From 11bb8a0034c232431f5287aabc1edc902bbc84da Mon Sep 17 00:00:00 2001 From: Mohamed Hegazy Date: Tue, 24 Feb 2015 13:36:51 -0800 Subject: [PATCH] Update LKG --- bin/lib.core.es6.d.ts | 114 +- bin/lib.es6.d.ts | 114 +- bin/tsc.js | 4320 ++-- bin/tsserver.js | 31943 +++++++++++++++++++++++++ bin/typescript.d.ts | 303 +- bin/typescript.js | 6175 ++--- bin/typescriptServices.d.ts | 303 +- bin/typescriptServices.js | 6175 ++--- bin/typescriptServices_internal.d.ts | 8 +- bin/typescript_internal.d.ts | 8 +- 10 files changed, 41743 insertions(+), 7720 deletions(-) create mode 100644 bin/tsserver.js diff --git a/bin/lib.core.es6.d.ts b/bin/lib.core.es6.d.ts index 13326cb1380..b3c400f11a2 100644 --- a/bin/lib.core.es6.d.ts +++ b/bin/lib.core.es6.d.ts @@ -1396,22 +1396,22 @@ interface ArrayLike { interface Array { /** Iterator */ - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, T]>; + entries(): IterableIterator<[number, T]>; /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -1495,7 +1495,7 @@ interface ArrayConstructor { interface String { /** Iterator */ - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; /** * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point @@ -1613,14 +1613,19 @@ interface IteratorResult { } interface Iterator { - [Symbol.iterator](): Iterator; next(): IteratorResult; + return?(value?: any): IteratorResult; + throw?(e?: any): IteratorResult; } interface Iterable { [Symbol.iterator](): Iterator; } +interface IterableIterator extends Iterator { + [Symbol.iterator](): IterableIterator; +} + interface GeneratorFunction extends Function { } @@ -1636,10 +1641,11 @@ interface GeneratorFunctionConstructor { } declare var GeneratorFunction: GeneratorFunctionConstructor; -interface Generator extends Iterator { +interface Generator extends IterableIterator { next(value?: any): IteratorResult; - throw (exception: any): IteratorResult; - return (value: T): IteratorResult; + throw(exception: any): IteratorResult; + return(value: T): IteratorResult; + [Symbol.iterator](): Generator; [Symbol.toStringTag]: string; } @@ -1807,15 +1813,15 @@ interface RegExp { interface Map { clear(): void; delete(key: K): boolean; - entries(): Iterator<[K, V]>; + entries(): IterableIterator<[K, V]>; forEach(callbackfn: (value: V, index: K, map: Map) => void, thisArg?: any): void; get(key: K): V; has(key: K): boolean; - keys(): Iterator; + keys(): IterableIterator; set(key: K, value?: V): Map; size: number; - values(): Iterator; - [Symbol.iterator]():Iterator<[K,V]>; + values(): IterableIterator; + [Symbol.iterator]():IterableIterator<[K,V]>; [Symbol.toStringTag]: string; } @@ -1846,13 +1852,13 @@ interface Set { add(value: T): Set; clear(): void; delete(value: T): boolean; - entries(): Iterator<[T, T]>; + entries(): IterableIterator<[T, T]>; forEach(callbackfn: (value: T, index: T, set: Set) => void, thisArg?: any): void; has(value: T): boolean; - keys(): Iterator; + keys(): IterableIterator; size: number; - values(): Iterator; - [Symbol.iterator]():Iterator; + values(): IterableIterator; + [Symbol.iterator]():IterableIterator; [Symbol.toStringTag]: string; } @@ -2083,7 +2089,7 @@ interface Int8Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -2163,7 +2169,7 @@ interface Int8Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -2300,10 +2306,10 @@ interface Int8Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Int8ArrayConstructor { @@ -2373,7 +2379,7 @@ interface Uint8Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -2453,7 +2459,7 @@ interface Uint8Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -2590,10 +2596,10 @@ interface Uint8Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint8ArrayConstructor { @@ -2663,7 +2669,7 @@ interface Uint8ClampedArray { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -2743,7 +2749,7 @@ interface Uint8ClampedArray { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -2880,10 +2886,10 @@ interface Uint8ClampedArray { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint8ClampedArrayConstructor { @@ -2953,7 +2959,7 @@ interface Int16Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3033,7 +3039,7 @@ interface Int16Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -3170,10 +3176,10 @@ interface Int16Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Int16ArrayConstructor { @@ -3243,7 +3249,7 @@ interface Uint16Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3323,7 +3329,7 @@ interface Uint16Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -3460,10 +3466,10 @@ interface Uint16Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint16ArrayConstructor { @@ -3533,7 +3539,7 @@ interface Int32Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3613,7 +3619,7 @@ interface Int32Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -3750,10 +3756,10 @@ interface Int32Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Int32ArrayConstructor { @@ -3823,7 +3829,7 @@ interface Uint32Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3903,7 +3909,7 @@ interface Uint32Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -4040,10 +4046,10 @@ interface Uint32Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint32ArrayConstructor { @@ -4113,7 +4119,7 @@ interface Float32Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -4193,7 +4199,7 @@ interface Float32Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -4330,10 +4336,10 @@ interface Float32Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Float32ArrayConstructor { @@ -4403,7 +4409,7 @@ interface Float64Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -4483,7 +4489,7 @@ interface Float64Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -4620,10 +4626,10 @@ interface Float64Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Float64ArrayConstructor { @@ -4682,7 +4688,7 @@ declare var Reflect: { construct(target: Function, argumentsList: ArrayLike): any; defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean; deleteProperty(target: any, propertyKey: PropertyKey): boolean; - enumerate(target: any): Iterator; + enumerate(target: any): IterableIterator; get(target: any, propertyKey: PropertyKey, receiver?: any): any; getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor; getPrototypeOf(target: any): any; diff --git a/bin/lib.es6.d.ts b/bin/lib.es6.d.ts index dfb025a0c36..935f78f1603 100644 --- a/bin/lib.es6.d.ts +++ b/bin/lib.es6.d.ts @@ -1396,22 +1396,22 @@ interface ArrayLike { interface Array { /** Iterator */ - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, T]>; + entries(): IterableIterator<[number, T]>; /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; /** * Returns the value of the first element in the array where predicate is true, and undefined @@ -1495,7 +1495,7 @@ interface ArrayConstructor { interface String { /** Iterator */ - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; /** * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point @@ -1613,14 +1613,19 @@ interface IteratorResult { } interface Iterator { - [Symbol.iterator](): Iterator; next(): IteratorResult; + return?(value?: any): IteratorResult; + throw?(e?: any): IteratorResult; } interface Iterable { [Symbol.iterator](): Iterator; } +interface IterableIterator extends Iterator { + [Symbol.iterator](): IterableIterator; +} + interface GeneratorFunction extends Function { } @@ -1636,10 +1641,11 @@ interface GeneratorFunctionConstructor { } declare var GeneratorFunction: GeneratorFunctionConstructor; -interface Generator extends Iterator { +interface Generator extends IterableIterator { next(value?: any): IteratorResult; - throw (exception: any): IteratorResult; - return (value: T): IteratorResult; + throw(exception: any): IteratorResult; + return(value: T): IteratorResult; + [Symbol.iterator](): Generator; [Symbol.toStringTag]: string; } @@ -1807,15 +1813,15 @@ interface RegExp { interface Map { clear(): void; delete(key: K): boolean; - entries(): Iterator<[K, V]>; + entries(): IterableIterator<[K, V]>; forEach(callbackfn: (value: V, index: K, map: Map) => void, thisArg?: any): void; get(key: K): V; has(key: K): boolean; - keys(): Iterator; + keys(): IterableIterator; set(key: K, value?: V): Map; size: number; - values(): Iterator; - [Symbol.iterator]():Iterator<[K,V]>; + values(): IterableIterator; + [Symbol.iterator]():IterableIterator<[K,V]>; [Symbol.toStringTag]: string; } @@ -1846,13 +1852,13 @@ interface Set { add(value: T): Set; clear(): void; delete(value: T): boolean; - entries(): Iterator<[T, T]>; + entries(): IterableIterator<[T, T]>; forEach(callbackfn: (value: T, index: T, set: Set) => void, thisArg?: any): void; has(value: T): boolean; - keys(): Iterator; + keys(): IterableIterator; size: number; - values(): Iterator; - [Symbol.iterator]():Iterator; + values(): IterableIterator; + [Symbol.iterator]():IterableIterator; [Symbol.toStringTag]: string; } @@ -2083,7 +2089,7 @@ interface Int8Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -2163,7 +2169,7 @@ interface Int8Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -2300,10 +2306,10 @@ interface Int8Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Int8ArrayConstructor { @@ -2373,7 +2379,7 @@ interface Uint8Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -2453,7 +2459,7 @@ interface Uint8Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -2590,10 +2596,10 @@ interface Uint8Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint8ArrayConstructor { @@ -2663,7 +2669,7 @@ interface Uint8ClampedArray { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -2743,7 +2749,7 @@ interface Uint8ClampedArray { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -2880,10 +2886,10 @@ interface Uint8ClampedArray { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint8ClampedArrayConstructor { @@ -2953,7 +2959,7 @@ interface Int16Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3033,7 +3039,7 @@ interface Int16Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -3170,10 +3176,10 @@ interface Int16Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Int16ArrayConstructor { @@ -3243,7 +3249,7 @@ interface Uint16Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3323,7 +3329,7 @@ interface Uint16Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -3460,10 +3466,10 @@ interface Uint16Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint16ArrayConstructor { @@ -3533,7 +3539,7 @@ interface Int32Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3613,7 +3619,7 @@ interface Int32Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -3750,10 +3756,10 @@ interface Int32Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Int32ArrayConstructor { @@ -3823,7 +3829,7 @@ interface Uint32Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -3903,7 +3909,7 @@ interface Uint32Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -4040,10 +4046,10 @@ interface Uint32Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Uint32ArrayConstructor { @@ -4113,7 +4119,7 @@ interface Float32Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -4193,7 +4199,7 @@ interface Float32Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -4330,10 +4336,10 @@ interface Float32Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Float32ArrayConstructor { @@ -4403,7 +4409,7 @@ interface Float64Array { /** * Returns an array of key, value pairs for every entry in the array */ - entries(): Iterator<[number, number]>; + entries(): IterableIterator<[number, number]>; /** * Determines whether all the members of an array satisfy the specified test. @@ -4483,7 +4489,7 @@ interface Float64Array { /** * Returns an list of keys in the array */ - keys(): Iterator; + keys(): IterableIterator; /** * Returns the index of the last occurrence of a value in an array. @@ -4620,10 +4626,10 @@ interface Float64Array { /** * Returns an list of values in the array */ - values(): Iterator; + values(): IterableIterator; [index: number]: number; - [Symbol.iterator] (): Iterator; + [Symbol.iterator](): IterableIterator; } interface Float64ArrayConstructor { @@ -4682,7 +4688,7 @@ declare var Reflect: { construct(target: Function, argumentsList: ArrayLike): any; defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean; deleteProperty(target: any, propertyKey: PropertyKey): boolean; - enumerate(target: any): Iterator; + enumerate(target: any): IterableIterator; get(target: any, propertyKey: PropertyKey, receiver?: any): any; getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor; getPrototypeOf(target: any): any; diff --git a/bin/tsc.js b/bin/tsc.js index 945a2115041..48eeb47befc 100644 --- a/bin/tsc.js +++ b/bin/tsc.js @@ -1021,6 +1021,10 @@ var ts; Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: 1, key: "Only a single variable declaration is allowed in a 'for...of' statement." }, The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: 1, key: "The variable declaration of a 'for...in' statement cannot have an initializer." }, The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: 1, key: "The variable declaration of a 'for...of' statement cannot have an initializer." }, + An_import_declaration_cannot_have_modifiers: { code: 1191, category: 1, key: "An import declaration cannot have modifiers." }, + External_module_0_has_no_default_export_or_export_assignment: { code: 1192, category: 1, key: "External module '{0}' has no default export or export assignment." }, + An_export_declaration_cannot_have_modifiers: { code: 1193, category: 1, key: "An export declaration cannot have modifiers." }, + Export_declarations_are_not_permitted_in_an_internal_module: { code: 1194, category: 1, key: "Export declarations are not permitted in an internal module." }, Duplicate_identifier_0: { code: 2300, category: 1, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: 1, 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: 1, key: "Static members cannot reference class type parameters." }, @@ -1149,7 +1153,7 @@ var ts; Ambient_external_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: 1, key: "Ambient external module declaration cannot specify relative module name." }, Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: 1, key: "Module '{0}' is hidden by a local declaration with the same name" }, Import_name_cannot_be_0: { code: 2438, category: 1, key: "Import name cannot be '{0}'" }, - Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name." }, + Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import or export declaration in an ambient external module declaration cannot reference external module through relative external module name." }, Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: 1, key: "Import declaration conflicts with local declaration of '{0}'" }, Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: { code: 2441, category: 1, key: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module." }, Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: 1, key: "Types have separate declarations of a private property '{0}'." }, @@ -1193,6 +1197,7 @@ var ts; Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: 1, key: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." }, for_of_statements_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 2482, category: 1, key: "'for...of' statements are only available when targeting ECMAScript 6 or higher." }, The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: 1, key: "The left-hand side of a 'for...of' statement cannot use a type annotation." }, + Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: 1, key: "Export declaration conflicts with exported declaration of '{0}'" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: 1, 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: 1, 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: 1, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -1344,17 +1349,18 @@ var ts; var ts; (function (ts) { var textToToken = { - "any": 110, - "boolean": 111, + "any": 112, + "as": 101, + "boolean": 113, "break": 65, "case": 66, "catch": 67, "class": 68, "continue": 70, "const": 69, - "constructor": 112, + "constructor": 114, "debugger": 71, - "declare": 113, + "declare": 115, "default": 72, "delete": 73, "do": 74, @@ -1365,43 +1371,44 @@ var ts; "false": 79, "finally": 80, "for": 81, + "from": 102, "function": 82, - "get": 114, + "get": 116, "if": 83, - "implements": 101, + "implements": 103, "import": 84, "in": 85, "instanceof": 86, - "interface": 102, - "let": 103, - "module": 115, + "interface": 104, + "let": 105, + "module": 117, "new": 87, "null": 88, - "number": 117, - "package": 104, - "private": 105, - "protected": 106, - "public": 107, - "require": 116, + "number": 119, + "package": 106, + "private": 107, + "protected": 108, + "public": 109, + "require": 118, "return": 89, - "set": 118, - "static": 108, - "string": 119, + "set": 120, + "static": 110, + "string": 121, "super": 90, "switch": 91, - "symbol": 120, + "symbol": 122, "this": 92, "throw": 93, "true": 94, "try": 95, - "type": 121, + "type": 123, "typeof": 96, "var": 97, "void": 98, "while": 99, "with": 100, - "yield": 109, - "of": 122, + "yield": 111, + "of": 124, "{": 14, "}": 15, "(": 16, @@ -2542,7 +2549,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 210) { + while (node && node.kind !== 220) { node = node.parent; } return node; @@ -2608,6 +2615,10 @@ var ts; return identifier.length >= 3 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 && identifier.charCodeAt(2) === 95 ? identifier.substr(1) : identifier; } ts.unescapeIdentifier = unescapeIdentifier; + function makeIdentifierFromModuleName(moduleName) { + return ts.getBaseFileName(moduleName).replace(/\W/g, "_"); + } + ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; function declarationNameToString(name) { return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); } @@ -2638,13 +2649,13 @@ var ts; function getErrorSpanForNode(node) { var errorSpan; switch (node.kind) { - case 191: - case 148: - case 194: - case 195: - case 198: + case 193: + case 150: + case 196: case 197: - case 209: + case 200: + case 199: + case 219: errorSpan = node.name; break; } @@ -2660,11 +2671,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 197 && isConst(node); + return node.kind === 199 && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 148 || isBindingPattern(node))) { + while (node && (node.kind === 150 || isBindingPattern(node))) { node = node.parent; } return node; @@ -2672,14 +2683,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 191) { + if (node.kind === 193) { node = node.parent; } - if (node && node.kind === 192) { + if (node && node.kind === 194) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 173) { + if (node && node.kind === 175) { flags |= node.flags; } return flags; @@ -2694,12 +2705,12 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 175 && node.expression.kind === 8; + return node.kind === 177 && node.expression.kind === 8; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node); - if (node.kind === 126 || node.kind === 125) { + if (node.kind === 128 || node.kind === 127) { return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); } else { @@ -2721,22 +2732,22 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 184: + case 186: return visitor(node); - case 172: - case 176: - case 177: + case 174: case 178: case 179: case 180: case 181: - case 185: - case 186: - case 203: - case 204: + case 182: + case 183: case 187: + case 188: + case 213: + case 214: case 189: - case 206: + case 191: + case 216: return ts.forEachChild(node, traverse); } } @@ -2745,22 +2756,22 @@ var ts; function isAnyFunction(node) { if (node) { switch (node.kind) { - case 131: - case 158: - case 193: - case 159: - case 130: - case 129: - case 132: case 133: + case 160: + case 195: + case 161: + case 132: + case 131: case 134: case 135: case 136: + case 137: case 138: - case 139: - case 158: - case 159: - case 193: + case 140: + case 141: + case 160: + case 161: + case 195: return true; } } @@ -2768,11 +2779,11 @@ var ts; } ts.isAnyFunction = isAnyFunction; function isFunctionBlock(node) { - return node && node.kind === 172 && isAnyFunction(node.parent); + return node && node.kind === 174 && isAnyFunction(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 130 && node.parent.kind === 150; + return node && node.kind === 132 && node.parent.kind === 152; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -2791,28 +2802,28 @@ var ts; return undefined; } switch (node.kind) { - case 124: - if (node.parent.parent.kind === 194) { + case 126: + if (node.parent.parent.kind === 196) { return node; } node = node.parent; break; - case 159: + case 161: if (!includeArrowFunctions) { continue; } - case 193: - case 158: - case 198: - case 128: - case 127: + case 195: + case 160: + case 200: case 130: case 129: - case 131: case 132: + case 131: case 133: - case 197: - case 210: + case 134: + case 135: + case 199: + case 220: return node; } } @@ -2824,32 +2835,32 @@ var ts; if (!node) return node; switch (node.kind) { - case 124: - if (node.parent.parent.kind === 194) { + case 126: + if (node.parent.parent.kind === 196) { return node; } node = node.parent; break; - case 193: - case 158: - case 159: + case 195: + case 160: + case 161: if (!includeFunctions) { continue; } - case 128: - case 127: case 130: case 129: - case 131: case 132: + case 131: case 133: + case 134: + case 135: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 155) { + if (node.kind === 157) { return node.tag; } return node.expression; @@ -2863,8 +2874,6 @@ var ts; case 94: case 79: case 9: - case 149: - case 150: case 151: case 152: case 153: @@ -2874,65 +2883,67 @@ var ts; case 157: case 158: case 159: - case 162: case 160: case 161: - case 163: case 164: + case 162: + case 163: case 165: case 166: - case 169: case 167: + case 168: + case 171: + case 169: case 10: - case 170: + case 172: return true; - case 123: - while (node.parent.kind === 123) { + case 125: + while (node.parent.kind === 125) { node = node.parent; } - return node.parent.kind === 140; + return node.parent.kind === 142; case 64: - if (node.parent.kind === 140) { + if (node.parent.kind === 142) { return true; } case 7: case 8: var parent = node.parent; switch (parent.kind) { - case 191: - case 126: + case 193: case 128: - case 127: - case 209: - case 207: - case 148: + case 130: + case 129: + case 219: + case 217: + case 150: return parent.initializer === node; - case 175: - case 176: case 177: case 178: - case 184: - case 185: - case 186: - case 203: - case 188: - case 186: - return parent.expression === node; case 179: + case 180: + case 186: + case 187: + case 188: + case 213: + case 190: + case 188: + return parent.expression === node; + case 181: var forStatement = parent; - return (forStatement.initializer === node && forStatement.initializer.kind !== 192) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 194) || forStatement.condition === node || forStatement.iterator === node; - case 180: - case 181: + case 182: + case 183: var forInStatement = parent; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 192) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 194) || forInStatement.expression === node; - case 156: + case 158: return node === parent.expression; - case 171: + case 173: return node === parent.expression; - case 124: + case 126: return node === parent.expression; default: if (isExpression(parent)) { @@ -2949,36 +2960,51 @@ var ts; (preserveConstEnums && moduleState === 2); } ts.isInstantiatedModule = isInstantiatedModule; - function isExternalModuleImportDeclaration(node) { - return node.kind === 200 && node.moduleReference.kind === 202; + function isExternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind === 212; } - ts.isExternalModuleImportDeclaration = isExternalModuleImportDeclaration; - function getExternalModuleImportDeclarationExpression(node) { - ts.Debug.assert(isExternalModuleImportDeclaration(node)); + ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; + function getExternalModuleImportEqualsDeclarationExpression(node) { + ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node)); return node.moduleReference.expression; } - ts.getExternalModuleImportDeclarationExpression = getExternalModuleImportDeclarationExpression; - function isInternalModuleImportDeclaration(node) { - return node.kind === 200 && node.moduleReference.kind !== 202; + ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; + function isInternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind !== 212; } - ts.isInternalModuleImportDeclaration = isInternalModuleImportDeclaration; + ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; + function getExternalModuleName(node) { + if (node.kind === 203) { + return node.moduleSpecifier; + } + if (node.kind === 202) { + var reference = node.moduleReference; + if (reference.kind === 212) { + return reference.expression; + } + } + if (node.kind === 209) { + return node.moduleSpecifier; + } + } + ts.getExternalModuleName = getExternalModuleName; function hasDotDotDotToken(node) { - return node && node.kind === 126 && node.dotDotDotToken !== undefined; + return node && node.kind === 128 && node.dotDotDotToken !== undefined; } ts.hasDotDotDotToken = hasDotDotDotToken; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 126: + case 128: return node.questionToken !== undefined; + case 132: + case 131: + return node.questionToken !== undefined; + case 218: + case 217: case 130: case 129: return node.questionToken !== undefined; - case 208: - case 207: - case 128: - case 127: - return node.questionToken !== undefined; } } return false; @@ -3001,7 +3027,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return node.kind === 147 || node.kind === 146; + return node.kind === 149 || node.kind === 148; } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -3016,27 +3042,31 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 125: - case 126: - case 191: - case 148: - case 128: case 127: - case 207: - case 208: - case 209: + case 128: + case 193: + case 150: case 130: case 129: - case 193: + case 217: + case 218: + case 219: case 132: - case 133: case 131: - case 194: case 195: + case 134: + case 135: + case 133: case 196: case 197: case 198: + case 199: case 200: + case 202: + case 204: + case 207: + case 205: + case 211: return true; } return false; @@ -3044,25 +3074,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 183: - case 182: - case 190: - case 177: - case 175: - case 174: - case 180: - case 181: - case 179: - case 176: - case 187: - case 184: - case 186: - case 93: - case 189: - case 173: - case 178: case 185: - case 201: + case 184: + case 192: + case 179: + case 177: + case 176: + case 182: + case 183: + case 181: + case 178: + case 189: + case 186: + case 188: + case 93: + case 191: + case 175: + case 180: + case 187: + case 208: return true; default: return false; @@ -3074,10 +3104,10 @@ var ts; return false; } var parent = name.parent; - if (isDeclaration(parent) || parent.kind === 158) { + if (isDeclaration(parent) || parent.kind === 160) { return parent.name === name; } - if (parent.kind === 206) { + if (parent.kind === 216) { return parent.name === name; } return false; @@ -3089,7 +3119,7 @@ var ts; } ts.getClassBaseTypeNode = getClassBaseTypeNode; function getClassImplementedTypeNodes(node) { - var heritageClause = getHeritageClause(node.heritageClauses, 101); + var heritageClause = getHeritageClause(node.heritageClauses, 103); return heritageClause ? heritageClause.types : undefined; } ts.getClassImplementedTypeNodes = getClassImplementedTypeNodes; @@ -3118,32 +3148,11 @@ var ts; } ts.tryResolveScriptReference = tryResolveScriptReference; function getAncestor(node, kind) { - switch (kind) { - case 194: - while (node) { - switch (node.kind) { - case 194: - return node; - case 197: - case 195: - case 196: - case 198: - case 200: - return undefined; - default: - node = node.parent; - continue; - } - } - break; - default: - while (node) { - if (node.kind === kind) { - return node; - } - node = node.parent; - } - break; + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; } return undefined; } @@ -3183,7 +3192,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 65 <= token && token <= 122; + return 65 <= token && token <= 124; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -3192,19 +3201,19 @@ var ts; ts.isTrivia = isTrivia; function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 124 && + declaration.name.kind === 126 && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; function isWellKnownSymbolSyntactically(node) { - return node.kind === 151 && isESSymbolIdentifier(node.expression); + return node.kind === 153 && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 64 || name.kind === 8 || name.kind === 7) { return name.text; } - if (name.kind === 124) { + if (name.kind === 126) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -3224,12 +3233,12 @@ var ts; ts.isESSymbolIdentifier = isESSymbolIdentifier; function isModifier(token) { switch (token) { + case 109: case 107: - case 105: - case 106: case 108: + case 110: case 77: - case 113: + case 115: case 69: return true; } @@ -3413,7 +3422,7 @@ var ts; })(ts || (ts = {})); var ts; (function (ts) { - var nodeConstructors = new Array(212); + var nodeConstructors = new Array(222); ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -3450,20 +3459,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 123: + case 125: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 125: + case 127: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 126: case 128: - case 127: - case 207: - case 208: - case 191: - case 148: + case 130: + case 129: + case 217: + case 218: + case 193: + case 150: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.dotDotDotToken) || @@ -3471,23 +3480,23 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 138: - case 139: - case 134: - case 135: + case 140: + case 141: case 136: + case 137: + case 138: return visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 130: - case 129: - case 131: case 132: + case 131: case 133: - case 158: - case 193: - case 159: + case 134: + case 135: + case 160: + case 195: + case 161: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || @@ -3496,178 +3505,198 @@ var ts; visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type) || visitNode(cbNode, node.body); - case 137: + case 139: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 140: - return visitNode(cbNode, node.exprName); - case 141: - return visitNodes(cbNodes, node.members); case 142: - return visitNode(cbNode, node.elementType); + return visitNode(cbNode, node.exprName); case 143: - return visitNodes(cbNodes, node.elementTypes); + return visitNodes(cbNodes, node.members); case 144: - return visitNodes(cbNodes, node.types); + return visitNode(cbNode, node.elementType); case 145: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.elementTypes); case 146: + return visitNodes(cbNodes, node.types); case 147: - return visitNodes(cbNodes, node.elements); + return visitNode(cbNode, node.type); + case 148: case 149: return visitNodes(cbNodes, node.elements); - case 150: - return visitNodes(cbNodes, node.properties); case 151: + return visitNodes(cbNodes, node.elements); + case 152: + return visitNodes(cbNodes, node.properties); + case 153: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.name); - case 152: + case 154: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 153: - case 154: + case 155: + case 156: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 155: + case 157: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 156: + case 158: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 157: - return visitNode(cbNode, node.expression); - case 160: - return visitNode(cbNode, node.expression); - case 161: + case 159: return visitNode(cbNode, node.expression); case 162: return visitNode(cbNode, node.expression); case 163: + return visitNode(cbNode, node.expression); + case 164: + return visitNode(cbNode, node.expression); + case 165: return visitNode(cbNode, node.operand); - case 168: + case 170: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 164: + case 166: return visitNode(cbNode, node.operand); - case 165: + case 167: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 166: + case 168: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.whenFalse); - case 169: + case 171: return visitNode(cbNode, node.expression); - case 172: - case 199: + case 174: + case 201: return visitNodes(cbNodes, node.statements); - case 210: + case 220: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 173: + case 175: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 192: + case 194: return visitNodes(cbNodes, node.declarations); - case 175: + case 177: return visitNode(cbNode, node.expression); - case 176: + case 178: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 177: + case 179: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 178: + case 180: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 179: + case 181: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.iterator) || visitNode(cbNode, node.statement); - case 180: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); - case 181: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); case 182: - case 183: - return visitNode(cbNode, node.label); - case 184: - return visitNode(cbNode, node.expression); - case 185: - return visitNode(cbNode, node.expression) || + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); + case 183: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 184: + case 185: + return visitNode(cbNode, node.label); case 186: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.clauses); - case 203: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.statements); - case 204: - return visitNodes(cbNodes, node.statements); + return visitNode(cbNode, node.expression); case 187: - return visitNode(cbNode, node.label) || + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 188: - return visitNode(cbNode, node.expression); + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.clauses); + case 213: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.statements); + case 214: + return visitNodes(cbNodes, node.statements); case 189: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 190: + return visitNode(cbNode, node.expression); + case 191: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 206: + case 216: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type) || visitNode(cbNode, node.block); - case 194: - return visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); - case 195: - return visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); case 196: return 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 197: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 209: - return visitNode(cbNode, node.name) || - visitNode(cbNode, node.initializer); case 198: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || - visitNode(cbNode, node.body); + visitNode(cbNode, node.type); + case 199: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.members); + case 219: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); case 200: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + case 202: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 201: + case 203: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier); + case 204: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + case 205: + return visitNode(cbNode, node.name); + case 206: + case 210: + return visitNodes(cbNodes, node.elements); + case 209: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier); + case 207: + case 211: + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + case 208: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportName); - case 167: + case 169: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 171: + case 173: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 124: + case 126: return visitNode(cbNode, node.expression); - case 205: + case 215: return visitNodes(cbNodes, node.types); - case 202: + case 212: return visitNode(cbNode, node.expression); } } @@ -3694,17 +3723,18 @@ var ts; 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; } } ; function modifierToFlag(token) { switch (token) { - case 108: return 128; - case 107: return 16; - case 106: return 64; - case 105: return 32; + case 110: return 128; + case 109: return 16; + case 108: return 64; + case 107: return 32; case 77: return 1; - case 113: return 2; + case 115: return 2; case 69: return 4096; } return 0; @@ -4019,7 +4049,7 @@ var ts; var identifierCount = 0; var nodeCount = 0; var token; - var sourceFile = createNode(210, 0); + var sourceFile = createNode(220, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -4174,10 +4204,10 @@ var ts; if (token === 64) { return true; } - if (token === 109 && inYieldContext()) { + if (token === 111 && inYieldContext()) { return false; } - return inStrictModeContext() ? token > 109 : token > 100; + return inStrictModeContext() ? token > 111 : token > 100; } function parseExpected(kind, diagnosticMessage) { if (token === kind) { @@ -4296,7 +4326,7 @@ var ts; return parseIdentifierName(); } function parseComputedPropertyName() { - var node = createNode(124); + var node = createNode(126); parseExpected(18); var yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { @@ -4323,6 +4353,10 @@ var ts; if (token === 69) { return nextToken() === 76; } + if (token === 77) { + nextToken(); + return token !== 35 && token !== 14 && canFollowModifier(); + } nextToken(); return canFollowModifier(); } @@ -4371,6 +4405,8 @@ var ts; return token === 23 || isStartOfType(); case 19: return isHeritageClause(); + case 20: + return isIdentifierOrKeyword(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); } @@ -4379,7 +4415,7 @@ var ts; return isIdentifier(); } function isNotHeritageClauseTypeName() { - if (token === 101 || + if (token === 103 || token === 78) { return lookAhead(nextTokenIsIdentifier); } @@ -4398,15 +4434,16 @@ var ts; case 7: case 13: case 10: + case 20: return token === 15; case 4: return token === 15 || token === 66 || token === 72; case 8: - return token === 14 || token === 78 || token === 101; + return token === 14 || token === 78 || token === 103; case 9: return isVariableDeclaratorListTerminator(); case 16: - return token === 25 || token === 16 || token === 14 || token === 78 || token === 101; + return token === 25 || token === 16 || token === 14 || token === 78 || token === 103; case 12: return token === 17 || token === 22; case 14: @@ -4434,7 +4471,7 @@ var ts; return false; } function isInSomeParsingContext() { - for (var kind = 0; kind < 20; kind++) { + for (var kind = 0; kind < 21; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -4545,12 +4582,14 @@ var ts; function isReusableModuleElement(node) { if (node) { switch (node.kind) { - case 200: - case 201: - case 194: - case 195: - case 198: + case 203: + case 202: + case 209: + case 208: + case 196: case 197: + case 200: + case 199: return true; } return isReusableStatement(node); @@ -4560,12 +4599,12 @@ var ts; function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 131: - case 136: - case 130: - case 132: case 133: - case 128: + case 138: + case 132: + case 134: + case 135: + case 130: return true; } } @@ -4574,8 +4613,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 203: - case 204: + case 213: + case 214: return true; } } @@ -4584,56 +4623,56 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 193: - case 173: - case 172: - case 176: + case 195: case 175: - case 188: - case 184: - case 186: - case 183: - case 182: - case 180: - case 181: - case 179: - case 178: - case 185: case 174: - case 189: - case 187: + case 178: case 177: case 190: + case 186: + case 188: + case 185: + case 184: + case 182: + case 183: + case 181: + case 180: + case 187: + case 176: + case 191: + case 189: + case 179: + case 192: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 209; + return node.kind === 219; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 135: + case 137: + case 131: + case 138: case 129: case 136: - case 127: - case 134: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 191) { + if (node.kind !== 193) { return false; } var variableDeclarator = node; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 126) { + if (node.kind !== 128) { return false; } var parameter = node; @@ -4702,7 +4741,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20)) { - var node = createNode(123, entity.pos); + var node = createNode(125, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -4719,7 +4758,7 @@ var ts; return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(167); + var template = createNode(169); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); var templateSpans = []; @@ -4732,7 +4771,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(171); + var span = createNode(173); span.expression = allowInAnd(parseExpression); var literal; if (token === 15) { @@ -4761,7 +4800,7 @@ var ts; return node; } function parseTypeReference() { - var node = createNode(137); + var node = createNode(139); node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); if (!scanner.hasPrecedingLineBreak() && token === 24) { node.typeArguments = parseBracketedList(17, parseType, 24, 25); @@ -4769,13 +4808,13 @@ var ts; return finishNode(node); } function parseTypeQuery() { - var node = createNode(140); + var node = createNode(142); parseExpected(96); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(125); + var node = createNode(127); node.name = parseIdentifier(); if (parseOptional(78)) { if (isStartOfType() || !isStartOfExpression()) { @@ -4808,7 +4847,7 @@ var ts; } } function parseParameter() { - var node = createNode(126); + var node = createNode(128); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21); node.name = inGeneratorParameterContext() ? doInYieldContext(parseIdentifierOrPattern) : parseIdentifierOrPattern(); @@ -4852,14 +4891,14 @@ var ts; return requireCompleteParameterList ? undefined : createMissingList(); } function parseTypeMemberSemicolon() { - if (parseSemicolon()) { + if (parseOptional(23)) { return; } - parseOptional(23); + parseSemicolon(); } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 135) { + if (kind === 137) { parseExpected(87); } fillSignature(51, false, false, node); @@ -4900,7 +4939,7 @@ var ts; } function parseIndexSignatureDeclaration(modifiers) { var fullStart = modifiers ? modifiers.pos : scanner.getStartPos(); - var node = createNode(136, fullStart); + var node = createNode(138, fullStart); setModifiers(node, modifiers); node.parameters = parseBracketedList(15, parseParameter, 18, 19); node.type = parseTypeAnnotation(); @@ -4912,7 +4951,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50); if (token === 16 || token === 24) { - var method = createNode(129, fullStart); + var method = createNode(131, fullStart); method.name = name; method.questionToken = questionToken; fillSignature(51, false, false, method); @@ -4920,7 +4959,7 @@ var ts; return finishNode(method); } else { - var property = createNode(127, fullStart); + var property = createNode(129, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -4962,12 +5001,12 @@ var ts; switch (token) { case 16: case 24: - return parseSignatureMember(134); + return parseSignatureMember(136); case 18: return isIndexSignature() ? parseIndexSignatureDeclaration(undefined) : parsePropertyOrMethodSignature(); case 87: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(135); + return parseSignatureMember(137); } case 8: case 7: @@ -4993,7 +5032,7 @@ var ts; return token === 16 || token === 24; } function parseTypeLiteral() { - var node = createNode(141); + var node = createNode(143); node.members = parseObjectTypeMembers(); return finishNode(node); } @@ -5009,12 +5048,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(143); + var node = createNode(145); node.elementTypes = parseBracketedList(18, parseType, 18, 19); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(145); + var node = createNode(147); parseExpected(16); node.type = parseType(); parseExpected(17); @@ -5022,7 +5061,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 139) { + if (kind === 141) { parseExpected(87); } fillSignature(32, false, false, node); @@ -5034,11 +5073,11 @@ var ts; } function parseNonArrayType() { switch (token) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: var node = tryParse(parseKeywordAndNoDot); return node || parseTypeReference(); case 98: @@ -5057,11 +5096,11 @@ var ts; } function isStartOfType() { switch (token) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: case 98: case 96: case 14: @@ -5083,7 +5122,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { parseExpected(19); - var node = createNode(142, type.pos); + var node = createNode(144, type.pos); node.elementType = type; type = finishNode(node); } @@ -5098,7 +5137,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(144, type.pos); + var node = createNode(146, type.pos); node.types = types; type = finishNode(node); } @@ -5143,10 +5182,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(138); + return parseFunctionOrConstructorType(140); } if (token === 87) { - return parseFunctionOrConstructorType(139); + return parseFunctionOrConstructorType(141); } return parseUnionTypeOrHigher(); } @@ -5182,7 +5221,7 @@ var ts; case 39: case 24: case 64: - case 109: + case 111: return true; default: if (isBinaryOperator()) { @@ -5229,7 +5268,7 @@ var ts; return parseConditionalExpressionRest(expr); } function isYieldExpression() { - if (token === 109) { + if (token === 111) { if (inYieldContext()) { return true; } @@ -5245,7 +5284,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(168); + var node = createNode(170); nextToken(); if (!scanner.hasPrecedingLineBreak() && (token === 35 || isStartOfExpression())) { @@ -5259,8 +5298,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(159, identifier.pos); - var parameter = createNode(126, identifier.pos); + var node = createNode(161, identifier.pos); + var parameter = createNode(128, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -5334,7 +5373,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(159); + var node = createNode(161); fillSignature(51, false, !allowAmbiguity, node); if (!node.parameters) { return undefined; @@ -5357,7 +5396,7 @@ var ts; if (!parseOptional(50)) { return leftOperand; } - var node = createNode(166, leftOperand.pos); + var node = createNode(168, leftOperand.pos); node.condition = leftOperand; node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(51); @@ -5369,7 +5408,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 85 || t === 122; + return t === 85 || t === 124; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -5430,33 +5469,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(165, left.pos); + var node = createNode(167, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(163); + var node = createNode(165); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(160); + var node = createNode(162); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(161); + var node = createNode(163); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(162); + var node = createNode(164); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -5486,7 +5525,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(isLeftHandSideExpression(expression)); if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(164, expression.pos); + var node = createNode(166, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -5507,14 +5546,14 @@ var ts; if (token === 16 || token === 20) { return expression; } - var node = createNode(151, expression.pos); + var node = createNode(153, expression.pos); node.expression = expression; parseExpected(20, 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(156); + var node = createNode(158); parseExpected(24); node.type = parseType(); parseExpected(25); @@ -5525,14 +5564,14 @@ var ts; while (true) { var dotOrBracketStart = scanner.getTokenPos(); if (parseOptional(20)) { - var propertyAccess = createNode(151, expression.pos); + var propertyAccess = createNode(153, expression.pos); propertyAccess.expression = expression; propertyAccess.name = parseRightSideOfDot(true); expression = finishNode(propertyAccess); continue; } if (parseOptional(18)) { - var indexedAccess = createNode(152, expression.pos); + var indexedAccess = createNode(154, expression.pos); indexedAccess.expression = expression; if (token !== 19) { indexedAccess.argumentExpression = allowInAnd(parseExpression); @@ -5546,7 +5585,7 @@ var ts; continue; } if (token === 10 || token === 11) { - var tagExpression = createNode(155, expression.pos); + var tagExpression = createNode(157, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 ? parseLiteralNode() : parseTemplateExpression(); expression = finishNode(tagExpression); @@ -5563,7 +5602,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(153, expression.pos); + var callExpr = createNode(155, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -5571,7 +5610,7 @@ var ts; continue; } else if (token === 16) { - var callExpr = createNode(153, expression.pos); + var callExpr = createNode(155, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -5656,26 +5695,26 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(157); + var node = createNode(159); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); return finishNode(node); } function parseSpreadElement() { - var node = createNode(169); + var node = createNode(171); parseExpected(21); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { - return token === 21 ? parseSpreadElement() : token === 23 ? createNode(170) : parseAssignmentExpressionOrHigher(); + return token === 21 ? parseSpreadElement() : token === 23 ? createNode(172) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return allowInAnd(parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(149); + var node = createNode(151); parseExpected(18); if (scanner.hasPrecedingLineBreak()) node.flags |= 256; @@ -5684,11 +5723,11 @@ var ts; return finishNode(node); } function tryParseAccessorDeclaration(fullStart, modifiers) { - if (parseContextualModifier(114)) { - return parseAccessorDeclaration(132, fullStart, modifiers); + if (parseContextualModifier(116)) { + return parseAccessorDeclaration(134, fullStart, modifiers); } - else if (parseContextualModifier(118)) { - return parseAccessorDeclaration(133, fullStart, modifiers); + else if (parseContextualModifier(120)) { + return parseAccessorDeclaration(135, fullStart, modifiers); } return undefined; } @@ -5708,13 +5747,13 @@ var ts; return parseMethodDeclaration(fullStart, modifiers, asteriskToken, propertyName, questionToken); } if ((token === 23 || token === 15) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(208, fullStart); + var shorthandDeclaration = createNode(218, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(207, fullStart); + var propertyAssignment = createNode(217, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51); @@ -5723,7 +5762,7 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(150); + var node = createNode(152); parseExpected(14); if (scanner.hasPrecedingLineBreak()) { node.flags |= 256; @@ -5733,7 +5772,7 @@ var ts; return finishNode(node); } function parseFunctionExpression() { - var node = createNode(158); + var node = createNode(160); parseExpected(82); node.asteriskToken = parseOptionalToken(35); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -5745,7 +5784,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(154); + var node = createNode(156); parseExpected(87); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -5755,7 +5794,7 @@ var ts; return finishNode(node); } function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(172); + var node = createNode(174); if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { node.statements = parseList(2, checkForStrictMode, parseStatement); parseExpected(15); @@ -5773,12 +5812,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(174); + var node = createNode(176); parseExpected(22); return finishNode(node); } function parseIfStatement() { - var node = createNode(176); + var node = createNode(178); parseExpected(83); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -5788,7 +5827,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(177); + var node = createNode(179); parseExpected(74); node.statement = parseStatement(); parseExpected(99); @@ -5799,7 +5838,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(178); + var node = createNode(180); parseExpected(99); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -5813,7 +5852,7 @@ var ts; parseExpected(16); var initializer = undefined; if (token !== 22) { - if (token === 97 || token === 103 || token === 69) { + if (token === 97 || token === 105 || token === 69) { initializer = parseVariableDeclarationList(true); } else { @@ -5822,21 +5861,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(85)) { - var forInStatement = createNode(180, pos); + var forInStatement = createNode(182, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(122)) { - var forOfStatement = createNode(181, pos); + else if (parseOptional(124)) { + var forOfStatement = createNode(183, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(179, pos); + var forStatement = createNode(181, pos); forStatement.initializer = initializer; parseExpected(22); if (token !== 22 && token !== 17) { @@ -5854,7 +5893,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 183 ? 65 : 70); + parseExpected(kind === 185 ? 65 : 70); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -5862,7 +5901,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(184); + var node = createNode(186); parseExpected(89); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -5871,7 +5910,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(185); + var node = createNode(187); parseExpected(100); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -5880,7 +5919,7 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(203); + var node = createNode(213); parseExpected(66); node.expression = allowInAnd(parseExpression); parseExpected(51); @@ -5888,7 +5927,7 @@ var ts; return finishNode(node); } function parseDefaultClause() { - var node = createNode(204); + var node = createNode(214); parseExpected(72); parseExpected(51); node.statements = parseList(4, false, parseStatement); @@ -5898,7 +5937,7 @@ var ts; return token === 66 ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(186); + var node = createNode(188); parseExpected(91); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -5909,14 +5948,14 @@ var ts; return finishNode(node); } function parseThrowStatement() { - var node = createNode(188); + var node = createNode(190); parseExpected(93); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); return finishNode(node); } function parseTryStatement() { - var node = createNode(189); + var node = createNode(191); parseExpected(95); node.tryBlock = parseBlock(false, false); node.catchClause = token === 67 ? parseCatchClause() : undefined; @@ -5927,7 +5966,7 @@ var ts; return finishNode(node); } function parseCatchClause() { - var result = createNode(206); + var result = createNode(216); parseExpected(67); parseExpected(16); result.name = parseIdentifier(); @@ -5937,7 +5976,7 @@ var ts; return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(190); + var node = createNode(192); parseExpected(71); parseSemicolon(); return finishNode(node); @@ -5946,13 +5985,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 64 && parseOptional(51)) { - var labeledStatement = createNode(187, fullStart); + var labeledStatement = createNode(189, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(175, fullStart); + var expressionStatement = createNode(177, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -5970,7 +6009,7 @@ var ts; return !inErrorRecovery; case 14: case 97: - case 103: + case 105: case 82: case 83: case 74: @@ -5990,18 +6029,18 @@ var ts; case 69: var isConstEnum = lookAhead(nextTokenIsEnumKeyword); return !isConstEnum; - case 102: + case 104: case 68: - case 115: + case 117: case 76: - case 121: + case 123: if (isDeclarationStart()) { return false; } + case 109: case 107: - case 105: - case 106: case 108: + case 110: if (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine)) { return false; } @@ -6037,9 +6076,9 @@ var ts; case 81: return parseForOrForInOrForOfStatement(); case 70: - return parseBreakOrContinueStatement(182); + return parseBreakOrContinueStatement(184); case 65: - return parseBreakOrContinueStatement(183); + return parseBreakOrContinueStatement(185); case 89: return parseReturnStatement(); case 100: @@ -6054,7 +6093,7 @@ var ts; return parseTryStatement(); case 71: return parseDebuggerStatement(); - case 103: + case 105: if (isLetDeclaration()) { return parseVariableStatement(scanner.getStartPos(), undefined); } @@ -6078,7 +6117,7 @@ var ts; return undefined; } return parseVariableStatement(start, modifiers); - case 103: + case 105: if (!isLetDeclaration()) { return undefined; } @@ -6099,16 +6138,16 @@ var ts; } function parseArrayBindingElement() { if (token === 23) { - return createNode(170); + return createNode(172); } - var node = createNode(148); + var node = createNode(150); node.dotDotDotToken = parseOptionalToken(21); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(148); + var node = createNode(150); var id = parsePropertyName(); if (id.kind === 64 && token !== 51) { node.name = id; @@ -6122,14 +6161,14 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(146); + var node = createNode(148); parseExpected(14); node.elements = parseDelimitedList(10, parseObjectBindingElement); parseExpected(15); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(147); + var node = createNode(149); parseExpected(18); node.elements = parseDelimitedList(11, parseArrayBindingElement); parseExpected(19); @@ -6148,7 +6187,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(191); + var node = createNode(193); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -6157,11 +6196,11 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(192); + var node = createNode(194); switch (token) { case 97: break; - case 103: + case 105: node.flags |= 2048; break; case 69: @@ -6171,7 +6210,7 @@ var ts; ts.Debug.fail(); } nextToken(); - if (token === 122 && lookAhead(canFollowContextualOfKeyword)) { + if (token === 124 && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { @@ -6186,14 +6225,14 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17; } function parseVariableStatement(fullStart, modifiers) { - var node = createNode(173, fullStart); + var node = createNode(175, fullStart); setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); parseSemicolon(); return finishNode(node); } function parseFunctionDeclaration(fullStart, modifiers) { - var node = createNode(193, fullStart); + var node = createNode(195, fullStart); setModifiers(node, modifiers); parseExpected(82); node.asteriskToken = parseOptionalToken(35); @@ -6203,15 +6242,15 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, modifiers) { - var node = createNode(131, pos); + var node = createNode(133, pos); setModifiers(node, modifiers); - parseExpected(112); + parseExpected(114); fillSignature(51, false, false, node); node.body = parseFunctionBlockOrSemicolon(false, ts.Diagnostics.or_expected); return finishNode(node); } function parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(130, fullStart); + var method = createNode(132, fullStart); setModifiers(method, modifiers); method.asteriskToken = asteriskToken; method.name = name; @@ -6228,7 +6267,7 @@ var ts; return parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected); } else { - var property = createNode(128, fullStart); + var property = createNode(130, fullStart); setModifiers(property, modifiers); property.name = name; property.questionToken = questionToken; @@ -6266,7 +6305,7 @@ var ts; return true; } if (idToken !== undefined) { - if (!ts.isKeyword(idToken) || idToken === 118 || idToken === 114) { + if (!ts.isKeyword(idToken) || idToken === 120 || idToken === 116) { return true; } switch (token) { @@ -6311,7 +6350,7 @@ var ts; if (accessor) { return accessor; } - if (token === 112) { + if (token === 114) { return parseConstructorDeclaration(fullStart, modifiers); } if (isIndexSignature()) { @@ -6327,7 +6366,7 @@ var ts; ts.Debug.fail("Should not have attempted to parse class member declaration."); } function parseClassDeclaration(fullStart, modifiers) { - var node = createNode(194, fullStart); + var node = createNode(196, fullStart); setModifiers(node, modifiers); parseExpected(68); node.name = parseIdentifier(); @@ -6352,8 +6391,8 @@ var ts; return parseList(19, false, parseHeritageClause); } function parseHeritageClause() { - if (token === 78 || token === 101) { - var node = createNode(205); + if (token === 78 || token === 103) { + var node = createNode(215); node.token = token; nextToken(); node.types = parseDelimitedList(8, parseTypeReference); @@ -6362,15 +6401,15 @@ var ts; return undefined; } function isHeritageClause() { - return token === 78 || token === 101; + return token === 78 || token === 103; } function parseClassMembers() { return parseList(6, false, parseClassElement); } function parseInterfaceDeclaration(fullStart, modifiers) { - var node = createNode(195, fullStart); + var node = createNode(197, fullStart); setModifiers(node, modifiers); - parseExpected(102); + parseExpected(104); node.name = parseIdentifier(); node.typeParameters = parseTypeParameters(); node.heritageClauses = parseHeritageClauses(false); @@ -6378,9 +6417,9 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, modifiers) { - var node = createNode(196, fullStart); + var node = createNode(198, fullStart); setModifiers(node, modifiers); - parseExpected(121); + parseExpected(123); node.name = parseIdentifier(); parseExpected(52); node.type = parseType(); @@ -6388,13 +6427,13 @@ var ts; return finishNode(node); } function parseEnumMember() { - var node = createNode(209, scanner.getStartPos()); + var node = createNode(219, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, modifiers) { - var node = createNode(197, fullStart); + var node = createNode(199, fullStart); setModifiers(node, modifiers); parseExpected(76); node.name = parseIdentifier(); @@ -6408,7 +6447,7 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(199, scanner.getStartPos()); + var node = createNode(201, scanner.getStartPos()); if (parseExpected(14)) { node.statements = parseList(1, false, parseModuleElement); parseExpected(15); @@ -6419,7 +6458,7 @@ var ts; return finishNode(node); } function parseInternalModuleTail(fullStart, modifiers, flags) { - var node = createNode(198, fullStart); + var node = createNode(200, fullStart); setModifiers(node, modifiers); node.flags |= flags; node.name = parseIdentifier(); @@ -6427,49 +6466,144 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, modifiers) { - var node = createNode(198, fullStart); + var node = createNode(200, fullStart); setModifiers(node, modifiers); node.name = parseLiteralNode(true); node.body = parseModuleBlock(); return finishNode(node); } function parseModuleDeclaration(fullStart, modifiers) { - parseExpected(115); + parseExpected(117); return token === 8 ? parseAmbientExternalModuleDeclaration(fullStart, modifiers) : parseInternalModuleTail(fullStart, modifiers, modifiers ? modifiers.flags : 0); } function isExternalModuleReference() { - return token === 116 && + return token === 118 && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { return nextToken() === 16; } - function parseImportDeclaration(fullStart, modifiers) { - var node = createNode(200, fullStart); - setModifiers(node, modifiers); + function nextTokenIsCommaOrFromKeyword() { + nextToken(); + return token === 23 || + token === 102; + } + function parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers) { parseExpected(84); - node.name = parseIdentifier(); - parseExpected(52); - node.moduleReference = parseModuleReference(); + var afterImportPos = scanner.getStartPos(); + var identifier; + if (isIdentifier()) { + identifier = parseIdentifier(); + if (token !== 23 && token !== 102) { + var importEqualsDeclaration = createNode(202, fullStart); + setModifiers(importEqualsDeclaration, modifiers); + importEqualsDeclaration.name = identifier; + parseExpected(52); + importEqualsDeclaration.moduleReference = parseModuleReference(); + parseSemicolon(); + return finishNode(importEqualsDeclaration); + } + } + var importDeclaration = createNode(203, fullStart); + setModifiers(importDeclaration, modifiers); + if (identifier || + token === 35 || + token === 14) { + importDeclaration.importClause = parseImportClause(identifier, afterImportPos); + parseExpected(102); + } + importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); - return finishNode(node); + return finishNode(importDeclaration); + } + function parseImportClause(identifier, fullStart) { + var importClause = createNode(204, fullStart); + if (identifier) { + importClause.name = identifier; + } + if (!importClause.name || + parseOptional(23)) { + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(206); + } + return finishNode(importClause); } function parseModuleReference() { return isExternalModuleReference() ? parseExternalModuleReference() : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(202); - parseExpected(116); + var node = createNode(212); + parseExpected(118); parseExpected(16); - node.expression = parseExpression(); - if (node.expression.kind === 8) { - internIdentifier(node.expression.text); - } + node.expression = parseModuleSpecifier(); parseExpected(17); return finishNode(node); } + function parseModuleSpecifier() { + var result = parseExpression(); + if (result.kind === 8) { + internIdentifier(result.text); + } + return result; + } + function parseNamespaceImport() { + var namespaceImport = createNode(205); + parseExpected(35); + parseExpected(101); + namespaceImport.name = parseIdentifier(); + return finishNode(namespaceImport); + } + function parseNamedImportsOrExports(kind) { + var node = createNode(kind); + node.elements = parseBracketedList(20, kind === 206 ? parseImportSpecifier : parseExportSpecifier, 14, 15); + return finishNode(node); + } + function parseExportSpecifier() { + return parseImportOrExportSpecifier(211); + } + function parseImportSpecifier() { + return parseImportOrExportSpecifier(207); + } + function parseImportOrExportSpecifier(kind) { + var node = createNode(kind); + var isFirstIdentifierNameNotAnIdentifier = ts.isKeyword(token) && !isIdentifier(); + var start = scanner.getTokenPos(); + var identifierName = parseIdentifierName(); + if (token === 101) { + node.propertyName = identifierName; + parseExpected(101); + if (isIdentifier()) { + node.name = parseIdentifierName(); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected); + } + } + else { + node.name = identifierName; + if (isFirstIdentifierNameNotAnIdentifier) { + parseErrorAtPosition(start, identifierName.end - start, ts.Diagnostics.Identifier_expected); + } + } + return finishNode(node); + } + function parseExportDeclaration(fullStart, modifiers) { + var node = createNode(209, fullStart); + setModifiers(node, modifiers); + if (parseOptional(35)) { + parseExpected(102); + node.moduleSpecifier = parseModuleSpecifier(); + } + else { + node.exportClause = parseNamedImportsOrExports(210); + if (parseOptional(102)) { + node.moduleSpecifier = parseModuleSpecifier(); + } + } + parseSemicolon(); + return finishNode(node); + } function parseExportAssignmentTail(fullStart, modifiers) { - var node = createNode(201, fullStart); + var node = createNode(208, fullStart); setModifiers(node, modifiers); node.exportName = parseIdentifier(); parseSemicolon(); @@ -6484,23 +6618,24 @@ var ts; case 69: case 82: return true; - case 103: + case 105: return isLetDeclaration(); case 68: - case 102: + case 104: case 76: - case 84: - case 121: + case 123: return lookAhead(nextTokenIsIdentifierOrKeyword); - case 115: + case 84: + return lookAhead(nextTokenCanFollowImportKeyword); + case 117: return lookAhead(nextTokenIsIdentifierOrKeywordOrStringLiteral); case 77: - return lookAhead(nextTokenIsEqualsTokenOrDeclarationStart); - case 113: + return lookAhead(nextTokenCanFollowExportKeyword); + case 115: + case 109: case 107: - case 105: - case 106: case 108: + case 110: return lookAhead(nextTokenIsDeclarationStart); } } @@ -6515,14 +6650,23 @@ var ts; nextToken(); return isIdentifierOrKeyword() || token === 8; } - function nextTokenIsEqualsTokenOrDeclarationStart() { + function nextTokenCanFollowImportKeyword() { nextToken(); - return token === 52 || isDeclarationStart(); + return isIdentifierOrKeyword() || token === 8 || + token === 35 || token === 14; + } + function nextTokenCanFollowExportKeyword() { + nextToken(); + return token === 52 || token === 35 || + token === 14 || isDeclarationStart(); } function nextTokenIsDeclarationStart() { nextToken(); return isDeclarationStart(); } + function nextTokenIsAsKeyword() { + return nextToken() === 101; + } function parseDeclaration() { var fullStart = getNodePos(); var modifiers = parseModifiers(); @@ -6531,26 +6675,29 @@ var ts; if (parseOptional(52)) { return parseExportAssignmentTail(fullStart, modifiers); } + if (token === 35 || token === 14) { + return parseExportDeclaration(fullStart, modifiers); + } } switch (token) { case 97: - case 103: + case 105: case 69: return parseVariableStatement(fullStart, modifiers); case 82: return parseFunctionDeclaration(fullStart, modifiers); case 68: return parseClassDeclaration(fullStart, modifiers); - case 102: + case 104: return parseInterfaceDeclaration(fullStart, modifiers); - case 121: + case 123: return parseTypeAliasDeclaration(fullStart, modifiers); case 76: return parseEnumDeclaration(fullStart, modifiers); - case 115: + case 117: return parseModuleDeclaration(fullStart, modifiers); case 84: - return parseImportDeclaration(fullStart, modifiers); + return parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers); default: ts.Debug.fail("Mismatch between isDeclarationStart and parseDeclaration"); } @@ -6623,28 +6770,28 @@ var ts; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { - return node.flags & 1 || node.kind === 200 && node.moduleReference.kind === 202 || node.kind === 201 ? node : undefined; + return node.flags & 1 || node.kind === 202 && node.moduleReference.kind === 212 || node.kind === 203 || node.kind === 208 || node.kind === 209 ? node : undefined; }); } } function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 151: - case 152: - case 154: case 153: + case 154: + case 156: case 155: - case 149: case 157: - case 150: - case 158: + case 151: + case 159: + case 152: + case 160: case 64: case 9: case 7: case 8: case 10: - case 167: + case 169: case 79: case 88: case 92: @@ -6665,16 +6812,16 @@ var ts; (function (ts) { ts.bindTime = 0; function getModuleInstanceState(node) { - if (node.kind === 195 || node.kind === 196) { + if (node.kind === 197 || node.kind === 198) { return 0; } else if (ts.isConstEnumDeclaration(node)) { return 2; } - else if (node.kind === 200 && !(node.flags & 1)) { + else if ((node.kind === 203 || node.kind === 202) && !(node.flags & 1)) { return 0; } - else if (node.kind === 199) { + else if (node.kind === 201) { var state = 0; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -6690,7 +6837,7 @@ var ts; }); return state; } - else if (node.kind === 198) { + else if (node.kind === 200) { return getModuleInstanceState(node.body); } else { @@ -6736,10 +6883,10 @@ var ts; } function getDeclarationName(node) { if (node.name) { - if (node.kind === 198 && node.name.kind === 8) { + if (node.kind === 200 && node.name.kind === 8) { return '"' + node.name.text + '"'; } - if (node.name.kind === 124) { + if (node.name.kind === 126) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -6747,15 +6894,15 @@ var ts; return node.name.text; } switch (node.kind) { - case 139: - case 131: + case 141: + case 133: return "__constructor"; - case 138: - case 134: - return "__call"; - case 135: - return "__new"; + case 140: case 136: + return "__call"; + case 137: + return "__new"; + case 138: return "__index"; } } @@ -6784,7 +6931,7 @@ var ts; } addDeclarationToSymbol(symbol, node, includes); symbol.parent = parent; - if (node.kind === 194 && symbol.exports) { + if (node.kind === 196 && symbol.exports) { var prototypeSymbol = createSymbol(4 | 134217728, "prototype"); if (ts.hasProperty(symbol.exports, prototypeSymbol.name)) { if (node.name) { @@ -6806,29 +6953,28 @@ var ts; return false; } function declareModuleMember(node, symbolKind, symbolExcludes) { - var exportKind = 0; - if (symbolKind & 107455) { - exportKind |= 1048576; + var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; + if (symbolKind & 8388608) { + if (node.kind === 211 || (node.kind === 202 && hasExportModifier)) { + declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + } + else { + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); + } } - if (symbolKind & 793056) { - exportKind |= 2097152; - } - if (symbolKind & 1536) { - exportKind |= 4194304; - } - if (ts.getCombinedNodeFlags(node) & 1 || (node.kind !== 200 && isAmbientContext(container))) { - if (exportKind) { + else { + if (hasExportModifier || isAmbientContext(container)) { + var exportKind = (symbolKind & 107455 ? 1048576 : 0) | + (symbolKind & 793056 ? 2097152 : 0) | + (symbolKind & 1536 ? 4194304 : 0); var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes); local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); node.localSymbol = local; } else { - declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); } } - else { - declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); - } } function bindChildren(node, symbolKind, isBlockScopeContainer) { if (symbolKind & 255504) { @@ -6855,40 +7001,40 @@ var ts; } function bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer) { switch (container.kind) { - case 198: + case 200: declareModuleMember(node, symbolKind, symbolExcludes); break; - case 210: + case 220: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolKind, symbolExcludes); break; } + case 140: + case 141: + case 136: + case 137: case 138: - case 139: + case 132: + case 131: + case 133: case 134: case 135: - case 136: - case 130: - case 129: - case 131: - case 132: - case 133: - case 193: - case 158: - case 159: + case 195: + case 160: + case 161: declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); break; - case 194: + case 196: if (node.flags & 128) { declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } - case 141: - case 150: - case 195: + case 143: + case 152: + case 197: declareSymbol(container.symbol.members, container.symbol, node, symbolKind, symbolExcludes); break; - case 197: + case 199: declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } @@ -6914,6 +7060,12 @@ var ts; } } } + function bindExportDeclaration(node) { + if (!node.exportClause) { + (container.exportStars || (container.exportStars = [])).push(node); + } + bindChildren(node, 0, false); + } function bindFunctionOrConstructorType(node) { var symbol = createSymbol(131072, getDeclarationName(node)); addDeclarationToSymbol(symbol, node, 131072); @@ -6921,7 +7073,7 @@ var ts; var typeLiteralSymbol = createSymbol(2048, "__type"); addDeclarationToSymbol(typeLiteralSymbol, node, 2048); typeLiteralSymbol.members = {}; - typeLiteralSymbol.members[node.kind === 138 ? "__call" : "__new"] = symbol; + typeLiteralSymbol.members[node.kind === 140 ? "__call" : "__new"] = symbol; } function bindAnonymousDeclaration(node, symbolKind, name, isBlockScopeContainer) { var symbol = createSymbol(symbolKind, name); @@ -6940,10 +7092,10 @@ var ts; } function bindBlockScopedVariableDeclaration(node) { switch (blockScopeContainer.kind) { - case 198: + case 200: declareModuleMember(node, 2, 107455); break; - case 210: + case 220: if (ts.isExternalModule(container)) { declareModuleMember(node, 2, 107455); break; @@ -6962,14 +7114,14 @@ var ts; function bind(node) { node.parent = parent; switch (node.kind) { - case 125: + case 127: bindDeclaration(node, 262144, 530912, false); break; - case 126: + case 128: bindParameter(node); break; - case 191: - case 148: + case 193: + case 150: if (ts.isBindingPattern(node.name)) { bindChildren(node, 0, false); } @@ -6980,65 +7132,65 @@ var ts; bindDeclaration(node, 1, 107454, false); } break; - case 128: - case 127: - bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); - break; - case 207: - case 208: - bindPropertyOrMethodOrAccessor(node, 4, 107455, false); - break; - case 209: - bindPropertyOrMethodOrAccessor(node, 8, 107455, false); - break; - case 134: - case 135: - case 136: - bindDeclaration(node, 131072, 0, false); - break; case 130: case 129: - bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); + bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); break; - case 193: - bindDeclaration(node, 16, 106927, true); + case 217: + case 218: + bindPropertyOrMethodOrAccessor(node, 4, 107455, false); break; - case 131: - bindDeclaration(node, 16384, 0, true); + case 219: + bindPropertyOrMethodOrAccessor(node, 8, 107455, false); + break; + case 136: + case 137: + case 138: + bindDeclaration(node, 131072, 0, false); break; case 132: - bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); - break; - case 133: - bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); - break; - case 138: - case 139: - bindFunctionOrConstructorType(node); - break; - case 141: - bindAnonymousDeclaration(node, 2048, "__type", false); - break; - case 150: - bindAnonymousDeclaration(node, 4096, "__object", false); - break; - case 158: - case 159: - bindAnonymousDeclaration(node, 16, "__function", true); - break; - case 206: - bindCatchVariableDeclaration(node); - break; - case 194: - bindDeclaration(node, 32, 899583, false); + case 131: + bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); break; case 195: - bindDeclaration(node, 64, 792992, false); + bindDeclaration(node, 16, 106927, true); + break; + case 133: + bindDeclaration(node, 16384, 0, true); + break; + case 134: + bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); + break; + case 135: + bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); + break; + case 140: + case 141: + bindFunctionOrConstructorType(node); + break; + case 143: + bindAnonymousDeclaration(node, 2048, "__type", false); + break; + case 152: + bindAnonymousDeclaration(node, 4096, "__object", false); + break; + case 160: + case 161: + bindAnonymousDeclaration(node, 16, "__function", true); + break; + case 216: + bindCatchVariableDeclaration(node); break; case 196: - bindDeclaration(node, 524288, 793056, false); + bindDeclaration(node, 32, 899583, false); break; case 197: + bindDeclaration(node, 64, 792992, false); + break; + case 198: + bindDeclaration(node, 524288, 793056, false); + break; + case 199: if (ts.isConst(node)) { bindDeclaration(node, 128, 899967, false); } @@ -7046,25 +7198,39 @@ var ts; bindDeclaration(node, 256, 899327, false); } break; - case 198: + case 200: bindModuleDeclaration(node); break; - case 200: + case 202: + case 205: + case 207: + case 211: bindDeclaration(node, 8388608, 8388608, false); break; - case 210: + case 209: + bindExportDeclaration(node); + break; + case 204: + if (node.name) { + bindDeclaration(node, 8388608, 8388608, false); + } + else { + bindChildren(node, 0, false); + } + break; + case 220: if (ts.isExternalModule(node)) { bindAnonymousDeclaration(node, 512, '"' + ts.removeFileExtension(node.fileName) + '"', true); break; } - case 172: + case 174: bindChildren(node, 0, !ts.isAnyFunction(node.parent)); break; - case 206: - case 179: - case 180: + case 216: case 181: - case 186: + case 182: + case 183: + case 188: bindChildren(node, 0, true); break; default: @@ -7082,8 +7248,8 @@ var ts; bindDeclaration(node, 1, 107455, false); } if (node.flags & 112 && - node.parent.kind === 131 && - node.parent.parent.kind === 194) { + node.parent.kind === 133 && + node.parent.parent.kind === 196) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -7276,7 +7442,7 @@ var ts; recordMergedSymbol(result, symbol); return result; } - function extendSymbol(target, source) { + function mergeSymbol(target, source) { if (!(target.flags & getExcludedSymbolFlags(source.flags))) { if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) { target.constEnumOnlyModule = false; @@ -7290,12 +7456,12 @@ var ts; if (source.members) { if (!target.members) target.members = {}; - extendSymbolTable(target.members, source.members); + mergeSymbolTable(target.members, source.members); } if (source.exports) { if (!target.exports) target.exports = {}; - extendSymbolTable(target.exports, source.exports); + mergeSymbolTable(target.exports, source.exports); } recordMergedSymbol(target, source); } @@ -7318,7 +7484,7 @@ var ts; } return result; } - function extendSymbolTable(target, source) { + function mergeSymbolTable(target, source) { for (var id in source) { if (ts.hasProperty(source, id)) { if (!ts.hasProperty(target, id)) { @@ -7329,11 +7495,18 @@ var ts; if (!(symbol.flags & 33554432)) { target[id] = symbol = cloneSymbol(symbol); } - extendSymbol(symbol, source[id]); + mergeSymbol(symbol, source[id]); } } } } + function extendSymbolTable(target, source) { + for (var id in source) { + if (!ts.hasProperty(target, id)) { + target[id] = source[id]; + } + } + } function getSymbolLinks(symbol) { if (symbol.flags & 67108864) return symbol; @@ -7347,10 +7520,10 @@ var ts; return nodeLinks[node.id] || (nodeLinks[node.id] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 210); + return ts.getAncestor(node, 220); } function isGlobalSourceFile(node) { - return node.kind === 210 && !ts.isExternalModule(node); + return node.kind === 220 && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -7391,22 +7564,25 @@ var ts; } } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) break; - case 198: + case 200: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - break loop; + if (!(result.flags & 8388608 && getDeclarationOfImportSymbol(result).kind === 211)) { + break loop; + } + result = undefined; } break; - case 197: + case 199: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { break loop; } break; - case 128: - case 127: - if (location.parent.kind === 194 && !(location.flags & 128)) { + case 130: + case 129: + if (location.parent.kind === 196 && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -7415,8 +7591,8 @@ var ts; } } break; - case 194: - case 195: + case 196: + case 197: 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); @@ -7425,28 +7601,28 @@ var ts; break loop; } break; - case 124: + case 126: var grandparent = location.parent.parent; - if (grandparent.kind === 194 || grandparent.kind === 195) { + if (grandparent.kind === 196 || grandparent.kind === 197) { 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 130: - case 129: - case 131: case 132: + case 131: case 133: - case 193: - case 159: + case 134: + case 135: + case 195: + case 161: if (name === "arguments") { result = argumentsSymbol; break loop; } break; - case 158: + case 160: if (name === "arguments") { result = argumentsSymbol; break loop; @@ -7457,7 +7633,7 @@ var ts; break loop; } break; - case 206: + case 216: var id = location.name; if (name === id.text) { result = location.symbol; @@ -7493,18 +7669,78 @@ var ts; } return result; } + function isImportSymbolDeclaration(node) { + return node.kind === 202 || + node.kind === 204 && !!node.name || + node.kind === 205 || + node.kind === 207 || + node.kind === 211; + } + function getDeclarationOfImportSymbol(symbol) { + return ts.forEach(symbol.declarations, function (d) { return isImportSymbolDeclaration(d) ? d : undefined; }); + } + function getTargetOfImportEqualsDeclaration(node) { + if (node.moduleReference.kind === 212) { + var moduleSymbol = resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node)); + var exportAssignmentSymbol = moduleSymbol && getResolvedExportAssignmentSymbol(moduleSymbol); + return exportAssignmentSymbol || moduleSymbol; + } + return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); + } + function getTargetOfImportClause(node) { + var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); + if (moduleSymbol) { + var exportAssignmentSymbol = getResolvedExportAssignmentSymbol(moduleSymbol); + if (!exportAssignmentSymbol) { + error(node.name, ts.Diagnostics.External_module_0_has_no_default_export_or_export_assignment, symbolToString(moduleSymbol)); + } + return exportAssignmentSymbol; + } + } + function getTargetOfNamespaceImport(node) { + return resolveExternalModuleName(node, node.parent.parent.moduleSpecifier); + } + function getExternalModuleMember(node, specifier) { + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleSymbol) { + var name = specifier.propertyName || specifier.name; + if (name.text) { + var symbol = getSymbol(getExportsOfSymbol(moduleSymbol), name.text, 107455 | 793056 | 1536); + if (!symbol) { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(moduleSymbol), ts.declarationNameToString(name)); + return; + } + return symbol.flags & (107455 | 793056 | 1536) ? symbol : resolveImport(symbol); + } + } + } + function getTargetOfImportSpecifier(node) { + return getExternalModuleMember(node.parent.parent.parent, node); + } + function getTargetOfExportSpecifier(node) { + return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : resolveEntityName(node, node.propertyName || node.name, 107455 | 793056 | 1536); + } + function getTargetOfImportDeclaration(node) { + switch (node.kind) { + case 202: + return getTargetOfImportEqualsDeclaration(node); + case 204: + return getTargetOfImportClause(node); + case 205: + return getTargetOfNamespaceImport(node); + case 207: + return getTargetOfImportSpecifier(node); + case 211: + return getTargetOfExportSpecifier(node); + } + } function resolveImport(symbol) { ts.Debug.assert((symbol.flags & 8388608) !== 0, "Should only get Imports here."); var links = getSymbolLinks(symbol); if (!links.target) { links.target = resolvingSymbol; - var node = ts.getDeclarationOfKind(symbol, 200); - if (node.moduleReference.kind === 202) { - if (node.moduleReference.expression.kind !== 8) { - grammarErrorOnNode(node.moduleReference.expression, ts.Diagnostics.String_literal_expected); - } - } - var target = node.moduleReference.kind === 202 ? resolveExternalModuleName(node, ts.getExternalModuleImportDeclarationExpression(node)) : getSymbolOfPartOfRightHandSideOfImport(node.moduleReference, node); + var node = getDeclarationOfImportSymbol(symbol); + var target = getTargetOfImportDeclaration(node); if (links.target === resolvingSymbol) { links.target = target || unknownSymbol; } @@ -7517,19 +7753,19 @@ var ts; } return links.target; } - function getSymbolOfPartOfRightHandSideOfImport(entityName, importDeclaration) { + function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 200); + importDeclaration = ts.getAncestor(entityName, 202); ts.Debug.assert(importDeclaration !== undefined); } if (entityName.kind === 64 && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { entityName = entityName.parent; } - if (entityName.kind === 64 || entityName.parent.kind === 123) { + if (entityName.kind === 64 || entityName.parent.kind === 125) { return resolveEntityName(importDeclaration, entityName, 1536); } else { - ts.Debug.assert(entityName.parent.kind === 200); + ts.Debug.assert(entityName.parent.kind === 202); return resolveEntityName(importDeclaration, entityName, 107455 | 793056 | 1536); } } @@ -7546,11 +7782,11 @@ var ts; return; } } - else if (name.kind === 123) { + else if (name.kind === 125) { var namespace = resolveEntityName(location, name.left, 1536); if (!namespace || namespace === unknownSymbol || ts.getFullWidth(name.right) === 0) return; - var symbol = getSymbol(namespace.exports, name.right.text, meaning); + var symbol = getSymbol(getExportsOfSymbol(namespace), name.right.text, meaning); if (!symbol) { error(location, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(name.right)); return; @@ -7575,7 +7811,7 @@ var ts; if (!isRelative) { var symbol = getSymbol(globals, '"' + moduleName + '"', 512); if (symbol) { - return getResolvedExportSymbol(symbol); + return symbol; } } while (true) { @@ -7590,14 +7826,14 @@ var ts; } if (sourceFile) { if (sourceFile.symbol) { - return getResolvedExportSymbol(sourceFile.symbol); + return sourceFile.symbol; } error(moduleReferenceLiteral, ts.Diagnostics.File_0_is_not_an_external_module, sourceFile.fileName); return; } error(moduleReferenceLiteral, ts.Diagnostics.Cannot_find_external_module_0, moduleName); } - function getResolvedExportSymbol(moduleSymbol) { + function getResolvedExportAssignmentSymbol(moduleSymbol) { var symbol = getExportAssignmentSymbol(moduleSymbol); if (symbol) { if (symbol.flags & (107455 | 793056 | 1536)) { @@ -7607,16 +7843,14 @@ var ts; return resolveImport(symbol); } } - return moduleSymbol; } function getExportAssignmentSymbol(symbol) { checkTypeOfExportAssignmentSymbol(symbol); - var symbolLinks = getSymbolLinks(symbol); - return symbolLinks.exportAssignSymbol === unknownSymbol ? undefined : symbolLinks.exportAssignSymbol; + return getSymbolLinks(symbol).exportAssignmentSymbol; } function checkTypeOfExportAssignmentSymbol(containerSymbol) { var symbolLinks = getSymbolLinks(containerSymbol); - if (!symbolLinks.exportAssignSymbol) { + if (!symbolLinks.exportAssignmentChecked) { var exportInformation = collectExportInformationForSourceFileOrModule(containerSymbol); if (exportInformation.exportAssignments.length) { if (exportInformation.exportAssignments.length > 1) { @@ -7630,17 +7864,18 @@ var ts; var meaning = 107455 | 793056 | 1536; var exportSymbol = resolveName(node, node.exportName.text, meaning, ts.Diagnostics.Cannot_find_name_0, node.exportName); } + symbolLinks.exportAssignmentSymbol = exportSymbol || unknownSymbol; } - symbolLinks.exportAssignSymbol = exportSymbol || unknownSymbol; + symbolLinks.exportAssignmentChecked = true; } } function collectExportInformationForSourceFileOrModule(symbol) { var seenExportedMember = false; var result = []; ts.forEach(symbol.declarations, function (declaration) { - var block = (declaration.kind === 210 ? declaration : declaration.body); + var block = (declaration.kind === 220 ? declaration : declaration.body); ts.forEach(block.statements, function (node) { - if (node.kind === 201) { + if (node.kind === 208) { result.push(node); } else { @@ -7653,6 +7888,37 @@ var ts; exportAssignments: result }; } + function getExportsOfSymbol(symbol) { + return symbol.flags & 1536 ? getExportsOfModule(symbol) : symbol.exports; + } + function getExportsOfModule(symbol) { + var links = getSymbolLinks(symbol); + return links.resolvedExports || (links.resolvedExports = getExportsForModule(symbol)); + } + function getExportsForModule(symbol) { + var result; + var visitedSymbols = []; + visit(symbol); + return result; + function visit(symbol) { + if (!ts.contains(visitedSymbols, symbol)) { + visitedSymbols.push(symbol); + if (!result) { + result = symbol.exports; + } + else { + extendSymbolTable(result, symbol.exports); + } + ts.forEach(symbol.declarations, function (node) { + if (node.kind === 220 || node.kind === 200) { + ts.forEach(node.exportStars, function (exportStar) { + visit(resolveExternalModuleName(exportStar, exportStar.moduleSpecifier)); + }); + } + }); + } + } + } function getMergedSymbol(symbol) { var merged; return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol; @@ -7682,7 +7948,7 @@ var ts; var members = node.members; for (var i = 0; i < members.length; i++) { var member = members[i]; - if (member.kind === 131 && ts.nodeIsPresent(member.body)) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { return member; } } @@ -7747,17 +8013,17 @@ var ts; } } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) { break; } - case 198: + case 200: if (result = callback(getSymbolOfNode(location).exports)) { return result; } break; - case 194: - case 195: + case 196: + case 197: if (result = callback(getSymbolOfNode(location).members)) { return result; } @@ -7790,7 +8056,7 @@ var ts; return ts.forEachValue(symbols, function (symbolFromSymbolTable) { if (symbolFromSymbolTable.flags & 8388608) { if (!useOnlyExternalAliasing || - ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportDeclaration)) { + ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) { var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable); if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) { return [symbolFromSymbolTable]; @@ -7872,8 +8138,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 198 && declaration.name.kind === 8) || - (declaration.kind === 210 && ts.isExternalModule(declaration)); + return (declaration.kind === 200 && declaration.name.kind === 8) || + (declaration.kind === 220 && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -7883,7 +8149,7 @@ var ts; return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible }; function getIsDeclarationVisible(declaration) { if (!isDeclarationVisible(declaration)) { - if (declaration.kind === 200 && + if (declaration.kind === 202 && !(declaration.flags & 1) && isDeclarationVisible(declaration.parent)) { getNodeLinks(declaration).isVisible = true; @@ -7904,11 +8170,11 @@ var ts; } function isEntityNameVisible(entityName, enclosingDeclaration) { var meaning; - if (entityName.parent.kind === 140) { + if (entityName.parent.kind === 142) { meaning = 107455 | 1048576; } - else if (entityName.kind === 123 || - entityName.parent.kind === 200) { + else if (entityName.kind === 125 || + entityName.parent.kind === 202) { meaning = 1536; } else { @@ -7952,10 +8218,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048) { var node = type.symbol.declarations[0].parent; - while (node.kind === 145) { + while (node.kind === 147) { node = node.parent; } - if (node.kind === 196) { + if (node.kind === 198) { return getSymbolOfNode(node); } } @@ -8108,7 +8374,7 @@ var ts; buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056, 0, flags); } else { - writeKeyword(writer, 110); + writeKeyword(writer, 112); } } else { @@ -8126,7 +8392,7 @@ var ts; var isNonLocalFunctionSymbol = !!(type.symbol.flags & 16) && (type.symbol.parent || ts.forEach(type.symbol.declarations, function (declaration) { - return declaration.parent.kind === 210 || declaration.parent.kind === 199; + return declaration.parent.kind === 220 || declaration.parent.kind === 201; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { return !!(flags & 2) || @@ -8199,7 +8465,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 119); + writeKeyword(writer, 121); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -8212,7 +8478,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 117); + writeKeyword(writer, 119); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -8355,12 +8621,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 198) { + if (node.kind === 200) { if (node.name.kind === 8) { return node; } } - else if (node.kind === 210) { + else if (node.kind === 220) { return ts.isExternalModule(node) ? node : undefined; } } @@ -8402,47 +8668,47 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 191: - case 148: - case 198: - case 194: - case 195: - case 196: case 193: - case 197: + case 150: case 200: + case 196: + case 197: + case 198: + case 195: + case 199: + case 202: var parent = getDeclarationContainer(node); if (!(ts.getCombinedNodeFlags(node) & 1) && - !(node.kind !== 200 && parent.kind !== 210 && ts.isInAmbientContext(parent))) { + !(node.kind !== 202 && parent.kind !== 220 && ts.isInAmbientContext(parent))) { return isGlobalSourceFile(parent) || isUsedInExportAssignment(node); } return isDeclarationVisible(parent); - case 128: - case 127: - case 132: - case 133: case 130: case 129: + case 134: + case 135: + case 132: + case 131: if (node.flags & (32 | 64)) { return false; } - case 131: - case 135: - case 134: - case 136: - case 126: - case 199: - case 138: - case 139: - case 141: + case 133: case 137: - case 142: + case 136: + case 138: + case 128: + case 201: + case 140: + case 141: case 143: + case 139: case 144: case 145: + case 146: + case 147: return isDeclarationVisible(node.parent); - case 125: - case 210: + case 127: + case 220: return true; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -8457,14 +8723,14 @@ var ts; } } function getRootDeclaration(node) { - while (node.kind === 148) { + while (node.kind === 150) { node = node.parent.parent; } return node; } function getDeclarationContainer(node) { node = getRootDeclaration(node); - return node.kind === 191 ? node.parent.parent.parent : node.parent; + return node.kind === 193 ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { var classType = getDeclaredTypeOfSymbol(prototype.parent); @@ -8486,7 +8752,7 @@ var ts; } return parentType; } - if (pattern.kind === 146) { + if (pattern.kind === 148) { var name = declaration.propertyName || declaration.name; var type = getTypeOfPropertyOfType(parentType, name.text) || isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, 1) || @@ -8516,7 +8782,7 @@ var ts; return type; } function getTypeForVariableLikeDeclaration(declaration) { - if (declaration.parent.parent.kind === 180) { + if (declaration.parent.parent.kind === 182) { return anyType; } if (ts.isBindingPattern(declaration.parent)) { @@ -8525,10 +8791,10 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 126) { + if (declaration.kind === 128) { var func = declaration.parent; - if (func.kind === 133 && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 132); + if (func.kind === 135 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 134); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -8541,7 +8807,7 @@ var ts; if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - if (declaration.kind === 208) { + if (declaration.kind === 218) { return checkIdentifier(declaration.name); } return undefined; @@ -8570,7 +8836,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 170 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 172 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -8578,7 +8844,7 @@ var ts; return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes); } function getTypeFromBindingPattern(pattern) { - return pattern.kind === 146 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); + return pattern.kind === 148 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { var type = getTypeForVariableLikeDeclaration(declaration); @@ -8586,7 +8852,7 @@ var ts; if (reportErrors) { reportErrorsFromWidening(declaration, type); } - return declaration.kind !== 207 ? getWidenedType(type) : type; + return declaration.kind !== 217 ? getWidenedType(type) : type; } if (ts.isBindingPattern(declaration.name)) { return getTypeFromBindingPattern(declaration.name); @@ -8594,7 +8860,7 @@ var ts; type = declaration.dotDotDotToken ? anyArrayType : anyType; if (reportErrors && compilerOptions.noImplicitAny) { var root = getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 126 && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 128 && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -8607,7 +8873,7 @@ var ts; return links.type = getTypeOfPrototypeProperty(symbol); } var declaration = symbol.valueDeclaration; - if (declaration.kind === 206) { + if (declaration.kind === 216) { return links.type = anyType; } links.type = resolvingType; @@ -8630,7 +8896,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 132) { + if (accessor.kind === 134) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -8649,8 +8915,8 @@ var ts; links = links || getSymbolLinks(symbol); if (!links.type) { links.type = resolvingType; - var getter = ts.getDeclarationOfKind(symbol, 132); - var setter = ts.getDeclarationOfKind(symbol, 133); + var getter = ts.getDeclarationOfKind(symbol, 134); + var setter = ts.getDeclarationOfKind(symbol, 135); var type; var getterReturnType = getAnnotatedAccessorType(getter); if (getterReturnType) { @@ -8680,7 +8946,7 @@ var ts; else if (links.type === resolvingType) { links.type = anyType; if (compilerOptions.noImplicitAny) { - var getter = ts.getDeclarationOfKind(symbol, 132); + var getter = ts.getDeclarationOfKind(symbol, 134); error(getter, 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)); } } @@ -8747,7 +9013,7 @@ var ts; function getTypeParametersOfClassOrInterface(symbol) { var result; ts.forEach(symbol.declarations, function (node) { - if (node.kind === 195 || node.kind === 194) { + if (node.kind === 197 || node.kind === 196) { var declaration = node; if (declaration.typeParameters && declaration.typeParameters.length) { ts.forEach(declaration.typeParameters, function (node) { @@ -8778,7 +9044,7 @@ var ts; type.typeArguments = type.typeParameters; } type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(symbol, 194); + var declaration = ts.getDeclarationOfKind(symbol, 196); var baseTypeNode = ts.getClassBaseTypeNode(declaration); if (baseTypeNode) { var baseType = getTypeFromTypeReferenceNode(baseTypeNode); @@ -8819,7 +9085,7 @@ var ts; } type.baseTypes = []; ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 195 && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 197 && ts.getInterfaceBaseTypeNodes(declaration)) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), function (node) { var baseType = getTypeFromTypeReferenceNode(node); if (baseType !== unknownType) { @@ -8850,7 +9116,7 @@ var ts; var links = getSymbolLinks(symbol); if (!links.declaredType) { links.declaredType = resolvingType; - var declaration = ts.getDeclarationOfKind(symbol, 196); + var declaration = ts.getDeclarationOfKind(symbol, 198); var type = getTypeFromTypeNode(declaration.type); if (links.declaredType === resolvingType) { links.declaredType = type; @@ -8858,7 +9124,7 @@ var ts; } else if (links.declaredType === resolvingType) { links.declaredType = unknownType; - var declaration = ts.getDeclarationOfKind(symbol, 196); + var declaration = ts.getDeclarationOfKind(symbol, 198); error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } return links.declaredType; @@ -8877,7 +9143,7 @@ var ts; if (!links.declaredType) { var type = createType(512); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 125).constraint) { + if (!ts.getDeclarationOfKind(symbol, 127).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -9086,7 +9352,7 @@ var ts; var callSignatures = emptyArray; var constructSignatures = emptyArray; if (symbol.flags & 1952) { - members = symbol.exports; + members = getExportsOfSymbol(symbol); } if (symbol.flags & (16 | 8192)) { callSignatures = getSignaturesOfSymbol(symbol); @@ -9283,7 +9549,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 131 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 133 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.typeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; var hasStringLiterals = false; @@ -9311,8 +9577,8 @@ var ts; returnType = getTypeFromTypeNode(declaration.type); } else { - if (declaration.kind === 132 && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 133); + if (declaration.kind === 134 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 135); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { @@ -9330,19 +9596,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 138: - case 139: - case 193: - case 130: - case 129: + case 140: + case 141: + case 195: + case 132: case 131: + case 133: + case 136: + case 137: + case 138: case 134: case 135: - case 136: - case 132: - case 133: - case 158: - case 159: + case 160: + case 161: if (i > 0 && node.body) { var previous = symbol.declarations[i - 1]; if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { @@ -9411,7 +9677,7 @@ var ts; } function getOrCreateTypeFromSignature(signature) { if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 131 || signature.declaration.kind === 135; + var isConstructor = signature.declaration.kind === 133 || signature.declaration.kind === 137; var type = createObjectType(32768 | 65536); type.members = emptySymbols; type.properties = emptyArray; @@ -9425,7 +9691,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 ? 117 : 119; + var syntaxKind = kind === 1 ? 119 : 121; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -9452,7 +9718,7 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 125).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 127).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; @@ -9500,13 +9766,13 @@ var ts; while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { currentNode = currentNode.parent; } - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 125; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 127; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 137 && n.typeName.kind === 64) { + if (n.kind === 139 && n.typeName.kind === 64) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056, undefined, undefined); @@ -9571,9 +9837,9 @@ var ts; for (var i = 0; i < declarations.length; i++) { var declaration = declarations[i]; switch (declaration.kind) { - case 194: - case 195: + case 196: case 197: + case 199: return declaration; } } @@ -9746,38 +10012,38 @@ var ts; } function getTypeFromTypeNode(node) { switch (node.kind) { - case 110: + case 112: return anyType; - case 119: + case 121: return stringType; - case 117: + case 119: return numberType; - case 111: + case 113: return booleanType; - case 120: + case 122: return esSymbolType; case 98: return voidType; case 8: return getTypeFromStringLiteral(node); - case 137: - return getTypeFromTypeReferenceNode(node); - case 140: - return getTypeFromTypeQueryNode(node); - case 142: - return getTypeFromArrayTypeNode(node); - case 143: - return getTypeFromTupleTypeNode(node); - case 144: - return getTypeFromUnionTypeNode(node); - case 145: - return getTypeFromTypeNode(node.type); - case 138: case 139: + return getTypeFromTypeReferenceNode(node); + case 142: + return getTypeFromTypeQueryNode(node); + case 144: + return getTypeFromArrayTypeNode(node); + case 145: + return getTypeFromTupleTypeNode(node); + case 146: + return getTypeFromUnionTypeNode(node); + case 147: + return getTypeFromTypeNode(node.type); + case 140: case 141: + case 143: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); case 64: - case 123: + case 125: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -9921,27 +10187,27 @@ var ts; return type; } function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 158: - case 159: + case 160: + case 161: return isContextSensitiveFunctionLikeDeclaration(node); - case 150: + case 152: return ts.forEach(node.properties, isContextSensitive); - case 149: + case 151: return ts.forEach(node.elements, isContextSensitive); - case 166: + case 168: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 165: + case 167: return node.operatorToken.kind === 49 && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 207: + case 217: return isContextSensitive(node.initializer); - case 130: - case 129: + case 132: + case 131: return isContextSensitiveFunctionLikeDeclaration(node); - case 157: + case 159: return isContextSensitive(node.expression); } return false; @@ -10700,20 +10966,20 @@ var ts; function reportImplicitAnyError(declaration, type) { var typeAsString = typeToString(getWidenedType(type)); switch (declaration.kind) { - case 128: - case 127: - var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; - break; - case 126: - var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; - break; - case 193: case 130: case 129: + var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; + break; + case 128: + var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; + break; + case 195: case 132: - case 133: - case 158: - case 159: + case 131: + case 134: + case 135: + case 160: + case 161: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -10942,10 +11208,10 @@ var ts; function isInTypeQuery(node) { while (node) { switch (node.kind) { - case 140: + case 142: return true; case 64: - case 123: + case 125: node = node.parent; continue; default: @@ -10984,7 +11250,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 52 && node.operatorToken.kind <= 63) { var n = node.left; - while (n.kind === 157) { + while (n.kind === 159) { n = n.expression; } if (n.kind === 64 && getResolvedSymbol(n) === symbol) { @@ -11001,46 +11267,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 165: + case 167: return isAssignedInBinaryExpression(node); - case 191: - case 148: - return isAssignedInVariableDeclaration(node); - case 146: - case 147: - case 149: + case 193: case 150: + return isAssignedInVariableDeclaration(node); + case 148: + case 149: case 151: case 152: case 153: case 154: + case 155: case 156: - case 157: - case 163: - case 160: - case 161: + case 158: + case 159: + case 165: case 162: + case 163: case 164: case 166: - case 169: - case 172: - case 173: + case 168: + case 171: + case 174: case 175: - case 176: case 177: case 178: case 179: case 180: case 181: - case 184: - case 185: + case 182: + case 183: case 186: - case 203: - case 204: case 187: case 188: + case 213: + case 214: case 189: - case 206: + case 190: + case 191: + case 216: return ts.forEachChild(node, isAssignedIn); } return false; @@ -11076,17 +11342,17 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 176: + case 178: if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 166: + case 168: if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 165: + case 167: if (child === node.right) { if (node.operatorToken.kind === 48) { narrowedType = narrowType(type, node.left, true); @@ -11096,14 +11362,14 @@ var ts; } } break; - case 210: - case 198: - case 193: - case 130: - case 129: + case 220: + case 200: + case 195: case 132: - case 133: case 131: + case 134: + case 135: + case 133: break loop; } if (narrowedType !== type) { @@ -11116,7 +11382,7 @@ var ts; } return type; function narrowTypeByEquality(type, expr, assumeTrue) { - if (expr.left.kind !== 161 || expr.right.kind !== 8) { + if (expr.left.kind !== 163 || expr.right.kind !== 8) { return type; } var left = expr.left; @@ -11189,9 +11455,9 @@ var ts; } function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 157: + case 159: return narrowType(type, expr.expression, assumeTrue); - case 165: + case 167: var operator = expr.operatorToken.kind; if (operator === 30 || operator === 31) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -11206,7 +11472,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 163: + case 165: if (expr.operator === 46) { return narrowType(type, expr.operand, !assumeTrue); } @@ -11216,27 +11482,29 @@ var ts; } } function markLinkedImportsAsReferenced(node) { - var nodeLinks = getNodeLinks(node); - while (nodeLinks.importOnRightSide) { - var rightSide = nodeLinks.importOnRightSide; - nodeLinks.importOnRightSide = undefined; - getSymbolLinks(rightSide).referenced = true; - ts.Debug.assert((rightSide.flags & 8388608) !== 0); - nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 200)); + if (node) { + var nodeLinks = getNodeLinks(node); + while (nodeLinks.importOnRightSide) { + var rightSide = nodeLinks.importOnRightSide; + nodeLinks.importOnRightSide = undefined; + getSymbolLinks(rightSide).referenced = true; + ts.Debug.assert((rightSide.flags & 8388608) !== 0); + nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 202)); + } } } function checkIdentifier(node) { var symbol = getResolvedSymbol(node); - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 159) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 161) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608) { var symbolLinks = getSymbolLinks(symbol); if (!symbolLinks.referenced) { - var importOrExportAssignment = getLeftSideOfImportOrExportAssignment(node); + var importOrExportAssignment = getLeftSideOfImportEqualsOrExportAssignment(node); if (!importOrExportAssignment || (importOrExportAssignment.flags & 1) || - (importOrExportAssignment.kind === 201)) { + (importOrExportAssignment.kind === 208)) { symbolLinks.referenced = !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveImport(symbol)); } else { @@ -11246,7 +11514,7 @@ var ts; } } if (symbolLinks.referenced) { - markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 200)); + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); } } checkCollisionWithCapturedSuperVariable(node, node); @@ -11254,9 +11522,9 @@ var ts; return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 194 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; getNodeLinks(node).flags |= 2; - if (container.kind === 128 || container.kind === 131) { + if (container.kind === 130 || container.kind === 133) { getNodeLinks(classNode).flags |= 4; } else { @@ -11266,36 +11534,36 @@ var ts; function checkThisExpression(node) { var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; - if (container.kind === 159) { + if (container.kind === 161) { container = ts.getThisContainer(container, false); needToCaptureLexicalThis = (languageVersion < 2); } switch (container.kind) { - case 198: + case 200: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_body); break; - case 197: + case 199: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); break; - case 131: + case 133: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; - case 128: - case 127: + case 130: + case 129: if (container.flags & 128) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 124: + case 126: 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 === 194 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -11304,15 +11572,15 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 126) { + if (n.kind === 128) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 153 && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 194); + var isCallExpression = node.parent.kind === 155 && node.parent.expression === node; + var enclosingClass = ts.getAncestor(node, 196); var baseClass; if (enclosingClass && ts.getClassBaseTypeNode(enclosingClass)) { var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); @@ -11326,31 +11594,31 @@ var ts; if (container) { var canUseSuperExpression = false; if (isCallExpression) { - canUseSuperExpression = container.kind === 131; + canUseSuperExpression = container.kind === 133; } else { var needToCaptureLexicalThis = false; - while (container && container.kind === 159) { + while (container && container.kind === 161) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = true; } - if (container && container.parent && container.parent.kind === 194) { + if (container && container.parent && container.parent.kind === 196) { if (container.flags & 128) { canUseSuperExpression = - container.kind === 130 || - container.kind === 129 || container.kind === 132 || - container.kind === 133; + container.kind === 131 || + container.kind === 134 || + container.kind === 135; } else { canUseSuperExpression = + container.kind === 132 || + container.kind === 131 || + container.kind === 134 || + container.kind === 135 || container.kind === 130 || container.kind === 129 || - container.kind === 132 || - container.kind === 133 || - container.kind === 128 || - container.kind === 127 || - container.kind === 131; + container.kind === 133; } } } @@ -11364,7 +11632,7 @@ var ts; getNodeLinks(node).flags |= 16; returnType = baseClass; } - if (container.kind === 131 && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 133 && isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; } @@ -11374,7 +11642,7 @@ var ts; return returnType; } } - if (container.kind === 124) { + if (container.kind === 126) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -11412,7 +11680,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 126) { + if (declaration.kind === 128) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -11427,7 +11695,7 @@ var ts; function getContextualTypeForReturnExpression(node) { var func = ts.getContainingFunction(node); if (func) { - if (func.type || func.kind === 131 || func.kind === 132 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 133))) { + if (func.type || func.kind === 133 || func.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 135))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(func)); } var signature = getContextualSignatureForFunctionLikeDeclaration(func); @@ -11447,7 +11715,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 155) { + if (template.parent.kind === 157) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -11552,32 +11820,32 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 191: - case 126: + case 193: case 128: - case 127: - case 148: + case 130: + case 129: + case 150: return getContextualTypeForInitializerExpression(node); - case 159: - case 184: + case 161: + case 186: return getContextualTypeForReturnExpression(node); - case 153: - case 154: - return getContextualTypeForArgument(parent, node); + case 155: case 156: + return getContextualTypeForArgument(parent, node); + case 158: return getTypeFromTypeNode(parent.type); - case 165: + case 167: return getContextualTypeForBinaryOperand(node); - case 207: + case 217: return getContextualTypeForObjectLiteralElement(parent); - case 149: + case 151: return getContextualTypeForElementExpression(node); - case 166: + case 168: return getContextualTypeForConditionalOperand(node); - case 171: - ts.Debug.assert(parent.parent.kind === 167); + case 173: + ts.Debug.assert(parent.parent.kind === 169); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 157: + case 159: return getContextualType(parent); } return undefined; @@ -11592,13 +11860,13 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 158 || node.kind === 159; + return node.kind === 160 || node.kind === 161; } function getContextualSignatureForFunctionLikeDeclaration(node) { return isFunctionExpressionOrArrowFunction(node) ? getContextualSignature(node) : undefined; } function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); if (!type) { return undefined; @@ -11639,13 +11907,13 @@ var ts; } function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 165 && parent.operatorToken.kind === 52 && parent.left === node) { + if (parent.kind === 167 && parent.operatorToken.kind === 52 && parent.left === node) { return true; } - if (parent.kind === 207) { + if (parent.kind === 217) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 149) { + if (parent.kind === 151) { return isAssignmentTarget(parent); } return false; @@ -11667,7 +11935,7 @@ var ts; var elementTypes = []; ts.forEach(elements, function (e) { var type = checkExpression(e, contextualMapper); - if (e.kind === 169) { + if (e.kind === 171) { elementTypes.push(getIndexTypeOfType(type, 1) || anyType); hasSpreadElement = true; } @@ -11684,7 +11952,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 124 ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 126 ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { return allConstituentTypesHaveKind(checkComputedPropertyName(name), 1 | 132); @@ -11714,18 +11982,18 @@ var ts; for (var i = 0; i < node.properties.length; i++) { var memberDecl = node.properties[i]; var member = memberDecl.symbol; - if (memberDecl.kind === 207 || - memberDecl.kind === 208 || + if (memberDecl.kind === 217 || + memberDecl.kind === 218 || ts.isObjectLiteralMethod(memberDecl)) { - if (memberDecl.kind === 207) { + if (memberDecl.kind === 217) { var type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 130) { + else if (memberDecl.kind === 132) { var type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 208); - var type = memberDecl.name.kind === 124 ? unknownType : checkExpression(memberDecl.name, contextualMapper); + ts.Debug.assert(memberDecl.kind === 218); + var type = memberDecl.name.kind === 126 ? unknownType : checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; var prop = createSymbol(4 | 67108864 | member.flags, member.name); @@ -11739,7 +12007,7 @@ var ts; member = prop; } else { - ts.Debug.assert(memberDecl.kind === 132 || memberDecl.kind === 133); + ts.Debug.assert(memberDecl.kind === 134 || memberDecl.kind === 135); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -11772,7 +12040,7 @@ var ts; } } function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 128; + return s.valueDeclaration ? s.valueDeclaration.kind : 130; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; @@ -11782,7 +12050,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 194); + var enclosingClassDeclaration = ts.getAncestor(node, 196); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -11829,7 +12097,7 @@ var ts; } getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & 32) { - if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 130) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -11841,12 +12109,12 @@ var ts; return anyType; } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 151 ? node.expression : node.left; + var left = node.kind === 153 ? node.expression : node.left; var type = checkExpressionOrQualifiedName(left); if (type !== unknownType && type !== anyType) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32) { - if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 130) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { return false; } else { @@ -11861,7 +12129,7 @@ var ts; function checkIndexedAccess(node) { if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 154 && node.parent.expression === node) { + if (node.parent.kind === 156 && 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); @@ -11957,7 +12225,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 155) { + if (node.kind === 157) { checkExpression(node.template); } else { @@ -12010,7 +12278,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 169) { + if (args[i].kind === 171) { return i; } } @@ -12020,11 +12288,11 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; - if (node.kind === 155) { + if (node.kind === 157) { var tagExpression = node; adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 167) { + if (tagExpression.template.kind === 169) { var templateExpression = tagExpression.template; var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); ts.Debug.assert(lastSpan !== undefined); @@ -12039,7 +12307,7 @@ var ts; else { var callExpression = node; if (!callExpression.arguments) { - ts.Debug.assert(callExpression.kind === 154); + ts.Debug.assert(callExpression.kind === 156); return signature.minArgumentCount === 0; } adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; @@ -12084,9 +12352,9 @@ var ts; var inferenceMapper = createInferenceMapper(context); for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 170) { - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); - if (i === 0 && args[i].parent.kind === 155) { + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + if (i === 0 && args[i].parent.kind === 157) { var argType = globalTemplateStringsArrayType; } else { @@ -12100,7 +12368,7 @@ var ts; for (var i = 0; i < args.length; i++) { if (excludeArgument[i] === false) { var arg = args[i]; - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType); } } @@ -12133,9 +12401,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 !== 170) { - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); - var argType = i === 0 && node.kind === 155 ? globalTemplateStringsArrayType : arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + var argType = i === 0 && node.kind === 157 ? globalTemplateStringsArrayType : 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)) { return false; } @@ -12145,10 +12413,10 @@ var ts; } function getEffectiveCallArguments(node) { var args; - if (node.kind === 155) { + if (node.kind === 157) { var template = node.template; args = [template]; - if (template.kind === 167) { + if (template.kind === 169) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -12161,7 +12429,7 @@ var ts; } function getEffectiveTypeArguments(callExpression) { if (callExpression.expression.kind === 90) { - var containingClass = ts.getAncestor(callExpression, 194); + var containingClass = ts.getAncestor(callExpression, 196); var baseClassTypeNode = containingClass && ts.getClassBaseTypeNode(containingClass); return baseClassTypeNode && baseClassTypeNode.typeArguments; } @@ -12170,7 +12438,7 @@ var ts; } } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 155; + var isTaggedTemplate = node.kind === 157; var typeArguments; if (!isTaggedTemplate) { typeArguments = getEffectiveTypeArguments(node); @@ -12376,13 +12644,13 @@ var ts; var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 153) { + if (node.kind === 155) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 154) { + else if (node.kind === 156) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 155) { + else if (node.kind === 157) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -12397,12 +12665,12 @@ var ts; if (node.expression.kind === 90) { return voidType; } - if (node.kind === 154) { + if (node.kind === 156) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 131 && - declaration.kind !== 135 && - declaration.kind !== 139) { + declaration.kind !== 133 && + declaration.kind !== 137 && + declaration.kind !== 141) { if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); } @@ -12452,7 +12720,7 @@ var ts; if (!func.body) { return unknownType; } - if (func.body.kind !== 172) { + if (func.body.kind !== 174) { var type = checkExpressionCached(func.body, contextualMapper); } else { @@ -12490,7 +12758,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 188); + return (body.statements.length === 1) && (body.statements[0].kind === 190); } function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { if (!produceDiagnostics) { @@ -12499,7 +12767,7 @@ var ts; if (returnType === voidType || returnType === anyType) { return; } - if (ts.nodeIsMissing(func.body) || func.body.kind !== 172) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 174) { return; } var bodyBlock = func.body; @@ -12512,9 +12780,9 @@ 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 !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 158) { + if (!hasGrammarError && node.kind === 160) { checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); } if (contextualMapper === identityMapper && isContextSensitive(node)) { @@ -12542,19 +12810,19 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 130 && node.kind !== 129) { + if (produceDiagnostics && node.kind !== 132 && node.kind !== 131) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); if (node.type) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } if (node.body) { - if (node.body.kind === 172) { + if (node.body.kind === 174) { checkSourceElement(node.body); } else { @@ -12583,12 +12851,12 @@ var ts; case 64: var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; - case 151: + case 153: var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; - case 152: + case 154: return true; - case 157: + case 159: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -12597,10 +12865,10 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 64: - case 151: + case 153: var symbol = findSymbol(n); return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 4096) !== 0; - case 152: + case 154: var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8) { @@ -12609,7 +12877,7 @@ var ts; return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 4096) !== 0; } return false; - case 157: + case 159: return isConstVariableReference(n.expression); default: return false; @@ -12732,7 +13000,7 @@ var ts; var properties = node.properties; for (var i = 0; i < properties.length; i++) { var p = properties[i]; - if (p.kind === 207 || p.kind === 208) { + if (p.kind === 217 || p.kind === 218) { var name = p.name; var type = sourceType.flags & 1 ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, 1) || @@ -12758,8 +13026,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 170) { - if (e.kind !== 169) { + if (e.kind !== 172) { + if (e.kind !== 171) { var propName = "" + i; var type = sourceType.flags & 1 ? sourceType : isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) : getIndexTypeOfType(sourceType, 1); if (type) { @@ -12782,14 +13050,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 165 && target.operatorToken.kind === 52) { + if (target.kind === 167 && target.operatorToken.kind === 52) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 150) { + if (target.kind === 152) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 149) { + if (target.kind === 151) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -12806,7 +13074,7 @@ var ts; checkGrammarEvalOrArgumentsInStrictMode(node, node.left); } var operator = node.operatorToken.kind; - if (operator === 52 && (node.left.kind === 150 || node.left.kind === 149)) { + if (operator === 52 && (node.left.kind === 152 || node.left.kind === 151)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -12978,14 +13246,14 @@ var ts; return links.resolvedType; } function checkPropertyAssignment(node, contextualMapper) { - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); } function checkObjectLiteralMethod(node, contextualMapper) { checkGrammarMethod(node); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -13011,7 +13279,7 @@ var ts; } function checkExpressionOrQualifiedName(node, contextualMapper) { var type; - if (node.kind == 123) { + if (node.kind == 125) { type = checkQualifiedName(node); } else { @@ -13019,9 +13287,9 @@ var ts; type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); } if (isConstEnumObjectType(type)) { - var ok = (node.parent.kind === 151 && node.parent.expression === node) || - (node.parent.kind === 152 && node.parent.expression === node) || - ((node.kind === 64 || node.kind === 123) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 153 && node.parent.expression === node) || + (node.parent.kind === 154 && node.parent.expression === node) || + ((node.kind === 64 || node.kind === 125) && 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); } @@ -13047,52 +13315,52 @@ var ts; return booleanType; case 7: return checkNumericLiteral(node); - case 167: + case 169: return checkTemplateExpression(node); case 8: case 10: return stringType; case 9: return globalRegExpType; - case 149: - return checkArrayLiteral(node, contextualMapper); - case 150: - return checkObjectLiteral(node, contextualMapper); case 151: - return checkPropertyAccessExpression(node); + return checkArrayLiteral(node, contextualMapper); case 152: - return checkIndexedAccess(node); + return checkObjectLiteral(node, contextualMapper); case 153: + return checkPropertyAccessExpression(node); case 154: - return checkCallExpression(node); + return checkIndexedAccess(node); case 155: - return checkTaggedTemplateExpression(node); case 156: - return checkTypeAssertion(node); + return checkCallExpression(node); case 157: - return checkExpression(node.expression, contextualMapper); + return checkTaggedTemplateExpression(node); case 158: + return checkTypeAssertion(node); case 159: - return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 161: - return checkTypeOfExpression(node); + return checkExpression(node.expression, contextualMapper); case 160: - return checkDeleteExpression(node); - case 162: - return checkVoidExpression(node); + case 161: + return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); case 163: - return checkPrefixUnaryExpression(node); + return checkTypeOfExpression(node); + case 162: + return checkDeleteExpression(node); case 164: - return checkPostfixUnaryExpression(node); + return checkVoidExpression(node); case 165: - return checkBinaryExpression(node, contextualMapper); + return checkPrefixUnaryExpression(node); case 166: - return checkConditionalExpression(node, contextualMapper); - case 169: - return checkSpreadElementExpression(node, contextualMapper); - case 170: - return undefinedType; + return checkPostfixUnaryExpression(node); + case 167: + return checkBinaryExpression(node, contextualMapper); case 168: + return checkConditionalExpression(node, contextualMapper); + case 171: + return checkSpreadElementExpression(node, contextualMapper); + case 172: + return undefinedType; + case 170: checkYieldExpression(node); return unknownType; } @@ -13114,7 +13382,7 @@ var ts; var func = ts.getContainingFunction(node); if (node.flags & 112) { func = ts.getContainingFunction(node); - if (!(func.kind === 131 && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 133 && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -13128,12 +13396,12 @@ var ts; } } function checkSignatureDeclaration(node) { - if (node.kind === 136) { + if (node.kind === 138) { checkGrammarIndexSignature(node); } - else if (node.kind === 138 || node.kind === 193 || node.kind === 139 || - node.kind === 134 || node.kind === 131 || - node.kind === 135) { + else if (node.kind === 140 || node.kind === 195 || node.kind === 141 || + node.kind === 136 || node.kind === 133 || + node.kind === 137) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); @@ -13145,10 +13413,10 @@ var ts; checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 135: + case 137: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 134: + case 136: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -13157,7 +13425,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 195) { + if (node.kind === 197) { var nodeSymbol = getSymbolOfNode(node); if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { return; @@ -13171,7 +13439,7 @@ var ts; var declaration = indexSymbol.declarations[i]; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 119: + case 121: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -13179,7 +13447,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 117: + case 119: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -13216,17 +13484,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 153 && n.expression.kind === 90; + return n.kind === 155 && n.expression.kind === 90; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 158: - case 193: - case 159: - case 150: return false; + case 160: + case 195: + case 161: + case 152: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -13234,12 +13502,12 @@ var ts; if (n.kind === 92) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 158 && n.kind !== 193) { + else if (n.kind !== 160 && n.kind !== 195) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 128 && + return n.kind === 130 && !(n.flags & 128) && !!n.initializer; } @@ -13249,7 +13517,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 !== 175 || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 177 || !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 { @@ -13265,13 +13533,13 @@ var ts; function checkAccessorDeclaration(node) { if (produceDiagnostics) { checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 132) { + if (node.kind === 134) { 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 === 132 ? 133 : 132; + var otherKind = node.kind === 134 ? 135 : 134; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112) !== (otherAccessor.flags & 112))) { @@ -13345,9 +13613,9 @@ var ts; return; } var signaturesToCheck; - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 195) { - ts.Debug.assert(signatureDeclarationNode.kind === 134 || signatureDeclarationNode.kind === 135); - var signatureKind = signatureDeclarationNode.kind === 134 ? 0 : 1; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 197) { + ts.Debug.assert(signatureDeclarationNode.kind === 136 || signatureDeclarationNode.kind === 137); + var signatureKind = signatureDeclarationNode.kind === 136 ? 0 : 1; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -13365,7 +13633,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 195 && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 197 && ts.isInAmbientContext(n)) { if (!(flags & 2)) { flags |= 1; } @@ -13438,7 +13706,7 @@ var ts; if (subsequentNode.kind === node.kind) { var errorNode = subsequentNode.name || subsequentNode; if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { - ts.Debug.assert(node.kind === 130 || node.kind === 129); + ts.Debug.assert(node.kind === 132 || node.kind === 131); 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, diagnostic); @@ -13464,11 +13732,11 @@ var ts; for (var i = 0; i < declarations.length; i++) { var node = declarations[i]; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 195 || node.parent.kind === 141 || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 197 || node.parent.kind === 143 || inAmbientContext; if (inAmbientContextOrInterface) { previousDeclaration = undefined; } - if (node.kind === 193 || node.kind === 130 || node.kind === 129 || node.kind === 131) { + if (node.kind === 195 || node.kind === 132 || node.kind === 131 || node.kind === 133) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -13565,14 +13833,14 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 195: - return 2097152; - case 198: - return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; - case 194: case 197: - return 2097152 | 1048576; + return 2097152; case 200: + return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; + case 196: + case 199: + return 2097152 | 1048576; + case 202: var result = 0; var target = resolveImport(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -13595,7 +13863,7 @@ var ts; } function checkFunctionLikeDeclaration(node) { checkSignatureDeclaration(node); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } if (!ts.hasDynamicName(node)) { @@ -13620,11 +13888,11 @@ var ts; } } function checkBlock(node) { - if (node.kind === 172) { + if (node.kind === 174) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 199) { + if (ts.isFunctionBlock(node) || node.kind === 201) { checkFunctionExpressionBodies(node); } } @@ -13642,19 +13910,19 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 128 || - node.kind === 127 || - node.kind === 130 || + if (node.kind === 130 || node.kind === 129 || node.kind === 132 || - node.kind === 133) { + node.kind === 131 || + node.kind === 134 || + node.kind === 135) { return false; } if (ts.isInAmbientContext(node)) { return false; } var root = getRootDeclaration(node); - if (root.kind === 126 && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 128 && ts.nodeIsMissing(root.parent.body)) { return false; } return true; @@ -13684,7 +13952,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 194); + var enclosingClass = ts.getAncestor(node, 196); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -13702,11 +13970,11 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { return; } - if (node.kind === 198 && ts.getModuleInstanceState(node) !== 1) { + if (node.kind === 200 && ts.getModuleInstanceState(node) !== 1) { return; } var parent = getDeclarationContainer(node); - if (parent.kind === 210 && ts.isExternalModule(parent)) { + if (parent.kind === 220 && ts.isExternalModule(parent)) { error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } } @@ -13719,13 +13987,13 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 6144) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 192); - var container = varDeclList.parent.kind === 173 && + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 194); + var container = varDeclList.parent.kind === 175 && varDeclList.parent.parent; var namesShareScope = container && - (container.kind === 172 && ts.isAnyFunction(container.parent) || - (container.kind === 199 && container.kind === 198) || - container.kind === 210); + (container.kind === 174 && ts.isAnyFunction(container.parent) || + (container.kind === 201 && container.kind === 200) || + container.kind === 220); if (!namesShareScope) { var name = symbolToString(localDeclarationSymbol); error(ts.getErrorSpanForNode(node), ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name); @@ -13736,13 +14004,13 @@ var ts; } } function isParameterDeclaration(node) { - while (node.kind === 148) { + while (node.kind === 150) { node = node.parent.parent; } - return node.kind === 126; + return node.kind === 128; } function checkParameterInitializer(node) { - if (getRootDeclaration(node).kind === 126) { + if (getRootDeclaration(node).kind === 128) { var func = ts.getContainingFunction(node); visit(node.initializer); } @@ -13750,7 +14018,7 @@ var ts; if (n.kind === 64) { var referencedSymbol = getNodeLinks(n).resolvedSymbol; if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 126) { + if (referencedSymbol.valueDeclaration.kind === 128) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -13769,7 +14037,7 @@ var ts; } function checkVariableLikeDeclaration(node) { checkSourceElement(node.type); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -13778,7 +14046,7 @@ var ts; if (ts.isBindingPattern(node.name)) { ts.forEach(node.name.elements, checkSourceElement); } - if (node.initializer && getRootDeclaration(node).kind === 126 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && getRootDeclaration(node).kind === 128 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -13806,9 +14074,9 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 128 && node.kind !== 127) { + if (node.kind !== 130 && node.kind !== 129) { checkExportsOnMergedDeclarations(node); - if (node.kind === 191 || node.kind === 148) { + if (node.kind === 193 || node.kind === 150) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -13837,7 +14105,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 172 || node.kind === 150) { + if (node.kind === 174 || node.kind === 152) { return true; } node = node.parent; @@ -13865,12 +14133,12 @@ var ts; } function checkForStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 192) { + if (node.initializer && node.initializer.kind == 194) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -13888,7 +14156,7 @@ var ts; } function checkForInStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; @@ -13915,7 +14183,7 @@ var ts; checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 132 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 133))); + return !!(node.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 135))); } function checkReturnStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { @@ -13929,11 +14197,11 @@ var ts; if (func) { var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); var exprType = checkExpressionCached(node.expression); - if (func.kind === 133) { + if (func.kind === 135) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } else { - if (func.kind === 131) { + if (func.kind === 133) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } @@ -13960,7 +14228,7 @@ var ts; var hasDuplicateDefaultClause = false; var expressionType = checkExpression(node.expression); ts.forEach(node.clauses, function (clause) { - if (clause.kind === 204 && !hasDuplicateDefaultClause) { + if (clause.kind === 214 && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -13972,7 +14240,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 203) { + if (produceDiagnostics && clause.kind === 213) { var caseClause = clause; var caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { @@ -13989,7 +14257,7 @@ var ts; if (ts.isAnyFunction(current)) { break; } - if (current.kind === 187 && current.label.text === node.label.text) { + if (current.kind === 189 && 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; @@ -14036,7 +14304,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 === 194) { + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 196) { var classDeclaration = type.symbol.valueDeclaration; for (var i = 0; i < classDeclaration.members.length; i++) { var member = classDeclaration.members[i]; @@ -14067,7 +14335,7 @@ var ts; return; } var errorNode; - if (prop.valueDeclaration.name.kind === 124 || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 126 || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -14208,7 +14476,7 @@ var ts; } } function isAccessor(kind) { - return kind === 132 || kind === 133; + return kind === 134 || kind === 135; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -14273,7 +14541,7 @@ var ts; checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 195); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 197); 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); @@ -14309,7 +14577,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 124 && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 126 && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -14345,7 +14613,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 163: + case 165: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -14356,7 +14624,7 @@ var ts; case 47: return enumIsConst ? ~value : undefined; } return undefined; - case 165: + case 167: if (!enumIsConst) { return undefined; } @@ -14384,11 +14652,11 @@ var ts; return undefined; case 7: return +e.text; - case 157: + case 159: return enumIsConst ? evalConstant(e.expression) : undefined; case 64: - case 152: - case 151: + case 154: + case 153: if (!enumIsConst) { return undefined; } @@ -14401,7 +14669,7 @@ var ts; propertyName = e.text; } else { - if (e.kind === 152) { + if (e.kind === 154) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8) { return undefined; @@ -14459,7 +14727,7 @@ var ts; } var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { - if (declaration.kind !== 197) { + if (declaration.kind !== 199) { return false; } var enumDeclaration = declaration; @@ -14482,7 +14750,7 @@ var ts; var declarations = symbol.declarations; for (var i = 0; i < declarations.length; i++) { var declaration = declarations[i]; - if ((declaration.kind === 194 || (declaration.kind === 193 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { + if ((declaration.kind === 196 || (declaration.kind === 195 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } } @@ -14494,16 +14762,13 @@ var ts; if (!ts.isInAmbientContext(node) && node.name.kind === 8) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } - else if (node.name.kind === 64 && node.body.kind === 199) { + else if (node.name.kind === 64 && node.body.kind === 201) { var statements = node.body.statements; for (var i = 0, n = statements.length; i < n; i++) { var statement = statements[i]; - if (statement.kind === 201) { + if (statement.kind === 208) { grammarErrorOnNode(statement, ts.Diagnostics.An_export_assignment_cannot_be_used_in_an_internal_module); } - else if (ts.isExternalModuleImportDeclaration(statement)) { - grammarErrorOnNode(ts.getExternalModuleImportDeclarationExpression(statement), ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); - } } } } @@ -14534,19 +14799,73 @@ var ts; checkSourceElement(node.body); } function getFirstIdentifier(node) { - while (node.kind === 123) { + while (node.kind === 125) { node = node.left; } return node; } - function checkImportDeclaration(node) { - checkGrammarModifiers(node); + function checkExternalImportOrExportDeclaration(node) { + var moduleName = ts.getExternalModuleName(node); + if (ts.getFullWidth(moduleName) !== 0 && moduleName.kind !== 8) { + error(moduleName, ts.Diagnostics.String_literal_expected); + return false; + } + var inAmbientExternalModule = node.parent.kind === 201 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 220 && !inAmbientExternalModule) { + error(moduleName, node.kind === 209 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_an_internal_module : ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); + return false; + } + if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) { + error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); + return false; + } + return true; + } + function checkImportSymbol(node) { + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); + if (target !== unknownSymbol) { + var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | + (symbol.flags & 793056 ? 793056 : 0) | + (symbol.flags & 1536 ? 1536 : 0); + if (target.flags & excludedMeanings) { + var message = node.kind === 211 ? 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)); + } + } + } + function checkImportBinding(node) { checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); - var symbol = getSymbolOfNode(node); - var target; - if (ts.isInternalModuleImportDeclaration(node)) { - target = resolveImport(symbol); + checkImportSymbol(node); + } + function checkImportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); + } + if (checkExternalImportOrExportDeclaration(node)) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + checkImportBinding(importClause); + } + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 205) { + checkImportBinding(importClause.namedBindings); + } + else { + ts.forEach(importClause.namedBindings.elements, checkImportBinding); + } + } + } + } + } + function checkImportEqualsDeclaration(node) { + checkGrammarModifiers(node); + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + checkImportBinding(node); + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); if (target !== unknownSymbol) { if (target.flags & 107455) { var moduleName = getFirstIdentifier(node.moduleReference); @@ -14563,33 +14882,18 @@ var ts; } } else { - if (node.parent.kind === 210) { - target = resolveImport(symbol); - } - else if (node.parent.kind === 199 && node.parent.parent.name.kind === 8) { - if (ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - if (isExternalModuleNameRelative(ts.getExternalModuleImportDeclarationExpression(node).text)) { - error(node, ts.Diagnostics.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); - target = unknownSymbol; - } - else { - target = resolveImport(symbol); - } - } - else { - target = unknownSymbol; - } - } - else { - target = unknownSymbol; + if (checkExternalImportOrExportDeclaration(node)) { + checkImportBinding(node); } } - if (target !== unknownSymbol) { - var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | - (symbol.flags & 793056 ? 793056 : 0) | - (symbol.flags & 1536 ? 1536 : 0); - if (target.flags & excludedMeanings) { - error(node, ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0, symbolToString(symbol)); + } + function checkExportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); + } + if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { + if (node.exportClause) { + ts.forEach(node.exportClause.elements, checkImportSymbol); } } } @@ -14598,7 +14902,7 @@ var ts; grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); } var container = node.parent; - if (container.kind !== 210) { + if (container.kind !== 220) { container = container.parent; } checkTypeOfExportAssignmentSymbol(getSymbolOfNode(container)); @@ -14607,158 +14911,160 @@ var ts; if (!node) return; switch (node.kind) { - case 125: - return checkTypeParameter(node); - case 126: - return checkParameter(node); - case 128: case 127: - return checkPropertyDeclaration(node); - case 138: - case 139: - case 134: - case 135: - return checkSignatureDeclaration(node); - case 136: - return checkSignatureDeclaration(node); + return checkTypeParameter(node); + case 128: + return checkParameter(node); case 130: case 129: - return checkMethodDeclaration(node); - case 131: - return checkConstructorDeclaration(node); - case 132: - case 133: - return checkAccessorDeclaration(node); - case 137: - return checkTypeReference(node); + return checkPropertyDeclaration(node); case 140: - return checkTypeQuery(node); case 141: - return checkTypeLiteral(node); + case 136: + case 137: + return checkSignatureDeclaration(node); + case 138: + return checkSignatureDeclaration(node); + case 132: + case 131: + return checkMethodDeclaration(node); + case 133: + return checkConstructorDeclaration(node); + case 134: + case 135: + return checkAccessorDeclaration(node); + case 139: + return checkTypeReference(node); case 142: - return checkArrayType(node); + return checkTypeQuery(node); case 143: - return checkTupleType(node); + return checkTypeLiteral(node); case 144: - return checkUnionType(node); + return checkArrayType(node); case 145: + return checkTupleType(node); + case 146: + return checkUnionType(node); + case 147: return checkSourceElement(node.type); - case 193: - return checkFunctionDeclaration(node); - case 172: - case 199: - return checkBlock(node); - case 173: - return checkVariableStatement(node); - case 175: - return checkExpressionStatement(node); - case 176: - return checkIfStatement(node); - case 177: - return checkDoStatement(node); - case 178: - return checkWhileStatement(node); - case 179: - return checkForStatement(node); - case 180: - return checkForInStatement(node); - case 181: - return checkForOfStatement(node); - case 182: - case 183: - return checkBreakOrContinueStatement(node); - case 184: - return checkReturnStatement(node); - case 185: - return checkWithStatement(node); - case 186: - return checkSwitchStatement(node); - case 187: - return checkLabeledStatement(node); - case 188: - return checkThrowStatement(node); - case 189: - return checkTryStatement(node); - case 191: - return checkVariableDeclaration(node); - case 148: - return checkBindingElement(node); - case 194: - return checkClassDeclaration(node); case 195: - return checkInterfaceDeclaration(node); - case 196: - return checkTypeAliasDeclaration(node); - case 197: - return checkEnumDeclaration(node); - case 198: - return checkModuleDeclaration(node); - case 200: - return checkImportDeclaration(node); - case 201: - return checkExportAssignment(node); + return checkFunctionDeclaration(node); case 174: + case 201: + return checkBlock(node); + case 175: + return checkVariableStatement(node); + case 177: + return checkExpressionStatement(node); + case 178: + return checkIfStatement(node); + case 179: + return checkDoStatement(node); + case 180: + return checkWhileStatement(node); + case 181: + return checkForStatement(node); + case 182: + return checkForInStatement(node); + case 183: + return checkForOfStatement(node); + case 184: + case 185: + return checkBreakOrContinueStatement(node); + case 186: + return checkReturnStatement(node); + case 187: + return checkWithStatement(node); + case 188: + return checkSwitchStatement(node); + case 189: + return checkLabeledStatement(node); + case 190: + return checkThrowStatement(node); + case 191: + return checkTryStatement(node); + case 193: + return checkVariableDeclaration(node); + case 150: + return checkBindingElement(node); + case 196: + return checkClassDeclaration(node); + case 197: + return checkInterfaceDeclaration(node); + case 198: + return checkTypeAliasDeclaration(node); + case 199: + return checkEnumDeclaration(node); + case 200: + return checkModuleDeclaration(node); + case 203: + return checkImportDeclaration(node); + case 202: + return checkImportEqualsDeclaration(node); + case 209: + return checkExportDeclaration(node); + case 208: + return checkExportAssignment(node); + case 176: checkGrammarStatementInAmbientContext(node); return; - case 190: + case 192: checkGrammarStatementInAmbientContext(node); return; } } function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 158: - case 159: + case 160: + case 161: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; - case 130: - case 129: + case 132: + case 131: ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 131: - case 132: case 133: - case 193: + case 134: + case 135: + case 195: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 185: + case 187: checkFunctionExpressionBodies(node.expression); break; - case 126: case 128: - case 127: - case 146: - case 147: + case 130: + case 129: case 148: case 149: case 150: - case 207: case 151: case 152: + case 217: case 153: case 154: case 155: - case 167: - case 171: case 156: case 157: - case 161: - case 162: - case 160: + case 169: + case 173: + case 158: + case 159: case 163: case 164: + case 162: case 165: case 166: - case 169: - case 172: - case 199: - case 173: + case 167: + case 168: + case 171: + case 174: + case 201: case 175: - case 176: case 177: case 178: case 179: @@ -14767,19 +15073,21 @@ var ts; case 182: case 183: case 184: + case 185: case 186: - case 203: - case 204: - case 187: case 188: + case 213: + case 214: case 189: - case 206: + case 190: case 191: - case 192: + case 216: + case 193: case 194: - case 197: - case 209: - case 210: + case 196: + case 199: + case 219: + case 220: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -14801,7 +15109,7 @@ var ts; var symbol = getExportAssignmentSymbol(node.symbol); if (symbol && symbol.flags & 8388608) { getSymbolLinks(symbol).referenced = true; - markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 200)); + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); } } if (potentialThisCollisions.length) { @@ -14835,7 +15143,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 185 && node.parent.statement === node) { + if (node.parent.kind === 187 && node.parent.statement === node) { return true; } node = node.parent; @@ -14871,27 +15179,27 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) break; - case 198: + case 200: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 197: + case 199: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 194: - case 195: + case 196: + case 197: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 158: + case 160: if (location.name) { copySymbol(location.symbol, meaning); } break; - case 206: + case 216: if (location.name.text) { copySymbol(location.symbol, meaning); } @@ -14910,109 +15218,109 @@ var ts; } function isTypeDeclaration(node) { switch (node.kind) { - case 125: - case 194: - case 195: + case 127: case 196: case 197: + case 198: + case 199: return true; } } function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 123) + while (node.parent && node.parent.kind === 125) node = node.parent; - return node.parent && node.parent.kind === 137; + return node.parent && node.parent.kind === 139; } function isTypeNode(node) { - if (137 <= node.kind && node.kind <= 145) { + if (139 <= node.kind && node.kind <= 147) { return true; } switch (node.kind) { - case 110: - case 117: + case 112: case 119: - case 111: - case 120: + case 121: + case 113: + case 122: return true; case 98: - return node.parent.kind !== 162; + return node.parent.kind !== 164; case 8: - return node.parent.kind === 126; + return node.parent.kind === 128; case 64: - if (node.parent.kind === 123 && node.parent.right === node) { + if (node.parent.kind === 125 && node.parent.right === node) { node = node.parent; } - case 123: - ts.Debug.assert(node.kind === 64 || node.kind === 123, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); + case 125: + ts.Debug.assert(node.kind === 64 || node.kind === 125, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); var parent = node.parent; - if (parent.kind === 140) { + if (parent.kind === 142) { return false; } - if (137 <= parent.kind && parent.kind <= 145) { + if (139 <= parent.kind && parent.kind <= 147) { return true; } switch (parent.kind) { - case 125: - return node === parent.constraint; - case 128: case 127: - case 126: - case 191: - return node === parent.type; - case 193: - case 158: - case 159: - case 131: + return node === parent.constraint; case 130: case 129: - case 132: - case 133: + case 128: + case 193: return node === parent.type; + case 195: + case 160: + case 161: + case 133: + case 132: + case 131: case 134: case 135: + return node === parent.type; case 136: + case 137: + case 138: return node === parent.type; - case 156: + case 158: return node === parent.type; - case 153: - case 154: - return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; case 155: + case 156: + return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; + case 157: return false; } } return false; } - function getLeftSideOfImportOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 123) { + function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { + while (nodeOnRightSide.parent.kind === 125) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 200) { + if (nodeOnRightSide.parent.kind === 202) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 201) { + if (nodeOnRightSide.parent.kind === 208) { return nodeOnRightSide.parent.exportName === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; } function isInRightSideOfImportOrExportAssignment(node) { - return getLeftSideOfImportOrExportAssignment(node) !== undefined; + return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 123 && node.parent.right === node) || - (node.parent.kind === 151 && node.parent.name === node); + return (node.parent.kind === 125 && node.parent.right === node) || + (node.parent.kind === 153 && node.parent.name === node); } function getSymbolOfEntityNameOrPropertyAccessExpression(entityName) { if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 201) { + if (entityName.parent.kind === 208) { return resolveEntityName(entityName.parent.parent, entityName, 107455 | 793056 | 1536 | 8388608); } - if (entityName.kind !== 151) { + if (entityName.kind !== 153) { if (isInRightSideOfImportOrExportAssignment(entityName)) { - return getSymbolOfPartOfRightHandSideOfImport(entityName); + return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); } } if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { @@ -15026,14 +15334,14 @@ var ts; var meaning = 107455 | 8388608; return resolveEntityName(entityName, entityName, meaning); } - else if (entityName.kind === 151) { + else if (entityName.kind === 153) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 123) { + else if (entityName.kind === 125) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -15042,7 +15350,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 137 ? 793056 : 1536; + var meaning = entityName.parent.kind === 139 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, entityName, meaning); } @@ -15056,32 +15364,32 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 64 && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 201 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImport(node); + return node.parent.kind === 208 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 64: - case 151: - case 123: + case 153: + case 125: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 92: case 90: var type = checkExpression(node); return type.symbol; - case 112: + case 114: var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 131) { + if (constructorDeclaration && constructorDeclaration.kind === 133) { return constructorDeclaration.parent.symbol; } return undefined; case 8: - if (ts.isExternalModuleImportDeclaration(node.parent.parent) && - ts.getExternalModuleImportDeclarationExpression(node.parent.parent) === node) { + if (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && + ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) { var importSymbol = getSymbolOfNode(node.parent.parent); var moduleType = getTypeOfSymbol(importSymbol); return moduleType ? moduleType.symbol : undefined; } case 7: - if (node.parent.kind == 152 && node.parent.argumentExpression === node) { + if (node.parent.kind == 154 && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -15095,7 +15403,7 @@ var ts; return undefined; } function getShorthandAssignmentValueSymbol(location) { - if (location && location.kind === 208) { + if (location && location.kind === 218) { return resolveEntityName(location, location.name, 107455); } return undefined; @@ -15169,7 +15477,7 @@ var ts; return [symbol]; } function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 210; + return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 220; } function isNodeDescendentOf(node, ancestor) { while (node) { @@ -15182,60 +15490,144 @@ var ts; function isUniqueLocalName(name, container) { for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) { if (node.locals && ts.hasProperty(node.locals, name)) { - var symbolWithRelevantName = node.locals[name]; - if (symbolWithRelevantName.flags & (107455 | 1048576)) { + if (node.locals[name].flags & (107455 | 1048576 | 8388608)) { return false; } - if (symbolWithRelevantName.flags & 8388608) { - var importDeclarationWithRelevantName = ts.getDeclarationOfKind(symbolWithRelevantName, 200); - if (isReferencedImportDeclaration(importDeclarationWithRelevantName)) { - return false; - } - } } } return true; } - function getLocalNameOfContainer(container) { - var links = getNodeLinks(container); - if (!links.localModuleName) { - var prefix = ""; - var name = ts.unescapeIdentifier(container.name.text); - while (!isUniqueLocalName(ts.escapeIdentifier(prefix + name), container)) { - prefix += "_"; - } - links.localModuleName = prefix + ts.getTextOfNode(container.name); + function getGeneratedNamesForSourceFile(sourceFile) { + var links = getNodeLinks(sourceFile); + var generatedNames = links.generatedNames; + if (!generatedNames) { + generatedNames = links.generatedNames = {}; + generateNames(sourceFile); + } + return generatedNames; + function generateNames(node) { + switch (node.kind) { + case 200: + generateNameForModuleOrEnum(node); + generateNames(node.body); + break; + case 199: + generateNameForModuleOrEnum(node); + break; + case 203: + generateNameForImportDeclaration(node); + break; + case 209: + generateNameForExportDeclaration(node); + break; + case 220: + case 201: + ts.forEach(node.statements, generateNames); + break; + } + } + function isExistingName(name) { + return ts.hasProperty(globals, name) || ts.hasProperty(sourceFile.identifiers, name) || ts.hasProperty(generatedNames, name); + } + function makeUniqueName(baseName) { + if (baseName.charCodeAt(0) !== 95) { + var baseName = "_" + baseName; + if (!isExistingName(baseName)) { + return generatedNames[baseName] = baseName; + } + } + if (baseName.charCodeAt(baseName.length - 1) !== 95) { + baseName += "_"; + } + var i = 1; + while (true) { + name = baseName + i; + if (!isExistingName(name)) { + return generatedNames[name] = name; + } + i++; + } + } + function assignGeneratedName(node, name) { + getNodeLinks(node).generatedName = ts.unescapeIdentifier(name); + } + function generateNameForModuleOrEnum(node) { + if (node.name.kind === 64) { + var name = node.name.text; + assignGeneratedName(node, 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)); + } + function generateNameForImportDeclaration(node) { + if (node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === 206) { + generateNameForImportOrExportDeclaration(node); + } + } + function generateNameForExportDeclaration(node) { + if (node.moduleSpecifier) { + generateNameForImportOrExportDeclaration(node); + } } - return links.localModuleName; } - function getLocalNameForSymbol(symbol, location) { + function getGeneratedNameForNode(node) { + var links = getNodeLinks(node); + if (!links.generatedName) { + getGeneratedNamesForSourceFile(getSourceFile(node)); + } + return links.generatedName; + } + function getLocalNameOfContainer(container) { + return getGeneratedNameForNode(container); + } + function getLocalNameForImportDeclaration(node) { + return getGeneratedNameForNode(node); + } + function getImportNameSubstitution(symbol) { + var declaration = getDeclarationOfImportSymbol(symbol); + if (declaration && declaration.kind === 207) { + var moduleName = getGeneratedNameForNode(declaration.parent.parent.parent); + var propertyName = declaration.propertyName || declaration.name; + return moduleName + "." + ts.unescapeIdentifier(propertyName.text); + } + } + function getExportNameSubstitution(symbol, location) { + if (isExternalModuleSymbol(symbol.parent)) { + return "exports." + ts.unescapeIdentifier(symbol.name); + } var node = location; + var containerSymbol = getParentOfSymbol(symbol); while (node) { - if ((node.kind === 198 || node.kind === 197) && getSymbolOfNode(node) === symbol) { - return getLocalNameOfContainer(node); + if ((node.kind === 200 || node.kind === 199) && getSymbolOfNode(node) === containerSymbol) { + return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); } node = node.parent; } - ts.Debug.fail("getLocalNameForSymbol failed"); } - function getExpressionNamePrefix(node) { + function getExpressionNameSubstitution(node) { var symbol = getNodeLinks(node).resolvedSymbol; if (symbol) { + if (symbol.parent) { + return getExportNameSubstitution(symbol, node.parent); + } var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { - symbol = exportSymbol; + return getExportNameSubstitution(exportSymbol, node.parent); } - if (symbol.parent) { - return isExternalModuleSymbol(symbol.parent) ? "exports" : getLocalNameForSymbol(getParentOfSymbol(symbol), node.parent); + if (symbol.flags & 8388608) { + return getImportNameSubstitution(symbol); } } } function getExportAssignmentName(node) { var symbol = getExportAssignmentSymbol(getSymbolOfNode(node)); - return symbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; + return symbol && symbol !== unknownSymbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; } - function isTopLevelValueImportWithEntityName(node) { - if (node.parent.kind !== 210 || !ts.isInternalModuleImportDeclaration(node)) { + function isTopLevelValueImportEqualsWithEntityName(node) { + if (node.parent.kind !== 220 || !ts.isInternalModuleImportEqualsDeclaration(node)) { return false; } return isImportResolvedToValue(getSymbolOfNode(node)); @@ -15248,14 +15640,16 @@ var ts; return isConstEnumSymbol(s) || s.constEnumOnlyModule; } function isReferencedImportDeclaration(node) { - var symbol = getSymbolOfNode(node); - if (getSymbolLinks(symbol).referenced) { - return true; + if (isImportSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + if (getSymbolLinks(symbol).referenced) { + return true; + } + if (node.kind === 202 && node.flags & 1 && isImportResolvedToValue(symbol)) { + return true; + } } - if (node.flags & 1) { - return isImportResolvedToValue(symbol); - } - return false; + return ts.forEachChild(node, isReferencedImportDeclaration); } function isImplementationOfOverload(node) { if (ts.nodeIsPresent(node.body)) { @@ -15274,14 +15668,14 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 209) { + if (node.kind === 219) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; if (symbol && (symbol.flags & 8)) { var declaration = symbol.valueDeclaration; var constantValue; - if (declaration.kind === 209) { + if (declaration.kind === 219) { return getEnumMemberValue(declaration); } } @@ -15297,16 +15691,17 @@ var ts; getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags); } function isUnknownIdentifier(location, name) { - return !resolveName(location, name, 107455, undefined, undefined); + return !resolveName(location, name, 107455, undefined, undefined) && + !ts.hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), name); } function createResolver() { return { - getLocalNameOfContainer: getLocalNameOfContainer, - getExpressionNamePrefix: getExpressionNamePrefix, + getGeneratedNameForNode: getGeneratedNameForNode, + getExpressionNameSubstitution: getExpressionNameSubstitution, getExportAssignmentName: getExportAssignmentName, isReferencedImportDeclaration: isReferencedImportDeclaration, getNodeCheckFlags: getNodeCheckFlags, - isTopLevelValueImportWithEntityName: isTopLevelValueImportWithEntityName, + isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName, isDeclarationVisible: isDeclarationVisible, isImplementationOfOverload: isImplementationOfOverload, writeTypeOfDeclaration: writeTypeOfDeclaration, @@ -15323,7 +15718,7 @@ var ts; }); ts.forEach(host.getSourceFiles(), function (file) { if (!ts.isExternalModule(file)) { - extendSymbolTable(globals, file.locals); + mergeSymbolTable(globals, file.locals); } }); getSymbolLinks(undefinedSymbol).type = undefinedType; @@ -15352,24 +15747,26 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 132: + case 134: + case 135: case 133: - case 131: - case 128: - case 127: case 130: case 129: - case 136: - case 194: + case 132: + case 131: + case 138: + case 196: + case 197: + case 200: + case 199: + case 175: case 195: case 198: - case 197: - case 201: - case 173: - case 193: - case 196: - case 200: - case 126: + case 203: + case 202: + case 209: + case 208: + case 128: break; default: return false; @@ -15382,14 +15779,14 @@ var ts; for (var i = 0, n = node.modifiers.length; i < n; i++) { var modifier = node.modifiers[i]; switch (modifier.kind) { + case 109: + case 108: case 107: - case 106: - case 105: var text; - if (modifier.kind === 107) { + if (modifier.kind === 109) { text = "public"; } - else if (modifier.kind === 106) { + else if (modifier.kind === 108) { text = "protected"; lastProtected = modifier; } @@ -15403,19 +15800,19 @@ var ts; else if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 199 || node.parent.kind === 210) { + else if (node.parent.kind === 201 || node.parent.kind === 220) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); break; - case 108: + case 110: if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 199 || node.parent.kind === 210) { + else if (node.parent.kind === 201 || node.parent.kind === 220) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128; @@ -15428,25 +15825,25 @@ var ts; else if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 194) { + else if (node.parent.kind === 196) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1; break; - case 113: + case 115: if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 194) { + else if (node.parent.kind === 196) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 199) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 201) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2; @@ -15454,7 +15851,7 @@ var ts; break; } } - if (node.kind === 131) { + if (node.kind === 133) { if (flags & 128) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -15465,13 +15862,13 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if (node.kind === 200 && flags & 2) { + else if ((node.kind === 203 || node.kind === 202) && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 195 && flags & 2) { + else if (node.kind === 197 && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); } - else if (node.kind === 126 && (flags & 112) && ts.isBindingPattern(node.name)) { + else if (node.kind === 128 && (flags & 112) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -15554,7 +15951,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 !== 119 && parameter.type.kind !== 117) { + if (parameter.type.kind !== 121 && parameter.type.kind !== 119) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -15586,7 +15983,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var i = 0, n = arguments.length; i < n; i++) { var arg = arguments[i]; - if (arg.kind === 170) { + if (arg.kind === 172) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -15627,7 +16024,7 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 101); + ts.Debug.assert(heritageClause.token === 103); if (seenImplementsClause) { return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); } @@ -15650,7 +16047,7 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 101); + ts.Debug.assert(heritageClause.token === 103); return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); } checkGrammarHeritageClause(heritageClause); @@ -15659,11 +16056,11 @@ var ts; return false; } function checkGrammarComputedPropertyName(node) { - if (node.kind !== 124) { + if (node.kind !== 126) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 165 && computedPropertyName.expression.operatorToken.kind === 23) { + if (computedPropertyName.expression.kind === 167 && computedPropertyName.expression.operatorToken.kind === 23) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } @@ -15690,26 +16087,26 @@ var ts; for (var i = 0, n = node.properties.length; i < n; i++) { var prop = node.properties[i]; var name = prop.name; - if (prop.kind === 170 || - name.kind === 124) { + if (prop.kind === 172 || + name.kind === 126) { checkGrammarComputedPropertyName(name); continue; } var currentKind; - if (prop.kind === 207 || prop.kind === 208) { + if (prop.kind === 217 || prop.kind === 218) { checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); if (name.kind === 7) { checkGrammarNumbericLiteral(name); } currentKind = Property; } - else if (prop.kind === 130) { + else if (prop.kind === 132) { currentKind = Property; } - else if (prop.kind === 132) { + else if (prop.kind === 134) { currentKind = GetAccessor; } - else if (prop.kind === 133) { + else if (prop.kind === 135) { currentKind = SetAccesor; } else { @@ -15743,20 +16140,20 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 192) { + if (forInOrOfStatement.initializer.kind === 194) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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); } } @@ -15784,10 +16181,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 132 && accessor.parameters.length) { + else if (kind === 134 && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 133) { + else if (kind === 135) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -15812,7 +16209,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 124 && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 126 && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -15822,7 +16219,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 150) { + if (node.parent.kind === 152) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -15830,7 +16227,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 194) { + if (node.parent.kind === 196) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -15841,22 +16238,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 === 195) { + else if (node.parent.kind === 197) { 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 === 141) { + else if (node.parent.kind === 143) { 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 181: + case 182: + case 183: case 179: case 180: - case 181: - case 177: - case 178: return true; - case 187: + case 189: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -15868,17 +16265,17 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 187: + case 189: if (node.label && current.label.text === node.label.text) { - var isMisplacedContinueLabel = node.kind === 182 && !isIterationStatement(current.statement, true); + var isMisplacedContinueLabel = node.kind === 184 && !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); } return false; } break; - case 186: - if (node.kind === 183 && !node.label) { + case 188: + if (node.kind === 185 && !node.label) { return false; } break; @@ -15891,11 +16288,11 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 183 ? 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; + var message = node.kind === 185 ? 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 === 183 ? 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; + var message = node.kind === 185 ? 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); } } @@ -15966,15 +16363,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 176: - case 177: case 178: - case 185: case 179: case 180: - case 181: - return false; case 187: + case 181: + case 182: + case 183: + return false; + case 189: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -15990,7 +16387,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 163) { + if (expression.kind === 165) { var unaryExpression = expression; if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { expression = unaryExpression.operand; @@ -16009,7 +16406,7 @@ var ts; var inAmbientContext = ts.isInAmbientContext(enumDecl); for (var i = 0, n = enumDecl.members.length; i < n; i++) { var node = enumDecl.members[i]; - if (node.name.kind === 124) { + if (node.name.kind === 126) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -16077,18 +16474,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 194) { + if (node.parent.kind === 196) { 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 === 195) { + else if (node.parent.kind === 197) { 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 === 141) { + else if (node.parent.kind === 143) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -16098,9 +16495,11 @@ var ts; } } function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { - if (node.kind === 195 || - node.kind === 200 || - node.kind === 201 || + if (node.kind === 197 || + node.kind === 203 || + node.kind === 202 || + node.kind === 209 || + node.kind === 208 || (node.flags & 2)) { return false; } @@ -16109,7 +16508,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var i = 0, n = file.statements.length; i < n; i++) { var decl = file.statements[i]; - if (ts.isDeclaration(decl) || decl.kind === 173) { + if (ts.isDeclaration(decl) || decl.kind === 175) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -16128,7 +16527,7 @@ var ts; if (!links.hasReportedStatementInAmbientContext && ts.isAnyFunction(node.parent)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); } - if (node.parent.kind === 172 || node.parent.kind === 199 || node.parent.kind === 210) { + if (node.parent.kind === 174 || node.parent.kind === 201 || node.parent.kind === 220) { var links = getNodeLinks(node.parent); if (!links.hasReportedStatementInAmbientContext) { return links.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); @@ -16337,7 +16736,7 @@ var ts; } function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 131 && ts.nodeIsPresent(member.body)) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { return member; } }); @@ -16348,10 +16747,10 @@ var ts; var setAccessor; if (ts.hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 132) { + if (accessor.kind === 134) { getAccessor = accessor; } - else if (accessor.kind === 133) { + else if (accessor.kind === 135) { setAccessor = accessor; } else { @@ -16360,17 +16759,17 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 132 || member.kind === 133) && (member.flags & 128) === (accessor.flags & 128)) { + if ((member.kind === 134 || member.kind === 135) && (member.flags & 128) === (accessor.flags & 128)) { var memberName = ts.getPropertyNameForPropertyNameNode(member.name); var accessorName = ts.getPropertyNameForPropertyNameNode(accessor.name); if (memberName === accessorName) { if (!firstAccessor) { firstAccessor = member; } - if (member.kind === 132 && !getAccessor) { + if (member.kind === 134 && !getAccessor) { getAccessor = member; } - if (member.kind === 133 && !setAccessor) { + if (member.kind === 135 && !setAccessor) { setAccessor = member; } } @@ -16496,16 +16895,16 @@ var ts; increaseIndent = newWriter.increaseIndent; decreaseIndent = newWriter.decreaseIndent; } - function writeAsychronousImportDeclarations(importDeclarations) { + function writeAsychronousImportEqualsDeclarations(importEqualsDeclarations) { var oldWriter = writer; - ts.forEach(importDeclarations, function (aliasToWrite) { + ts.forEach(importEqualsDeclarations, function (aliasToWrite) { var aliasEmitInfo = ts.forEach(aliasDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined; }); if (aliasEmitInfo) { createAndSetNewTextWriterWithSymbolWriter(); for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - writeImportDeclaration(aliasToWrite); + writeImportEqualsDeclaration(aliasToWrite); aliasEmitInfo.asynchronousOutput = writer.getText(); } }); @@ -16514,7 +16913,7 @@ var ts; function handleSymbolAccessibilityError(symbolAccesibilityResult) { if (symbolAccesibilityResult.accessibility === 0) { if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) { - writeAsychronousImportDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); + writeAsychronousImportEqualsDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); } } else { @@ -16584,40 +16983,40 @@ var ts; } function emitType(type) { switch (type.kind) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: case 98: case 8: return writeTextOfNode(currentSourceFile, type); - case 137: - return emitTypeReference(type); - case 140: - return emitTypeQuery(type); - case 142: - return emitArrayType(type); - case 143: - return emitTupleType(type); - case 144: - return emitUnionType(type); - case 145: - return emitParenType(type); - case 138: case 139: - return emitSignatureDeclarationWithJsDocComments(type); + return emitTypeReference(type); + case 142: + return emitTypeQuery(type); + case 144: + return emitArrayType(type); + case 145: + return emitTupleType(type); + case 146: + return emitUnionType(type); + case 147: + return emitParenType(type); + case 140: case 141: + return emitSignatureDeclarationWithJsDocComments(type); + case 143: return emitTypeLiteral(type); case 64: return emitEntityName(type); - case 123: + case 125: return emitEntityName(type); default: ts.Debug.fail("Unknown type annotation: " + type.kind); } function emitEntityName(entityName) { - var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 200 ? entityName.parent : enclosingDeclaration); + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 202 ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -16688,7 +17087,7 @@ var ts; if (node.flags & 1) { write("export "); } - if (node.kind !== 195) { + if (node.kind !== 197) { write("declare "); } } @@ -16704,7 +17103,7 @@ var ts; write("static "); } } - function emitImportDeclaration(node) { + function emitImportEqualsDeclaration(node) { var nodeEmitInfo = { declaration: node, outputPos: writer.getTextPos(), @@ -16713,10 +17112,10 @@ var ts; }; aliasDeclarationEmitInfo.push(nodeEmitInfo); if (nodeEmitInfo.hasWritten) { - writeImportDeclaration(node); + writeImportEqualsDeclaration(node); } } - function writeImportDeclaration(node) { + function writeImportEqualsDeclaration(node) { emitJsDocComments(node); if (node.flags & 1) { write("export "); @@ -16724,13 +17123,13 @@ var ts; write("import "); writeTextOfNode(currentSourceFile, node.name); write(" = "); - if (ts.isInternalModuleImportDeclaration(node)) { + if (ts.isInternalModuleImportEqualsDeclaration(node)) { emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.moduleReference, getImportEntityNameVisibilityError); write(";"); } else { write("require("); - writeTextOfNode(currentSourceFile, ts.getExternalModuleImportDeclarationExpression(node)); + writeTextOfNode(currentSourceFile, ts.getExternalModuleImportEqualsDeclarationExpression(node)); write(");"); } writer.writeLine(); @@ -16748,7 +17147,7 @@ var ts; emitModuleElementDeclarationFlags(node); write("module "); writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 199) { + while (node.body.kind !== 201) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -16814,7 +17213,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 130 && (node.parent.flags & 32); + return node.parent.kind === 132 && (node.parent.flags & 32); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -16824,15 +17223,15 @@ var ts; writeTextOfNode(currentSourceFile, node.name); if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 138 || - node.parent.kind === 139 || - (node.parent.parent && node.parent.parent.kind === 141)) { - ts.Debug.assert(node.parent.kind === 130 || - node.parent.kind === 129 || - node.parent.kind === 138 || - node.parent.kind === 139 || - node.parent.kind === 134 || - node.parent.kind === 135); + if (node.parent.kind === 140 || + node.parent.kind === 141 || + (node.parent.parent && node.parent.parent.kind === 143)) { + ts.Debug.assert(node.parent.kind === 132 || + node.parent.kind === 131 || + node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.kind === 136 || + node.parent.kind === 137); emitType(node.constraint); } else { @@ -16842,31 +17241,31 @@ var ts; function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 194: + case 196: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 195: + case 197: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 135: + case 137: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 134: + case 136: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 130: - case 129: + case 132: + case 131: 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 === 194) { + else if (node.parent.parent.kind === 196) { 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 193: + case 195: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -16894,7 +17293,7 @@ var ts; emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError); function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.parent.parent.kind === 194) { + if (node.parent.parent.kind === 196) { 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; } else { @@ -16973,12 +17372,12 @@ var ts; writeLine(); } function emitVariableDeclaration(node) { - if (node.kind !== 191 || resolver.isDeclarationVisible(node)) { + if (node.kind !== 193 || resolver.isDeclarationVisible(node)) { writeTextOfNode(currentSourceFile, node.name); - if ((node.kind === 128 || node.kind === 127) && ts.hasQuestionToken(node)) { + if ((node.kind === 130 || node.kind === 129) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 128 || node.kind === 127) && node.parent.kind === 141) { + if ((node.kind === 130 || node.kind === 129) && node.parent.kind === 143) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32)) { @@ -16987,14 +17386,14 @@ var ts; } function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.kind === 191) { + if (node.kind === 193) { diagnosticMessage = 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 === 128 || node.kind === 127) { + else if (node.kind === 130 || node.kind === 129) { if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 194) { + else if (node.parent.kind === 196) { diagnosticMessage = 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 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; } else { @@ -17047,7 +17446,7 @@ var ts; var accessorWithTypeAnnotation = node; var type = getTypeAnnotationFromAccessor(node); if (!type) { - var anotherAccessor = node.kind === 132 ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 134 ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -17060,12 +17459,12 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 132 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; + return accessor.kind === 134 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; } } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 133) { + if (accessorWithTypeAnnotation.kind === 135) { 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 : ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1; } @@ -17097,20 +17496,20 @@ var ts; if (ts.hasDynamicName(node)) { return; } - if ((node.kind !== 193 || resolver.isDeclarationVisible(node)) && + if ((node.kind !== 195 || resolver.isDeclarationVisible(node)) && !resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 193) { + if (node.kind === 195) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 130) { + else if (node.kind === 132) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 193) { + if (node.kind === 195) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 131) { + else if (node.kind === 133) { write("constructor"); } else { @@ -17127,11 +17526,11 @@ var ts; emitSignatureDeclaration(node); } function emitSignatureDeclaration(node) { - if (node.kind === 135 || node.kind === 139) { + if (node.kind === 137 || node.kind === 141) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 136) { + if (node.kind === 138) { write("["); } else { @@ -17140,20 +17539,20 @@ var ts; var prevEnclosingDeclaration = enclosingDeclaration; enclosingDeclaration = node; emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 136) { + if (node.kind === 138) { write("]"); } else { write(")"); } - var isFunctionTypeOrConstructorType = node.kind === 138 || node.kind === 139; - if (isFunctionTypeOrConstructorType || node.parent.kind === 141) { + var isFunctionTypeOrConstructorType = node.kind === 140 || node.kind === 141; + if (isFunctionTypeOrConstructorType || node.parent.kind === 143) { if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 131 && !(node.flags & 32)) { + else if (node.kind !== 133 && !(node.flags & 32)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -17164,28 +17563,28 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 135: + case 137: 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 134: + case 136: 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 136: + case 138: 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 130: - case 129: + case 132: + case 131: if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : 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 === 194) { + else if (node.parent.kind === 196) { 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 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 193: + case 195: 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 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; break; default: @@ -17213,9 +17612,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 138 || - node.parent.kind === 139 || - node.parent.parent.kind === 141) { + if (node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.parent.kind === 143) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32)) { @@ -17224,28 +17623,28 @@ var ts; function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 131: + case 133: diagnosticMessage = 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; break; - case 135: + case 137: diagnosticMessage = 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; break; - case 134: + case 136: diagnosticMessage = 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; break; - case 130: - case 129: + case 132: + case 131: if (node.parent.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 194) { + else if (node.parent.parent.kind === 196) { diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? 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; } break; - case 193: + case 195: diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -17260,40 +17659,40 @@ var ts; } function emitNode(node) { switch (node.kind) { + case 133: + case 195: + case 132: case 131: - case 193: + return emitFunctionDeclaration(node); + case 137: + case 136: + case 138: + return emitSignatureDeclarationWithJsDocComments(node); + case 134: + case 135: + return emitAccessorDeclaration(node); + case 175: + return emitVariableStatement(node); case 130: case 129: - return emitFunctionDeclaration(node); - case 135: - case 134: - case 136: - return emitSignatureDeclarationWithJsDocComments(node); - case 132: - case 133: - return emitAccessorDeclaration(node); - case 173: - return emitVariableStatement(node); - case 128: - case 127: return emitPropertyDeclaration(node); - case 195: - return emitInterfaceDeclaration(node); - case 194: - return emitClassDeclaration(node); - case 196: - return emitTypeAliasDeclaration(node); - case 209: - return emitEnumMemberDeclaration(node); case 197: - return emitEnumDeclaration(node); + return emitInterfaceDeclaration(node); + case 196: + return emitClassDeclaration(node); case 198: - return emitModuleDeclaration(node); + return emitTypeAliasDeclaration(node); + case 219: + return emitEnumMemberDeclaration(node); + case 199: + return emitEnumDeclaration(node); case 200: - return emitImportDeclaration(node); - case 201: + return emitModuleDeclaration(node); + case 202: + return emitImportEqualsDeclaration(node); + case 208: return emitExportAssignment(node); - case 210: + case 220: return emitSourceFile(node); } } @@ -17354,6 +17753,8 @@ var ts; var tempCount = 0; var tempVariables; var tempParameters; + var externalImports; + var exportSpecifiers; var writeEmittedFiles = writeJavaScriptFile; var emitLeadingComments = compilerOptions.removeComments ? function (node) { } : emitLeadingDeclarationComments; var emitTrailingComments = compilerOptions.removeComments ? function (node) { } : emitTrailingDeclarationComments; @@ -17510,7 +17911,7 @@ var ts; var parentIndex = getSourceMapNameIndex(); if (parentIndex !== -1) { var name = node.name; - if (!name || name.kind !== 124) { + if (!name || name.kind !== 126) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -17527,18 +17928,18 @@ var ts; if (scopeName) { recordScopeNameStart(scopeName); } - else if (node.kind === 193 || - node.kind === 158 || - node.kind === 130 || - node.kind === 129 || + else if (node.kind === 195 || + node.kind === 160 || node.kind === 132 || - node.kind === 133 || - node.kind === 198 || - node.kind === 194 || - node.kind === 197) { + node.kind === 131 || + node.kind === 134 || + node.kind === 135 || + node.kind === 200 || + node.kind === 196 || + node.kind === 199) { if (node.name) { var name = node.name; - scopeName = name.kind === 124 ? ts.getTextOfNode(name) : node.name.text; + scopeName = name.kind === 126 ? ts.getTextOfNode(name) : node.name.text; } recordScopeNameStart(scopeName); } @@ -17618,7 +18019,7 @@ var ts; } function emitNodeWithMap(node) { if (node) { - if (node.kind != 210) { + if (node.kind != 220) { recordEmitNodeStartSpan(node); emitNode(node); recordEmitNodeEndSpan(node); @@ -17822,7 +18223,7 @@ var ts; } for (var i = 0; i < node.templateSpans.length; i++) { var templateSpan = node.templateSpans[i]; - var needsParens = templateSpan.expression.kind !== 157 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; + var needsParens = templateSpan.expression.kind !== 159 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; if (i > 0 || headEmitted) { write(" + "); } @@ -17841,11 +18242,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 153: - case 154: - return parent.expression === template; case 155: + case 156: + return parent.expression === template; case 157: + case 159: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1; @@ -17853,7 +18254,7 @@ var ts; } function comparePrecedenceToBinaryPlus(expression) { switch (expression.kind) { - case 165: + case 167: switch (expression.operatorToken.kind) { case 35: case 36: @@ -17865,7 +18266,7 @@ var ts; default: return -1; } - case 166: + case 168: return -1; default: return 1; @@ -17877,11 +18278,11 @@ var ts; emit(span.literal); } function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 148); + ts.Debug.assert(node.kind !== 150); if (node.kind === 8) { emitLiteral(node); } - else if (node.kind === 124) { + else if (node.kind === 126) { emit(node.expression); } else { @@ -17898,43 +18299,44 @@ var ts; function isNotExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 126: - case 191: - case 148: case 128: - case 127: - case 207: - case 208: - case 209: + case 193: + case 150: case 130: case 129: - case 193: + case 217: + case 218: + case 219: case 132: - case 133: - case 158: - case 194: + case 131: case 195: + case 134: + case 135: + case 160: + case 196: case 197: - case 198: + case 199: case 200: + case 202: return parent.name === node; - case 183: - case 182: - case 201: + case 185: + case 184: + case 208: return false; - case 187: + case 189: return node.parent.label === node; - case 206: + case 216: return node.parent.name === node; } } function emitExpressionIdentifier(node) { - var prefix = resolver.getExpressionNamePrefix(node); - if (prefix) { - write(prefix); - write("."); + var substitution = resolver.getExpressionNameSubstitution(node); + if (substitution) { + write(substitution); + } + else { + writeTextOfNode(currentSourceFile, node); } - writeTextOfNode(currentSourceFile, node); } function emitIdentifier(node) { if (!node.parent) { @@ -18002,11 +18404,11 @@ var ts; function needsParenthesisForPropertyAccess(node) { switch (node.kind) { case 64: - case 149: case 151: - case 152: case 153: - case 157: + case 154: + case 155: + case 159: return false; } return true; @@ -18023,14 +18425,14 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 169) { + if (e.kind === 171) { e = e.expression; emitParenthesized(e, group === 0 && needsParenthesisForPropertyAccess(e)); pos++; } else { var i = pos; - while (i < length && elements[i].kind !== 169) { + while (i < length && elements[i].kind !== 171) { i++; } write("["); @@ -18051,7 +18453,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 169; + return node.kind === 171; } function emitArrayLiteral(node) { var elements = node.elements; @@ -18079,7 +18481,7 @@ var ts; } function createDownlevelObjectLiteralWithComputedProperties(originalObjectLiteral, firstComputedPropertyIndex) { var tempVar = createAndRecordTempVariable(originalObjectLiteral); - var initialObjectLiteral = createSynthesizedNode(150); + var initialObjectLiteral = createSynthesizedNode(152); initialObjectLiteral.properties = originalObjectLiteral.properties.slice(0, firstComputedPropertyIndex); initialObjectLiteral.flags |= 256; var propertyPatches = createBinaryExpression(tempVar, 52, initialObjectLiteral); @@ -18104,20 +18506,19 @@ var ts; } function tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral, property) { switch (property.kind) { - case 207: + case 217: return property.initializer; - case 208: - var prefix = createIdentifier(resolver.getExpressionNamePrefix(property.name)); - return createPropertyAccessExpression(prefix, property.name); - case 130: - return createFunctionExpression(property.parameters, property.body); + case 218: + return createIdentifier(resolver.getExpressionNameSubstitution(property.name)); case 132: - case 133: + return createFunctionExpression(property.parameters, property.body); + case 134: + case 135: var _a = getAllAccessorDeclarations(objectLiteral.properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; if (firstAccessor !== property) { return undefined; } - var propertyDescriptor = createSynthesizedNode(150); + var propertyDescriptor = createSynthesizedNode(152); var descriptorProperties = []; if (getAccessor) { var getProperty = createPropertyAssignment(createIdentifier("get"), createFunctionExpression(getAccessor.parameters, getAccessor.body)); @@ -18140,7 +18541,7 @@ var ts; } } function createParenthesizedExpression(expression) { - var result = createSynthesizedNode(157); + var result = createSynthesizedNode(159); result.expression = expression; return result; } @@ -18155,7 +18556,7 @@ var ts; return result; } function createBinaryExpression(left, operator, right) { - var result = createSynthesizedNode(165); + var result = createSynthesizedNode(167); result.operatorToken = createSynthesizedNode(operator); result.left = left; result.right = right; @@ -18168,7 +18569,7 @@ var ts; else if (memberName.kind === 8 || memberName.kind === 7) { return createElementAccessExpression(expression, memberName); } - else if (memberName.kind === 124) { + else if (memberName.kind === 126) { return createElementAccessExpression(expression, memberName.expression); } else { @@ -18176,25 +18577,25 @@ var ts; } } function createPropertyAssignment(name, initializer) { - var result = createSynthesizedNode(207); + var result = createSynthesizedNode(217); result.name = name; result.initializer = initializer; return result; } function createFunctionExpression(parameters, body) { - var result = createSynthesizedNode(158); + var result = createSynthesizedNode(160); result.parameters = parameters; result.body = body; return result; } function createPropertyAccessExpression(expression, name) { - var result = createSynthesizedNode(151); + var result = createSynthesizedNode(153); result.expression = expression; result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = createSynthesizedNode(152); + var result = createSynthesizedNode(154); result.expression = expression; result.argumentExpression = argumentExpression; return result; @@ -18205,7 +18606,7 @@ var ts; return result; } function createCallExpression(invokedExpression, arguments) { - var result = createSynthesizedNode(153); + var result = createSynthesizedNode(155); result.expression = invokedExpression; result.arguments = arguments; return result; @@ -18216,7 +18617,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 === 124) { + if (properties[i].name.kind === 126) { numInitialNonComputedProperties = i; break; } @@ -18253,7 +18654,7 @@ var ts; } function emitShorthandPropertyAssignment(node) { emit(node.name); - if (languageVersion <= 1 || resolver.getExpressionNamePrefix(node.name)) { + if (languageVersion < 2 || resolver.getExpressionNameSubstitution(node.name)) { write(": "); emitExpressionIdentifier(node.name); } @@ -18263,7 +18664,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 151 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 153 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -18293,10 +18694,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 169; }); + return ts.forEach(elements, function (e) { return e.kind === 171; }); } function skipParentheses(node) { - while (node.kind === 157 || node.kind === 156) { + while (node.kind === 159 || node.kind === 158) { node = node.expression; } return node; @@ -18317,12 +18718,12 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 151) { + if (expr.kind === 153) { target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 152) { + else if (expr.kind === 154) { target = emitCallTarget(expr.expression); write("["); emit(expr.argumentExpression); @@ -18363,7 +18764,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 151 && node.expression.expression.kind === 90; + superCall = node.expression.kind === 153 && node.expression.expression.kind === 90; } if (superCall) { write(".call("); @@ -18395,19 +18796,19 @@ var ts; emit(node.template); } function emitParenExpression(node) { - if (node.expression.kind === 156) { + if (node.expression.kind === 158) { var operand = node.expression.expression; - while (operand.kind == 156) { + while (operand.kind == 158) { operand = operand.expression; } - if (operand.kind !== 163 && - operand.kind !== 162 && - operand.kind !== 161 && - operand.kind !== 160 && + if (operand.kind !== 165 && operand.kind !== 164 && - operand.kind !== 154 && - !(operand.kind === 153 && node.parent.kind === 154) && - !(operand.kind === 158 && node.parent.kind === 153)) { + operand.kind !== 163 && + operand.kind !== 162 && + operand.kind !== 166 && + operand.kind !== 156 && + !(operand.kind === 155 && node.parent.kind === 156) && + !(operand.kind === 160 && node.parent.kind === 155)) { emit(operand); return; } @@ -18433,7 +18834,7 @@ var ts; } function emitPrefixUnaryExpression(node) { write(ts.tokenToString(node.operator)); - if (node.operand.kind === 163) { + if (node.operand.kind === 165) { var operand = node.operand; if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { write(" "); @@ -18450,7 +18851,7 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 && node.operatorToken.kind === 52 && - (node.left.kind === 150 || node.left.kind === 149)) { + (node.left.kind === 152 || node.left.kind === 151)) { emitDestructuring(node); } else { @@ -18499,7 +18900,7 @@ var ts; emit(node.whenFalse); } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 172) { + if (node && node.kind === 174) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -18514,12 +18915,12 @@ var ts; emitToken(14, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 199) { - ts.Debug.assert(node.parent.kind === 198); + if (node.kind === 201) { + ts.Debug.assert(node.parent.kind === 200); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 199) { + if (node.kind === 201) { emitTempDeclarations(true); } decreaseIndent(); @@ -18528,7 +18929,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 172) { + if (node.kind === 174) { write(" "); emit(node); } @@ -18540,7 +18941,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesized(node.expression, node.expression.kind === 159); + emitParenthesized(node.expression, node.expression.kind === 161); write(";"); } function emitIfStatement(node) { @@ -18553,7 +18954,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(75, node.thenStatement.end); - if (node.elseStatement.kind === 176) { + if (node.elseStatement.kind === 178) { write(" "); emit(node.elseStatement); } @@ -18565,7 +18966,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 172) { + if (node.statement.kind === 174) { write(" "); } else { @@ -18585,11 +18986,11 @@ var ts; var endPos = emitToken(81, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer && node.initializer.kind === 192) { + if (node.initializer && node.initializer.kind === 194) { var variableDeclarationList = node.initializer; var declarations = variableDeclarationList.declarations; if (declarations[0] && ts.isLet(declarations[0])) { - emitToken(103, endPos); + emitToken(105, endPos); } else if (declarations[0] && ts.isConst(declarations[0])) { emitToken(69, endPos); @@ -18614,12 +19015,12 @@ var ts; var endPos = emitToken(81, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; if (ts.isLet(decl)) { - emitToken(103, endPos); + emitToken(105, endPos); } else { emitToken(97, endPos); @@ -18631,7 +19032,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 180) { + if (node.kind === 182) { write(" in "); } else { @@ -18642,7 +19043,7 @@ var ts; emitEmbeddedStatement(node.statement); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 183 ? 65 : 70, node.pos); + emitToken(node.kind === 185 ? 65 : 70, node.pos); emitOptional(" ", node.label); write(";"); } @@ -18684,7 +19085,7 @@ var ts; getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 203) { + if (node.kind === 213) { write("case "); emit(node.expression); write(":"); @@ -18739,23 +19140,41 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 198); + } while (node && node.kind !== 200); return node; } + function emitContainingModuleName(node) { + var container = getContainingModule(node); + write(container ? resolver.getGeneratedNameForNode(container) : "exports"); + } function emitModuleMemberName(node) { emitStart(node.name); if (ts.getCombinedNodeFlags(node) & 1) { - var container = getContainingModule(node); - write(container ? resolver.getLocalNameOfContainer(container) : "exports"); + emitContainingModuleName(node); write("."); } emitNode(node.name); emitEnd(node.name); } + function emitExportMemberAssignments(name) { + if (exportSpecifiers && ts.hasProperty(exportSpecifiers, name.text)) { + ts.forEach(exportSpecifiers[name.text], function (specifier) { + writeLine(); + emitStart(specifier.name); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + emitEnd(specifier.name); + write(" = "); + emitNode(name); + write(";"); + }); + } + } function emitDestructuring(root, value) { var emitCount = 0; - var isDeclaration = (root.kind === 191 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 126; - if (root.kind === 165) { + var isDeclaration = (root.kind === 193 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 128; + if (root.kind === 167) { emitAssignmentExpression(root); } else { @@ -18765,7 +19184,7 @@ var ts; if (emitCount++) { write(", "); } - if (name.parent && (name.parent.kind === 191 || name.parent.kind === 148)) { + if (name.parent && (name.parent.kind === 193 || name.parent.kind === 150)) { emitModuleMemberName(name.parent); } else { @@ -18788,17 +19207,17 @@ var ts; function createVoidZero() { var zero = ts.createNode(7); zero.text = "0"; - var result = ts.createNode(162); + var result = ts.createNode(164); result.expression = zero; return result; } function createDefaultValueCheck(value, defaultValue) { value = ensureIdentifier(value); - var equals = ts.createNode(165); + var equals = ts.createNode(167); equals.left = value; equals.operatorToken = ts.createNode(30); equals.right = createVoidZero(); - var cond = ts.createNode(166); + var cond = ts.createNode(168); cond.condition = equals; cond.whenTrue = defaultValue; cond.whenFalse = value; @@ -18810,10 +19229,10 @@ var ts; return node; } function parenthesizeForAccess(expr) { - if (expr.kind === 64 || expr.kind === 151 || expr.kind === 152) { + if (expr.kind === 64 || expr.kind === 153 || expr.kind === 154) { return expr; } - var node = ts.createNode(157); + var node = ts.createNode(159); node.expression = expr; return node; } @@ -18821,13 +19240,13 @@ var ts; if (propName.kind !== 64) { return createElementAccess(object, propName); } - var node = ts.createNode(151); + var node = ts.createNode(153); node.expression = parenthesizeForAccess(object); node.name = propName; return node; } function createElementAccess(object, index) { - var node = ts.createNode(152); + var node = ts.createNode(154); node.expression = parenthesizeForAccess(object); node.argumentExpression = index; return node; @@ -18839,7 +19258,7 @@ var ts; } for (var i = 0; i < properties.length; i++) { var p = properties[i]; - if (p.kind === 207 || p.kind === 208) { + if (p.kind === 217 || p.kind === 218) { var propName = (p.name); emitDestructuringAssignment(p.initializer || propName, createPropertyAccess(value, propName)); } @@ -18852,8 +19271,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 170) { - if (e.kind !== 169) { + if (e.kind !== 172) { + if (e.kind !== 171) { emitDestructuringAssignment(e, createElementAccess(value, createNumericLiteral(i))); } else { @@ -18867,14 +19286,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 165 && target.operatorToken.kind === 52) { + if (target.kind === 167 && target.operatorToken.kind === 52) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 150) { + if (target.kind === 152) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 149) { + else if (target.kind === 151) { emitArrayLiteralAssignment(target, value); } else { @@ -18884,18 +19303,18 @@ var ts; function emitAssignmentExpression(root) { var target = root.left; var value = root.right; - if (root.parent.kind === 175) { + if (root.parent.kind === 177) { emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 157) { + if (root.parent.kind !== 159) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 157) { + if (root.parent.kind !== 159) { write(")"); } } @@ -18915,11 +19334,11 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 146) { + if (pattern.kind === 148) { var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccess(value, propName)); } - else if (element.kind !== 170) { + else if (element.kind !== 172) { if (!element.dotDotDotToken) { emitBindingElement(element, createElementAccess(value, createNumericLiteral(i))); } @@ -18953,6 +19372,15 @@ var ts; emitOptional(" = ", node.initializer); } } + function emitExportVariableAssignments(node) { + var name = node.name; + if (name.kind === 64) { + emitExportMemberAssignments(name); + } + else if (ts.isBindingPattern(name)) { + ts.forEach(name.elements, emitExportVariableAssignments); + } + } function emitVariableStatement(node) { if (!(node.flags & 1)) { if (ts.isLet(node.declarationList)) { @@ -18967,6 +19395,9 @@ var ts; } emitCommaList(node.declarationList.declarations); write(";"); + if (languageVersion < 2 && node.parent === currentSourceFile) { + ts.forEach(node.declarationList.declarations, emitExportVariableAssignments); + } } function emitParameter(node) { if (languageVersion < 2) { @@ -19058,28 +19489,31 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 132 ? "get " : "set "); + write(node.kind === 134 ? "get " : "set "); emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 159 && languageVersion >= 2; + return node.kind === 161 && languageVersion >= 2; } function emitFunctionDeclaration(node) { if (ts.nodeIsMissing(node.body)) { return emitPinnedOrTripleSlashComments(node); } - if (node.kind !== 130 && node.kind !== 129) { + if (node.kind !== 132 && node.kind !== 131) { emitLeadingComments(node); } if (!shouldEmitAsArrowFunction(node)) { write("function "); } - if (node.kind === 193 || (node.kind === 158 && node.name)) { + if (node.kind === 195 || (node.kind === 160 && node.name)) { emit(node.name); } emitSignatureAndBody(node); - if (node.kind !== 130 && node.kind !== 129) { + if (languageVersion < 2 && node.kind === 195 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + if (node.kind !== 132 && node.kind !== 131) { emitTrailingComments(node); } } @@ -19123,10 +19557,10 @@ var ts; else { emitSignatureParameters(node); } - if (isSingleLineEmptyBlock(node.body) || !node.body) { + if (!node.body) { write(" { }"); } - else if (node.body.kind === 172) { + else if (node.body.kind === 174) { emitBlockFunctionBody(node, node.body); } else { @@ -19151,6 +19585,14 @@ var ts; emitRestParameter(node); } function emitExpressionFunctionBody(node, body) { + if (languageVersion < 2) { + emitDownLevelExpressionFunctionBody(node, body); + return; + } + write(" "); + emit(body); + } + function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); scopeEmitStart(node); increaseIndent(); @@ -19187,6 +19629,36 @@ var ts; scopeEmitEnd(); } function emitBlockFunctionBody(node, body) { + if (body.statements.length === 0 && !anyParameterHasBindingPatternOrInitializer(node)) { + emitFunctionBodyWithNoStatements(node, body); + } + else { + emitFunctionBodyWithStatements(node, body); + } + } + function anyParameterHasBindingPatternOrInitializer(func) { + return ts.forEach(func.parameters, hasBindingPatternOrInitializer); + } + function hasBindingPatternOrInitializer(parameter) { + return parameter.initializer || ts.isBindingPattern(parameter.name); + } + function emitFunctionBodyWithNoStatements(node, body) { + var singleLine = isSingleLineEmptyBlock(node.body); + write(" {"); + if (singleLine) { + write(" "); + } + else { + increaseIndent(); + writeLine(); + } + emitLeadingCommentsOfPosition(body.statements.end); + if (!singleLine) { + decreaseIndent(); + } + emitToken(15, body.statements.end); + } + function emitFunctionBodyWithStatements(node, body) { write(" {"); scopeEmitStart(node); var outPos = writer.getTextPos(); @@ -19219,9 +19691,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 175) { + if (statement && statement.kind === 177) { var expr = statement.expression; - if (expr && expr.kind === 153) { + if (expr && expr.kind === 155) { var func = expr.expression; if (func && func.kind === 90) { return statement; @@ -19252,7 +19724,7 @@ var ts; emitNode(memberName); write("]"); } - else if (memberName.kind === 124) { + else if (memberName.kind === 126) { emitComputedPropertyName(memberName); } else { @@ -19262,7 +19734,7 @@ var ts; } function emitMemberAssignments(node, staticFlag) { ts.forEach(node.members, function (member) { - if (member.kind === 128 && (member.flags & 128) === staticFlag && member.initializer) { + if (member.kind === 130 && (member.flags & 128) === staticFlag && member.initializer) { writeLine(); emitLeadingComments(member); emitStart(member); @@ -19285,7 +19757,7 @@ var ts; } function emitMemberFunctions(node) { ts.forEach(node.members, function (member) { - if (member.kind === 130 || node.kind === 129) { + if (member.kind === 132 || node.kind === 131) { if (!member.body) { return emitPinnedOrTripleSlashComments(member); } @@ -19307,7 +19779,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 132 || member.kind === 133) { + else if (member.kind === 134 || member.kind === 135) { var accessors = getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -19407,6 +19879,9 @@ var ts; emitEnd(node); write(";"); } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } function emitConstructorOfClass() { var saveTempCount = tempCount; var saveTempVariables = tempVariables; @@ -19415,7 +19890,7 @@ var ts; tempVariables = undefined; tempParameters = undefined; ts.forEach(node.members, function (member) { - if (member.kind === 131 && !member.body) { + if (member.kind === 133 && !member.body) { emitPinnedOrTripleSlashComments(member); } }); @@ -19500,7 +19975,7 @@ var ts; emitStart(node); write("(function ("); emitStart(node.name); - write(resolver.getLocalNameOfContainer(node)); + write(resolver.getGeneratedNameForNode(node)); emitEnd(node.name); write(") {"); increaseIndent(); @@ -19526,13 +20001,16 @@ var ts; emitEnd(node); write(";"); } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } } function emitEnumMember(node) { var enumParent = node.parent; emitStart(node); - write(resolver.getLocalNameOfContainer(enumParent)); + write(resolver.getGeneratedNameForNode(enumParent)); write("["); - write(resolver.getLocalNameOfContainer(enumParent)); + write(resolver.getGeneratedNameForNode(enumParent)); write("["); emitExpressionForPropertyName(node.name); write("] = "); @@ -19558,7 +20036,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 198) { + if (moduleDeclaration.body.kind === 200) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -19580,10 +20058,10 @@ var ts; emitStart(node); write("(function ("); emitStart(node.name); - write(resolver.getLocalNameOfContainer(node)); + write(resolver.getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 199) { + if (node.body.kind === 201) { var saveTempCount = tempCount; var saveTempVariables = tempVariables; tempCount = 0; @@ -19615,63 +20093,194 @@ var ts; emitModuleMemberName(node); write(" = {}));"); emitEnd(node); + if (languageVersion < 2 && node.name.kind === 64 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + } + function emitRequire(moduleName) { + if (moduleName.kind === 8) { + write("require("); + emitStart(moduleName); + emitLiteral(moduleName); + emitEnd(moduleName); + emitToken(17, moduleName.end); + write(";"); + } + else { + write("require();"); + } } function emitImportDeclaration(node) { - var emitImportDeclaration = resolver.isReferencedImportDeclaration(node); - if (!emitImportDeclaration) { - emitImportDeclaration = !ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportWithEntityName(node); - } - if (emitImportDeclaration) { - if (ts.isExternalModuleImportDeclaration(node) && node.parent.kind === 210 && compilerOptions.module === 2) { - if (node.flags & 1) { - writeLine(); - emitLeadingComments(node); - emitStart(node); - emitModuleMemberName(node); - write(" = "); - emit(node.name); - write(";"); - emitEnd(node); - emitTrailingComments(node); - } - } - else { - writeLine(); + var info = getExternalImportInfo(node); + if (info) { + var declarationNode = info.declarationNode; + var namedImports = info.namedImports; + if (compilerOptions.module !== 2) { emitLeadingComments(node); emitStart(node); - if (!(node.flags & 1)) + var moduleName = ts.getExternalModuleName(node); + if (declarationNode) { + if (!(declarationNode.flags & 1)) + write("var "); + emitModuleMemberName(declarationNode); + write(" = "); + emitRequire(moduleName); + } + else if (namedImports) { write("var "); - emitModuleMemberName(node); - write(" = "); - if (ts.isInternalModuleImportDeclaration(node)) { - emit(node.moduleReference); + write(resolver.getGeneratedNameForNode(node)); + write(" = "); + emitRequire(moduleName); } else { - var literal = ts.getExternalModuleImportDeclarationExpression(node); - write("require("); - emitStart(literal); - emitLiteral(literal); - emitEnd(literal); - emitToken(17, literal.end); + emitRequire(moduleName); } - write(";"); emitEnd(node); emitTrailingComments(node); } + else { + if (declarationNode) { + if (declarationNode.flags & 1) { + emitModuleMemberName(declarationNode); + write(" = "); + emit(declarationNode.name); + write(";"); + } + } + } } } - function getExternalImportDeclarations(node) { - var result = []; - ts.forEach(node.statements, function (statement) { - if (ts.isExternalModuleImportDeclaration(statement) && resolver.isReferencedImportDeclaration(statement)) { - result.push(statement); + function emitImportEqualsDeclaration(node) { + if (ts.isExternalModuleImportEqualsDeclaration(node)) { + emitImportDeclaration(node); + return; + } + if (resolver.isReferencedImportDeclaration(node) || + (!ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node))) { + emitLeadingComments(node); + emitStart(node); + if (!(node.flags & 1)) + write("var "); + emitModuleMemberName(node); + write(" = "); + emit(node.moduleReference); + write(";"); + emitEnd(node); + emitTrailingComments(node); + } + } + function emitExportDeclaration(node) { + if (node.moduleSpecifier) { + emitStart(node); + var generatedName = resolver.getGeneratedNameForNode(node); + if (compilerOptions.module !== 2) { + write("var "); + write(generatedName); + write(" = "); + emitRequire(ts.getExternalModuleName(node)); + } + if (node.exportClause) { + ts.forEach(node.exportClause.elements, function (specifier) { + writeLine(); + emitStart(specifier); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + write(" = "); + write(generatedName); + write("."); + emitNode(specifier.propertyName || specifier.name); + write(";"); + emitEnd(specifier); + }); + } + else { + var tempName = createTempVariable(node).text; + writeLine(); + write("for (var " + tempName + " in " + generatedName + ") if (!"); + emitContainingModuleName(node); + write(".hasOwnProperty(" + tempName + ")) "); + emitContainingModuleName(node); + write("[" + tempName + "] = " + generatedName + "[" + tempName + "];"); + } + emitEnd(node); + } + } + function createExternalImportInfo(node) { + if (node.kind === 202) { + if (node.moduleReference.kind === 212) { + return { + rootNode: node, + declarationNode: node + }; + } + } + else if (node.kind === 203) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + return { + rootNode: node, + declarationNode: importClause + }; + } + if (importClause.namedBindings.kind === 205) { + return { + rootNode: node, + declarationNode: importClause.namedBindings + }; + } + return { + rootNode: node, + namedImports: importClause.namedBindings, + localName: resolver.getGeneratedNameForNode(node) + }; + } + return { + rootNode: node + }; + } + else if (node.kind === 209) { + if (node.moduleSpecifier) { + return { + rootNode: node + }; + } + } + } + function createExternalModuleInfo(sourceFile) { + externalImports = []; + exportSpecifiers = {}; + ts.forEach(sourceFile.statements, function (node) { + if (node.kind === 209 && !node.moduleSpecifier) { + ts.forEach(node.exportClause.elements, function (specifier) { + var name = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier); + }); + } + else { + var info = createExternalImportInfo(node); + if (info) { + if ((!info.declarationNode && !info.namedImports) || resolver.isReferencedImportDeclaration(node)) { + externalImports.push(info); + } + } } }); - return result; + } + function getExternalImportInfo(node) { + if (externalImports) { + for (var i = 0; i < externalImports.length; i++) { + var info = externalImports[i]; + if (info.rootNode === node) { + return info; + } + } + } } function getFirstExportAssignment(sourceFile) { return ts.forEach(sourceFile.statements, function (node) { - if (node.kind === 201) { + if (node.kind === 208) { return node; } }); @@ -19690,7 +20299,6 @@ var ts; }); } function emitAMDModule(node, startIndex) { - var imports = getExternalImportDeclarations(node); writeLine(); write("define("); sortAMDModules(node.amdDependencies); @@ -19698,9 +20306,15 @@ var ts; write("\"" + node.amdModuleName + "\", "); } write("[\"require\", \"exports\""); - ts.forEach(imports, function (imp) { + ts.forEach(externalImports, function (info) { write(", "); - emitLiteral(ts.getExternalModuleImportDeclarationExpression(imp)); + var moduleName = ts.getExternalModuleName(info.rootNode); + if (moduleName.kind === 8) { + emitLiteral(moduleName); + } + else { + write("\"\""); + } }); ts.forEach(node.amdDependencies, function (amdDependency) { var text = "\"" + amdDependency.path + "\""; @@ -19708,9 +20322,14 @@ var ts; write(text); }); write("], function (require, exports"); - ts.forEach(imports, function (imp) { + ts.forEach(externalImports, function (info) { write(", "); - emit(imp.name); + if (info.declarationNode) { + emit(info.declarationNode.name); + } + else { + write(resolver.getGeneratedNameForNode(info.rootNode)); + } }); ts.forEach(node.amdDependencies, function (amdDependency) { if (amdDependency.name) { @@ -19793,6 +20412,7 @@ var ts; extendsEmitted = true; } if (ts.isExternalModule(node)) { + createExternalModuleInfo(node); if (compilerOptions.module === 2) { emitAMDModule(node, startIndex); } @@ -19801,6 +20421,8 @@ var ts; } } else { + externalImports = undefined; + exportSpecifiers = undefined; emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); emitTempDeclarations(true); @@ -19825,15 +20447,16 @@ var ts; } function shouldEmitLeadingAndTrailingComments(node) { switch (node.kind) { - case 195: - case 193: - case 200: - case 196: - case 201: - return false; - case 198: - return shouldEmitModuleDeclaration(node); case 197: + case 195: + case 203: + case 202: + case 198: + case 208: + return false; + case 200: + return shouldEmitModuleDeclaration(node); + case 199: return shouldEmitEnumDeclaration(node); } return true; @@ -19842,13 +20465,13 @@ var ts; switch (node.kind) { case 64: return emitIdentifier(node); - case 126: + case 128: return emitParameter(node); - case 130: - case 129: - return emitMethod(node); case 132: - case 133: + case 131: + return emitMethod(node); + case 134: + case 135: return emitAccessor(node); case 92: return emitThis(node); @@ -19868,121 +20491,125 @@ var ts; case 12: case 13: return emitLiteral(node); - case 167: - return emitTemplateExpression(node); - case 171: - return emitTemplateSpan(node); - case 123: - return emitQualifiedName(node); - case 146: - return emitObjectBindingPattern(node); - case 147: - return emitArrayBindingPattern(node); - case 148: - return emitBindingElement(node); - case 149: - return emitArrayLiteral(node); - case 150: - return emitObjectLiteral(node); - case 207: - return emitPropertyAssignment(node); - case 208: - return emitShorthandPropertyAssignment(node); - case 124: - return emitComputedPropertyName(node); - case 151: - return emitPropertyAccess(node); - case 152: - return emitIndexedAccess(node); - case 153: - return emitCallExpression(node); - case 154: - return emitNewExpression(node); - case 155: - return emitTaggedTemplateExpression(node); - case 156: - return emit(node.expression); - case 157: - return emitParenExpression(node); - case 193: - case 158: - case 159: - return emitFunctionDeclaration(node); - case 160: - return emitDeleteExpression(node); - case 161: - return emitTypeOfExpression(node); - case 162: - return emitVoidExpression(node); - case 163: - return emitPrefixUnaryExpression(node); - case 164: - return emitPostfixUnaryExpression(node); - case 165: - return emitBinaryExpression(node); - case 166: - return emitConditionalExpression(node); case 169: - return emitSpreadElementExpression(node); - case 170: - return; - case 172: - case 199: - return emitBlock(node); + return emitTemplateExpression(node); case 173: - return emitVariableStatement(node); - case 174: - return write(";"); - case 175: - return emitExpressionStatement(node); - case 176: - return emitIfStatement(node); - case 177: - return emitDoStatement(node); - case 178: - return emitWhileStatement(node); - case 179: - return emitForStatement(node); - case 181: - case 180: - return emitForInOrForOfStatement(node); - case 182: - case 183: - return emitBreakOrContinueStatement(node); - case 184: - return emitReturnStatement(node); - case 185: - return emitWithStatement(node); - case 186: - return emitSwitchStatement(node); - case 203: - case 204: - return emitCaseOrDefaultClause(node); - case 187: - return emitLabelledStatement(node); - case 188: - return emitThrowStatement(node); - case 189: - return emitTryStatement(node); - case 206: - return emitCatchClause(node); - case 190: - return emitDebuggerStatement(node); - case 191: - return emitVariableDeclaration(node); - case 194: - return emitClassDeclaration(node); + return emitTemplateSpan(node); + case 125: + return emitQualifiedName(node); + case 148: + return emitObjectBindingPattern(node); + case 149: + return emitArrayBindingPattern(node); + case 150: + return emitBindingElement(node); + case 151: + return emitArrayLiteral(node); + case 152: + return emitObjectLiteral(node); + case 217: + return emitPropertyAssignment(node); + case 218: + return emitShorthandPropertyAssignment(node); + case 126: + return emitComputedPropertyName(node); + case 153: + return emitPropertyAccess(node); + case 154: + return emitIndexedAccess(node); + case 155: + return emitCallExpression(node); + case 156: + return emitNewExpression(node); + case 157: + return emitTaggedTemplateExpression(node); + case 158: + return emit(node.expression); + case 159: + return emitParenExpression(node); case 195: - return emitInterfaceDeclaration(node); + case 160: + case 161: + return emitFunctionDeclaration(node); + case 162: + return emitDeleteExpression(node); + case 163: + return emitTypeOfExpression(node); + case 164: + return emitVoidExpression(node); + case 165: + return emitPrefixUnaryExpression(node); + case 166: + return emitPostfixUnaryExpression(node); + case 167: + return emitBinaryExpression(node); + case 168: + return emitConditionalExpression(node); + case 171: + return emitSpreadElementExpression(node); + case 172: + return; + case 174: + case 201: + return emitBlock(node); + case 175: + return emitVariableStatement(node); + case 176: + return write(";"); + case 177: + return emitExpressionStatement(node); + case 178: + return emitIfStatement(node); + case 179: + return emitDoStatement(node); + case 180: + return emitWhileStatement(node); + case 181: + return emitForStatement(node); + case 183: + case 182: + return emitForInOrForOfStatement(node); + case 184: + case 185: + return emitBreakOrContinueStatement(node); + case 186: + return emitReturnStatement(node); + case 187: + return emitWithStatement(node); + case 188: + return emitSwitchStatement(node); + case 213: + case 214: + return emitCaseOrDefaultClause(node); + case 189: + return emitLabelledStatement(node); + case 190: + return emitThrowStatement(node); + case 191: + return emitTryStatement(node); + case 216: + return emitCatchClause(node); + case 192: + return emitDebuggerStatement(node); + case 193: + return emitVariableDeclaration(node); + case 196: + return emitClassDeclaration(node); case 197: + return emitInterfaceDeclaration(node); + case 199: return emitEnumDeclaration(node); - case 209: + case 219: return emitEnumMember(node); - case 198: - return emitModuleDeclaration(node); case 200: + return emitModuleDeclaration(node); + case 203: return emitImportDeclaration(node); - case 210: + case 202: + return emitImportEqualsDeclaration(node); + case 209: + return emitExportDeclaration(node); + case 220: return emitSourceFile(node); } } @@ -20001,7 +20628,7 @@ var ts; } function getLeadingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 210 || node.pos !== node.parent.pos) { + if (node.parent.kind === 220 || node.pos !== node.parent.pos) { var leadingComments; if (hasDetachedComments(node.pos)) { leadingComments = getLeadingCommentsWithoutDetachedComments(); @@ -20020,7 +20647,7 @@ var ts; } function emitTrailingDeclarationComments(node) { if (node.parent) { - if (node.parent.kind === 210 || node.end !== node.parent.end) { + if (node.parent.kind === 220 || node.end !== node.parent.end) { var trailingComments = ts.getTrailingCommentRanges(currentSourceFile.text, node.end); emitComments(currentSourceFile, writer, trailingComments, false, newLine, writeComment); } @@ -20400,30 +21027,31 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (ts.isExternalModuleImportDeclaration(node) && - ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - var nameLiteral = ts.getExternalModuleImportDeclarationExpression(node); - var moduleName = nameLiteral.text; - if (moduleName) { - var searchPath = basePath; - while (true) { - var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleName)); - if (findModuleSourceFile(searchName + ".ts", nameLiteral) || findModuleSourceFile(searchName + ".d.ts", nameLiteral)) { - break; + if (node.kind === 203 || node.kind === 202 || node.kind === 209) { + var moduleNameExpr = ts.getExternalModuleName(node); + if (moduleNameExpr && moduleNameExpr.kind === 8) { + var moduleNameText = moduleNameExpr.text; + if (moduleNameText) { + var searchPath = basePath; + while (true) { + var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleNameText)); + if (findModuleSourceFile(searchName + ".ts", moduleNameExpr) || findModuleSourceFile(searchName + ".d.ts", moduleNameExpr)) { + break; + } + var parentPath = ts.getDirectoryPath(searchPath); + if (parentPath === searchPath) { + break; + } + searchPath = parentPath; } - var parentPath = ts.getDirectoryPath(searchPath); - if (parentPath === searchPath) { - break; - } - searchPath = parentPath; } } } - else if (node.kind === 198 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { + else if (node.kind === 200 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { ts.forEachChild(node.body, function (node) { - if (ts.isExternalModuleImportDeclaration(node) && - ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - var nameLiteral = ts.getExternalModuleImportDeclarationExpression(node); + if (ts.isExternalModuleImportEqualsDeclaration(node) && + ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8) { + var nameLiteral = ts.getExternalModuleImportEqualsDeclarationExpression(node); var moduleName = nameLiteral.text; if (moduleName) { var searchName = ts.normalizePath(ts.combinePaths(basePath, moduleName)); diff --git a/bin/tsserver.js b/bin/tsserver.js new file mode 100644 index 00000000000..fa69f8cf5fa --- /dev/null +++ b/bin/tsserver.js @@ -0,0 +1,31943 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +var ts; +(function (ts) { + (function (ExitStatus) { + ExitStatus[ExitStatus["Success"] = 0] = "Success"; + ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped"; + ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated"; + })(ts.ExitStatus || (ts.ExitStatus = {})); + var ExitStatus = ts.ExitStatus; + (function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message"; + })(ts.DiagnosticCategory || (ts.DiagnosticCategory = {})); + var DiagnosticCategory = ts.DiagnosticCategory; +})(ts || (ts = {})); +var ts; +(function (ts) { + function forEach(array, callback) { + if (array) { + for (var i = 0, len = array.length; i < len; i++) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + } + return undefined; + } + ts.forEach = forEach; + function contains(array, value) { + if (array) { + for (var i = 0, len = array.length; i < len; i++) { + if (array[i] === value) { + return true; + } + } + } + return false; + } + ts.contains = contains; + function indexOf(array, value) { + if (array) { + for (var i = 0, len = array.length; i < len; i++) { + if (array[i] === value) { + return i; + } + } + } + return -1; + } + ts.indexOf = indexOf; + function countWhere(array, predicate) { + var count = 0; + if (array) { + for (var i = 0, len = array.length; i < len; i++) { + if (predicate(array[i])) { + count++; + } + } + } + return count; + } + ts.countWhere = countWhere; + function filter(array, f) { + if (array) { + var result = []; + for (var i = 0, len = array.length; i < len; i++) { + var item = array[i]; + if (f(item)) { + result.push(item); + } + } + } + return result; + } + ts.filter = filter; + function map(array, f) { + if (array) { + var result = []; + for (var i = 0, len = array.length; i < len; i++) { + result.push(f(array[i])); + } + } + return result; + } + ts.map = map; + function concatenate(array1, array2) { + if (!array2 || !array2.length) + return array1; + if (!array1 || !array1.length) + return array2; + return array1.concat(array2); + } + ts.concatenate = concatenate; + function deduplicate(array) { + if (array) { + var result = []; + for (var i = 0, len = array.length; i < len; i++) { + var item = array[i]; + if (!contains(result, item)) + result.push(item); + } + } + return result; + } + ts.deduplicate = deduplicate; + function sum(array, prop) { + var result = 0; + for (var i = 0; i < array.length; i++) { + result += array[i][prop]; + } + return result; + } + ts.sum = sum; + function addRange(to, from) { + for (var i = 0, n = from.length; i < n; i++) { + to.push(from[i]); + } + } + ts.addRange = addRange; + function lastOrUndefined(array) { + if (array.length === 0) { + return undefined; + } + return array[array.length - 1]; + } + ts.lastOrUndefined = lastOrUndefined; + function binarySearch(array, value) { + var low = 0; + var high = array.length - 1; + while (low <= high) { + var middle = low + ((high - low) >> 1); + var midValue = array[middle]; + if (midValue === value) { + return middle; + } + else if (midValue > value) { + high = middle - 1; + } + else { + low = middle + 1; + } + } + return ~low; + } + ts.binarySearch = binarySearch; + var hasOwnProperty = Object.prototype.hasOwnProperty; + function hasProperty(map, key) { + return hasOwnProperty.call(map, key); + } + ts.hasProperty = hasProperty; + function getProperty(map, key) { + return hasOwnProperty.call(map, key) ? map[key] : undefined; + } + ts.getProperty = getProperty; + function isEmpty(map) { + for (var id in map) { + if (hasProperty(map, id)) { + return false; + } + } + return true; + } + ts.isEmpty = isEmpty; + function clone(object) { + var result = {}; + for (var id in object) { + result[id] = object[id]; + } + return result; + } + ts.clone = clone; + function extend(first, second) { + var result = {}; + for (var id in first) { + result[id] = first[id]; + } + for (var id in second) { + if (!hasProperty(result, id)) { + result[id] = second[id]; + } + } + return result; + } + ts.extend = extend; + function forEachValue(map, callback) { + var result; + for (var id in map) { + if (result = callback(map[id])) + break; + } + return result; + } + ts.forEachValue = forEachValue; + function forEachKey(map, callback) { + var result; + for (var id in map) { + if (result = callback(id)) + break; + } + return result; + } + ts.forEachKey = forEachKey; + function lookUp(map, key) { + return hasProperty(map, key) ? map[key] : undefined; + } + ts.lookUp = lookUp; + function mapToArray(map) { + var result = []; + for (var id in map) { + result.push(map[id]); + } + return result; + } + ts.mapToArray = mapToArray; + function copyMap(source, target) { + for (var p in source) { + target[p] = source[p]; + } + } + ts.copyMap = copyMap; + function arrayToMap(array, makeKey) { + var result = {}; + forEach(array, function (value) { + result[makeKey(value)] = value; + }); + return result; + } + ts.arrayToMap = arrayToMap; + function formatStringFromArgs(text, args, baseIndex) { + baseIndex = baseIndex || 0; + return text.replace(/{(\d+)}/g, function (match, index) { return args[+index + baseIndex]; }); + } + ts.localizedDiagnosticMessages = undefined; + function getLocaleSpecificMessage(message) { + return ts.localizedDiagnosticMessages && ts.localizedDiagnosticMessages[message] ? ts.localizedDiagnosticMessages[message] : message; + } + ts.getLocaleSpecificMessage = getLocaleSpecificMessage; + function createFileDiagnostic(file, start, length, message) { + Debug.assert(start >= 0, "start must be non-negative, is " + start); + Debug.assert(length >= 0, "length must be non-negative, is " + length); + var text = getLocaleSpecificMessage(message.key); + if (arguments.length > 4) { + text = formatStringFromArgs(text, arguments, 4); + } + return { + file: file, + start: start, + length: length, + messageText: text, + category: message.category, + code: message.code + }; + } + ts.createFileDiagnostic = createFileDiagnostic; + function createCompilerDiagnostic(message) { + var text = getLocaleSpecificMessage(message.key); + if (arguments.length > 1) { + text = formatStringFromArgs(text, arguments, 1); + } + return { + file: undefined, + start: undefined, + length: undefined, + messageText: text, + category: message.category, + code: message.code + }; + } + ts.createCompilerDiagnostic = createCompilerDiagnostic; + function chainDiagnosticMessages(details, message) { + var text = getLocaleSpecificMessage(message.key); + if (arguments.length > 2) { + text = formatStringFromArgs(text, arguments, 2); + } + return { + messageText: text, + category: message.category, + code: message.code, + next: details + }; + } + ts.chainDiagnosticMessages = chainDiagnosticMessages; + function concatenateDiagnosticMessageChains(headChain, tailChain) { + Debug.assert(!headChain.next); + headChain.next = tailChain; + return headChain; + } + ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains; + function compareValues(a, b) { + if (a === b) + return 0; + if (a === undefined) + return -1; + if (b === undefined) + return 1; + return a < b ? -1 : 1; + } + ts.compareValues = compareValues; + function getDiagnosticFileName(diagnostic) { + return diagnostic.file ? diagnostic.file.fileName : undefined; + } + function compareDiagnostics(d1, d2) { + return compareValues(getDiagnosticFileName(d1), getDiagnosticFileName(d2)) || + compareValues(d1.start, d2.start) || + compareValues(d1.length, d2.length) || + compareValues(d1.code, d2.code) || + compareMessageText(d1.messageText, d2.messageText) || + 0; + } + ts.compareDiagnostics = compareDiagnostics; + function compareMessageText(text1, text2) { + while (text1 && text2) { + var string1 = typeof text1 === "string" ? text1 : text1.messageText; + var string2 = typeof text2 === "string" ? text2 : text2.messageText; + var res = compareValues(string1, string2); + if (res) { + return res; + } + text1 = typeof text1 === "string" ? undefined : text1.next; + text2 = typeof text2 === "string" ? undefined : text2.next; + } + if (!text1 && !text2) { + return 0; + } + return text1 ? 1 : -1; + } + function sortAndDeduplicateDiagnostics(diagnostics) { + return deduplicateSortedDiagnostics(diagnostics.sort(compareDiagnostics)); + } + ts.sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics; + function deduplicateSortedDiagnostics(diagnostics) { + if (diagnostics.length < 2) { + return diagnostics; + } + var newDiagnostics = [diagnostics[0]]; + var previousDiagnostic = diagnostics[0]; + for (var i = 1; i < diagnostics.length; i++) { + var currentDiagnostic = diagnostics[i]; + var isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === 0; + if (!isDupe) { + newDiagnostics.push(currentDiagnostic); + previousDiagnostic = currentDiagnostic; + } + } + return newDiagnostics; + } + ts.deduplicateSortedDiagnostics = deduplicateSortedDiagnostics; + function normalizeSlashes(path) { + return path.replace(/\\/g, "/"); + } + ts.normalizeSlashes = normalizeSlashes; + function getRootLength(path) { + if (path.charCodeAt(0) === 47) { + if (path.charCodeAt(1) !== 47) + return 1; + var p1 = path.indexOf("/", 2); + if (p1 < 0) + return 2; + var p2 = path.indexOf("/", p1 + 1); + if (p2 < 0) + return p1 + 1; + return p2 + 1; + } + if (path.charCodeAt(1) === 58) { + if (path.charCodeAt(2) === 47) + return 3; + return 2; + } + return 0; + } + ts.getRootLength = getRootLength; + ts.directorySeparator = "/"; + function getNormalizedParts(normalizedSlashedPath, rootLength) { + var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator); + var normalized = []; + for (var i = 0; i < parts.length; i++) { + var part = parts[i]; + if (part !== ".") { + if (part === ".." && normalized.length > 0 && normalized[normalized.length - 1] !== "..") { + normalized.pop(); + } + else { + normalized.push(part); + } + } + } + return normalized; + } + function normalizePath(path) { + var path = normalizeSlashes(path); + var rootLength = getRootLength(path); + var normalized = getNormalizedParts(path, rootLength); + return path.substr(0, rootLength) + normalized.join(ts.directorySeparator); + } + ts.normalizePath = normalizePath; + function getDirectoryPath(path) { + return path.substr(0, Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator))); + } + ts.getDirectoryPath = getDirectoryPath; + function isUrl(path) { + return path && !isRootedDiskPath(path) && path.indexOf("://") !== -1; + } + ts.isUrl = isUrl; + function isRootedDiskPath(path) { + return getRootLength(path) !== 0; + } + ts.isRootedDiskPath = isRootedDiskPath; + function normalizedPathComponents(path, rootLength) { + var normalizedParts = getNormalizedParts(path, rootLength); + return [path.substr(0, rootLength)].concat(normalizedParts); + } + function getNormalizedPathComponents(path, currentDirectory) { + var path = normalizeSlashes(path); + var rootLength = getRootLength(path); + if (rootLength == 0) { + path = combinePaths(normalizeSlashes(currentDirectory), path); + rootLength = getRootLength(path); + } + return normalizedPathComponents(path, rootLength); + } + ts.getNormalizedPathComponents = getNormalizedPathComponents; + function getNormalizedAbsolutePath(fileName, currentDirectory) { + return getNormalizedPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory)); + } + ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath; + function getNormalizedPathFromPathComponents(pathComponents) { + if (pathComponents && pathComponents.length) { + return pathComponents[0] + pathComponents.slice(1).join(ts.directorySeparator); + } + } + ts.getNormalizedPathFromPathComponents = getNormalizedPathFromPathComponents; + function getNormalizedPathComponentsOfUrl(url) { + var urlLength = url.length; + var rootLength = url.indexOf("://") + "://".length; + while (rootLength < urlLength) { + if (url.charCodeAt(rootLength) === 47) { + rootLength++; + } + else { + break; + } + } + if (rootLength === urlLength) { + return [url]; + } + var indexOfNextSlash = url.indexOf(ts.directorySeparator, rootLength); + if (indexOfNextSlash !== -1) { + rootLength = indexOfNextSlash + 1; + return normalizedPathComponents(url, rootLength); + } + else { + return [url + ts.directorySeparator]; + } + } + function getNormalizedPathOrUrlComponents(pathOrUrl, currentDirectory) { + if (isUrl(pathOrUrl)) { + return getNormalizedPathComponentsOfUrl(pathOrUrl); + } + else { + return getNormalizedPathComponents(pathOrUrl, currentDirectory); + } + } + function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) { + var pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory); + var directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory); + if (directoryComponents.length > 1 && directoryComponents[directoryComponents.length - 1] === "") { + directoryComponents.length--; + } + for (var joinStartIndex = 0; joinStartIndex < pathComponents.length && joinStartIndex < directoryComponents.length; joinStartIndex++) { + if (getCanonicalFileName(directoryComponents[joinStartIndex]) !== getCanonicalFileName(pathComponents[joinStartIndex])) { + break; + } + } + if (joinStartIndex) { + var relativePath = ""; + var relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length); + for (; joinStartIndex < directoryComponents.length; joinStartIndex++) { + if (directoryComponents[joinStartIndex] !== "") { + relativePath = relativePath + ".." + ts.directorySeparator; + } + } + return relativePath + relativePathComponents.join(ts.directorySeparator); + } + var absolutePath = getNormalizedPathFromPathComponents(pathComponents); + if (isAbsolutePathAnUrl && isRootedDiskPath(absolutePath)) { + absolutePath = "file:///" + absolutePath; + } + return absolutePath; + } + ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl; + function getBaseFileName(path) { + var i = path.lastIndexOf(ts.directorySeparator); + return i < 0 ? path : path.substring(i + 1); + } + ts.getBaseFileName = getBaseFileName; + function combinePaths(path1, path2) { + if (!(path1 && path1.length)) + return path2; + if (!(path2 && path2.length)) + return path1; + if (getRootLength(path2) !== 0) + return path2; + if (path1.charAt(path1.length - 1) === ts.directorySeparator) + return path1 + path2; + return path1 + ts.directorySeparator + path2; + } + ts.combinePaths = combinePaths; + function fileExtensionIs(path, extension) { + var pathLen = path.length; + var extLen = extension.length; + return pathLen > extLen && path.substr(pathLen - extLen, extLen) === extension; + } + ts.fileExtensionIs = fileExtensionIs; + var supportedExtensions = [".d.ts", ".ts", ".js"]; + function removeFileExtension(path) { + for (var i = 0; i < supportedExtensions.length; i++) { + var ext = supportedExtensions[i]; + if (fileExtensionIs(path, ext)) { + return path.substr(0, path.length - ext.length); + } + } + return path; + } + ts.removeFileExtension = removeFileExtension; + var backslashOrDoubleQuote = /[\"\\]/g; + var escapedCharsRegExp = /[\0-\19\t\v\f\b\0\r\n\u2028\u2029\u0085]/g; + var escapedCharsMap = { + "\0": "\\0", + "\t": "\\t", + "\v": "\\v", + "\f": "\\f", + "\b": "\\b", + "\r": "\\r", + "\n": "\\n", + "\\": "\\\\", + "\"": "\\\"", + "\u2028": "\\u2028", + "\u2029": "\\u2029", + "\u0085": "\\u0085" + }; + function escapeString(s) { + s = backslashOrDoubleQuote.test(s) ? s.replace(backslashOrDoubleQuote, getReplacement) : s; + s = escapedCharsRegExp.test(s) ? s.replace(escapedCharsRegExp, getReplacement) : s; + return s; + function getReplacement(c) { + return escapedCharsMap[c] || unicodeEscape(c); + } + function unicodeEscape(c) { + var hexCharCode = c.charCodeAt(0).toString(16); + var paddedHexCode = ("0000" + hexCharCode).slice(-4); + return "\\u" + paddedHexCode; + } + } + ts.escapeString = escapeString; + function getDefaultLibFileName(options) { + return options.target === 2 ? "lib.es6.d.ts" : "lib.d.ts"; + } + ts.getDefaultLibFileName = getDefaultLibFileName; + function Symbol(flags, name) { + this.flags = flags; + this.name = name; + this.declarations = undefined; + } + function Type(checker, flags) { + this.flags = flags; + } + function Signature(checker) { + } + ts.objectAllocator = { + getNodeConstructor: function (kind) { + function Node() { + } + Node.prototype = { + kind: kind, + pos: 0, + end: 0, + flags: 0, + parent: undefined + }; + return Node; + }, + getSymbolConstructor: function () { return Symbol; }, + getTypeConstructor: function () { return Type; }, + getSignatureConstructor: function () { return Signature; } + }; + var Debug; + (function (Debug) { + var currentAssertionLevel = 0; + function shouldAssert(level) { + return currentAssertionLevel >= level; + } + Debug.shouldAssert = shouldAssert; + function assert(expression, message, verboseDebugInfo) { + if (!expression) { + var verboseDebugString = ""; + if (verboseDebugInfo) { + verboseDebugString = "\r\nVerbose Debug Information: " + verboseDebugInfo(); + } + throw new Error("Debug Failure. False expression: " + (message || "") + verboseDebugString); + } + } + Debug.assert = assert; + function fail(message) { + Debug.assert(false, message); + } + Debug.fail = fail; + })(Debug = ts.Debug || (ts.Debug = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.sys = (function () { + function getWScriptSystem() { + var fso = new ActiveXObject("Scripting.FileSystemObject"); + var fileStream = new ActiveXObject("ADODB.Stream"); + fileStream.Type = 2; + var binaryStream = new ActiveXObject("ADODB.Stream"); + binaryStream.Type = 1; + var args = []; + for (var i = 0; i < WScript.Arguments.length; i++) { + args[i] = WScript.Arguments.Item(i); + } + function readFile(fileName, encoding) { + if (!fso.FileExists(fileName)) { + return undefined; + } + fileStream.Open(); + try { + if (encoding) { + fileStream.Charset = encoding; + fileStream.LoadFromFile(fileName); + } + else { + fileStream.Charset = "x-ansi"; + fileStream.LoadFromFile(fileName); + var bom = fileStream.ReadText(2) || ""; + fileStream.Position = 0; + fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8"; + } + return fileStream.ReadText(); + } + catch (e) { + throw e; + } + finally { + fileStream.Close(); + } + } + function writeFile(fileName, data, writeByteOrderMark) { + fileStream.Open(); + binaryStream.Open(); + try { + fileStream.Charset = "utf-8"; + fileStream.WriteText(data); + if (writeByteOrderMark) { + fileStream.Position = 0; + } + else { + fileStream.Position = 3; + } + fileStream.CopyTo(binaryStream); + binaryStream.SaveToFile(fileName, 2); + } + finally { + binaryStream.Close(); + fileStream.Close(); + } + } + function getNames(collection) { + var result = []; + for (var e = new Enumerator(collection); !e.atEnd(); e.moveNext()) { + result.push(e.item().Name); + } + return result.sort(); + } + function readDirectory(path, extension) { + var result = []; + visitDirectory(path); + return result; + function visitDirectory(path) { + var folder = fso.GetFolder(path || "."); + var files = getNames(folder.files); + for (var i = 0; i < files.length; i++) { + var name = files[i]; + if (!extension || ts.fileExtensionIs(name, extension)) { + result.push(ts.combinePaths(path, name)); + } + } + var subfolders = getNames(folder.subfolders); + for (var i = 0; i < subfolders.length; i++) { + visitDirectory(ts.combinePaths(path, subfolders[i])); + } + } + } + return { + args: args, + newLine: "\r\n", + useCaseSensitiveFileNames: false, + write: function (s) { + WScript.StdOut.Write(s); + }, + readFile: readFile, + writeFile: writeFile, + resolvePath: function (path) { + return fso.GetAbsolutePathName(path); + }, + fileExists: function (path) { + return fso.FileExists(path); + }, + directoryExists: function (path) { + return fso.FolderExists(path); + }, + createDirectory: function (directoryName) { + if (!this.directoryExists(directoryName)) { + fso.CreateFolder(directoryName); + } + }, + getExecutingFilePath: function () { + return WScript.ScriptFullName; + }, + getCurrentDirectory: function () { + return new ActiveXObject("WScript.Shell").CurrentDirectory; + }, + readDirectory: readDirectory, + exit: function (exitCode) { + try { + WScript.Quit(exitCode); + } + catch (e) { + } + } + }; + } + function getNodeSystem() { + var _fs = require("fs"); + var _path = require("path"); + var _os = require('os'); + var platform = _os.platform(); + var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin"; + function readFile(fileName, encoding) { + if (!_fs.existsSync(fileName)) { + return undefined; + } + var buffer = _fs.readFileSync(fileName); + var len = buffer.length; + if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { + len &= ~1; + for (var i = 0; i < len; i += 2) { + var temp = buffer[i]; + buffer[i] = buffer[i + 1]; + buffer[i + 1] = temp; + } + return buffer.toString("utf16le", 2); + } + if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { + return buffer.toString("utf16le", 2); + } + if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { + return buffer.toString("utf8", 3); + } + return buffer.toString("utf8"); + } + function writeFile(fileName, data, writeByteOrderMark) { + if (writeByteOrderMark) { + data = '\uFEFF' + data; + } + _fs.writeFileSync(fileName, data, "utf8"); + } + function readDirectory(path, extension) { + var result = []; + visitDirectory(path); + return result; + function visitDirectory(path) { + var files = _fs.readdirSync(path || ".").sort(); + var directories = []; + for (var i = 0; i < files.length; i++) { + var name = ts.combinePaths(path, files[i]); + var stat = _fs.lstatSync(name); + if (stat.isFile()) { + if (!extension || ts.fileExtensionIs(name, extension)) { + result.push(name); + } + } + else if (stat.isDirectory()) { + directories.push(name); + } + } + for (var i = 0; i < directories.length; i++) { + visitDirectory(directories[i]); + } + } + } + return { + args: process.argv.slice(2), + newLine: _os.EOL, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + write: function (s) { + _fs.writeSync(1, s); + }, + readFile: readFile, + writeFile: writeFile, + watchFile: function (fileName, callback) { + _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged); + return { + close: function () { _fs.unwatchFile(fileName, fileChanged); } + }; + function fileChanged(curr, prev) { + if (+curr.mtime <= +prev.mtime) { + return; + } + callback(fileName); + } + ; + }, + resolvePath: function (path) { + return _path.resolve(path); + }, + fileExists: function (path) { + return _fs.existsSync(path); + }, + directoryExists: function (path) { + return _fs.existsSync(path) && _fs.statSync(path).isDirectory(); + }, + createDirectory: function (directoryName) { + if (!this.directoryExists(directoryName)) { + _fs.mkdirSync(directoryName); + } + }, + getExecutingFilePath: function () { + return __filename; + }, + getCurrentDirectory: function () { + return process.cwd(); + }, + readDirectory: readDirectory, + getMemoryUsage: function () { + if (global.gc) { + global.gc(); + } + return process.memoryUsage().heapUsed; + }, + exit: function (exitCode) { + process.exit(exitCode); + } + }; + } + if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") { + return getWScriptSystem(); + } + else if (typeof module !== "undefined" && module.exports) { + return getNodeSystem(); + } + else { + return undefined; + } + })(); +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.Diagnostics = { + Unterminated_string_literal: { code: 1002, category: 1, key: "Unterminated string literal." }, + Identifier_expected: { code: 1003, category: 1, key: "Identifier expected." }, + _0_expected: { code: 1005, category: 1, key: "'{0}' expected." }, + A_file_cannot_have_a_reference_to_itself: { code: 1006, category: 1, key: "A file cannot have a reference to itself." }, + Trailing_comma_not_allowed: { code: 1009, category: 1, key: "Trailing comma not allowed." }, + Asterisk_Slash_expected: { code: 1010, category: 1, key: "'*/' expected." }, + Unexpected_token: { code: 1012, category: 1, key: "Unexpected token." }, + Catch_clause_parameter_cannot_have_a_type_annotation: { code: 1013, category: 1, key: "Catch clause parameter cannot have a type annotation." }, + A_rest_parameter_must_be_last_in_a_parameter_list: { code: 1014, category: 1, key: "A rest parameter must be last in a parameter list." }, + Parameter_cannot_have_question_mark_and_initializer: { code: 1015, category: 1, key: "Parameter cannot have question mark and initializer." }, + A_required_parameter_cannot_follow_an_optional_parameter: { code: 1016, category: 1, key: "A required parameter cannot follow an optional parameter." }, + An_index_signature_cannot_have_a_rest_parameter: { code: 1017, category: 1, key: "An index signature cannot have a rest parameter." }, + An_index_signature_parameter_cannot_have_an_accessibility_modifier: { code: 1018, category: 1, key: "An index signature parameter cannot have an accessibility modifier." }, + An_index_signature_parameter_cannot_have_a_question_mark: { code: 1019, category: 1, key: "An index signature parameter cannot have a question mark." }, + An_index_signature_parameter_cannot_have_an_initializer: { code: 1020, category: 1, key: "An index signature parameter cannot have an initializer." }, + An_index_signature_must_have_a_type_annotation: { code: 1021, category: 1, key: "An index signature must have a type annotation." }, + An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: 1, key: "An index signature parameter must have a type annotation." }, + An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: 1, 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: 1, key: "A class or interface declaration can only have one 'extends' clause." }, + An_extends_clause_must_precede_an_implements_clause: { code: 1025, category: 1, key: "An 'extends' clause must precede an 'implements' clause." }, + A_class_can_only_extend_a_single_class: { code: 1026, category: 1, key: "A class can only extend a single class." }, + A_class_declaration_can_only_have_one_implements_clause: { code: 1027, category: 1, key: "A class declaration can only have one 'implements' clause." }, + Accessibility_modifier_already_seen: { code: 1028, category: 1, key: "Accessibility modifier already seen." }, + _0_modifier_must_precede_1_modifier: { code: 1029, category: 1, key: "'{0}' modifier must precede '{1}' modifier." }, + _0_modifier_already_seen: { code: 1030, category: 1, key: "'{0}' modifier already seen." }, + _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: 1, key: "'{0}' modifier cannot appear on a class element." }, + An_interface_declaration_cannot_have_an_implements_clause: { code: 1032, category: 1, key: "An interface declaration cannot have an 'implements' clause." }, + super_must_be_followed_by_an_argument_list_or_member_access: { code: 1034, category: 1, key: "'super' must be followed by an argument list or member access." }, + Only_ambient_modules_can_use_quoted_names: { code: 1035, category: 1, key: "Only ambient modules can use quoted names." }, + Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: 1, key: "Statements are not allowed in ambient contexts." }, + A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: 1, key: "A 'declare' modifier cannot be used in an already ambient context." }, + Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: 1, key: "Initializers are not allowed in ambient contexts." }, + _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: 1, key: "'{0}' modifier cannot appear on a module element." }, + A_declare_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: 1, 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: 1, 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: 1, key: "A rest parameter cannot be optional." }, + A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: 1, key: "A rest parameter cannot have an initializer." }, + A_set_accessor_must_have_exactly_one_parameter: { code: 1049, category: 1, key: "A 'set' accessor must have exactly one parameter." }, + A_set_accessor_cannot_have_an_optional_parameter: { code: 1051, category: 1, key: "A 'set' accessor cannot have an optional parameter." }, + A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: 1, key: "A 'set' accessor parameter cannot have an initializer." }, + A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: 1, key: "A 'set' accessor cannot have rest parameter." }, + A_get_accessor_cannot_have_parameters: { code: 1054, category: 1, key: "A 'get' accessor cannot have parameters." }, + Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: 1, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, + Enum_member_must_have_initializer: { code: 1061, category: 1, key: "Enum member must have initializer." }, + An_export_assignment_cannot_be_used_in_an_internal_module: { code: 1063, category: 1, key: "An export assignment cannot be used in an internal module." }, + Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: 1, key: "Ambient enum elements can only have integer literal initializers." }, + Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: 1, key: "Unexpected token. A constructor, method, accessor, or property was expected." }, + A_declare_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: 1, key: "A 'declare' modifier cannot be used with an import declaration." }, + Invalid_reference_directive_syntax: { code: 1084, category: 1, key: "Invalid 'reference' directive syntax." }, + Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: 1, key: "Octal literals are not available when targeting ECMAScript 5 and higher." }, + An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: 1, key: "An accessor cannot be declared in an ambient context." }, + _0_modifier_cannot_appear_on_a_constructor_declaration: { code: 1089, category: 1, key: "'{0}' modifier cannot appear on a constructor declaration." }, + _0_modifier_cannot_appear_on_a_parameter: { code: 1090, category: 1, key: "'{0}' modifier cannot appear on a parameter." }, + Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: { code: 1091, category: 1, key: "Only a single variable declaration is allowed in a 'for...in' statement." }, + Type_parameters_cannot_appear_on_a_constructor_declaration: { code: 1092, category: 1, key: "Type parameters cannot appear on a constructor declaration." }, + Type_annotation_cannot_appear_on_a_constructor_declaration: { code: 1093, category: 1, key: "Type annotation cannot appear on a constructor declaration." }, + An_accessor_cannot_have_type_parameters: { code: 1094, category: 1, key: "An accessor cannot have type parameters." }, + A_set_accessor_cannot_have_a_return_type_annotation: { code: 1095, category: 1, key: "A 'set' accessor cannot have a return type annotation." }, + An_index_signature_must_have_exactly_one_parameter: { code: 1096, category: 1, key: "An index signature must have exactly one parameter." }, + _0_list_cannot_be_empty: { code: 1097, category: 1, key: "'{0}' list cannot be empty." }, + Type_parameter_list_cannot_be_empty: { code: 1098, category: 1, key: "Type parameter list cannot be empty." }, + Type_argument_list_cannot_be_empty: { code: 1099, category: 1, key: "Type argument list cannot be empty." }, + Invalid_use_of_0_in_strict_mode: { code: 1100, category: 1, key: "Invalid use of '{0}' in strict mode." }, + with_statements_are_not_allowed_in_strict_mode: { code: 1101, category: 1, key: "'with' statements are not allowed in strict mode." }, + delete_cannot_be_called_on_an_identifier_in_strict_mode: { code: 1102, category: 1, key: "'delete' cannot be called on an identifier in strict mode." }, + A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: { code: 1104, category: 1, key: "A 'continue' statement can only be used within an enclosing iteration statement." }, + A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: { code: 1105, category: 1, key: "A 'break' statement can only be used within an enclosing iteration or switch statement." }, + Jump_target_cannot_cross_function_boundary: { code: 1107, category: 1, key: "Jump target cannot cross function boundary." }, + A_return_statement_can_only_be_used_within_a_function_body: { code: 1108, category: 1, key: "A 'return' statement can only be used within a function body." }, + Expression_expected: { code: 1109, category: 1, key: "Expression expected." }, + Type_expected: { code: 1110, category: 1, key: "Type expected." }, + A_class_member_cannot_be_declared_optional: { code: 1112, category: 1, key: "A class member cannot be declared optional." }, + A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: { code: 1113, category: 1, key: "A 'default' clause cannot appear more than once in a 'switch' statement." }, + Duplicate_label_0: { code: 1114, category: 1, key: "Duplicate label '{0}'" }, + A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: { code: 1115, category: 1, key: "A 'continue' statement can only jump to a label of an enclosing iteration statement." }, + A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: { code: 1116, category: 1, key: "A 'break' statement can only jump to a label of an enclosing statement." }, + An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: { code: 1117, category: 1, key: "An object literal cannot have multiple properties with the same name in strict mode." }, + An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: 1, key: "An object literal cannot have multiple get/set accessors with the same name." }, + An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: 1, key: "An object literal cannot have property and accessor with the same name." }, + An_export_assignment_cannot_have_modifiers: { code: 1120, category: 1, key: "An export assignment cannot have modifiers." }, + Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: 1, key: "Octal literals are not allowed in strict mode." }, + A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: 1, key: "A tuple type element list cannot be empty." }, + Variable_declaration_list_cannot_be_empty: { code: 1123, category: 1, key: "Variable declaration list cannot be empty." }, + Digit_expected: { code: 1124, category: 1, key: "Digit expected." }, + Hexadecimal_digit_expected: { code: 1125, category: 1, key: "Hexadecimal digit expected." }, + Unexpected_end_of_text: { code: 1126, category: 1, key: "Unexpected end of text." }, + Invalid_character: { code: 1127, category: 1, key: "Invalid character." }, + Declaration_or_statement_expected: { code: 1128, category: 1, key: "Declaration or statement expected." }, + Statement_expected: { code: 1129, category: 1, key: "Statement expected." }, + case_or_default_expected: { code: 1130, category: 1, key: "'case' or 'default' expected." }, + Property_or_signature_expected: { code: 1131, category: 1, key: "Property or signature expected." }, + Enum_member_expected: { code: 1132, category: 1, key: "Enum member expected." }, + Type_reference_expected: { code: 1133, category: 1, key: "Type reference expected." }, + Variable_declaration_expected: { code: 1134, category: 1, key: "Variable declaration expected." }, + Argument_expression_expected: { code: 1135, category: 1, key: "Argument expression expected." }, + Property_assignment_expected: { code: 1136, category: 1, key: "Property assignment expected." }, + Expression_or_comma_expected: { code: 1137, category: 1, key: "Expression or comma expected." }, + Parameter_declaration_expected: { code: 1138, category: 1, key: "Parameter declaration expected." }, + Type_parameter_declaration_expected: { code: 1139, category: 1, key: "Type parameter declaration expected." }, + Type_argument_expected: { code: 1140, category: 1, key: "Type argument expected." }, + String_literal_expected: { code: 1141, category: 1, key: "String literal expected." }, + Line_break_not_permitted_here: { code: 1142, category: 1, key: "Line break not permitted here." }, + or_expected: { code: 1144, category: 1, key: "'{' or ';' expected." }, + Modifiers_not_permitted_on_index_signature_members: { code: 1145, category: 1, key: "Modifiers not permitted on index signature members." }, + Declaration_expected: { code: 1146, category: 1, key: "Declaration expected." }, + Import_declarations_in_an_internal_module_cannot_reference_an_external_module: { code: 1147, category: 1, key: "Import declarations in an internal module cannot reference an external module." }, + Cannot_compile_external_modules_unless_the_module_flag_is_provided: { code: 1148, category: 1, key: "Cannot compile external modules unless the '--module' flag is provided." }, + File_name_0_differs_from_already_included_file_name_1_only_in_casing: { code: 1149, category: 1, 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: 1, key: "'new T[]' cannot be used to create an array. Use 'new Array()' instead." }, + var_let_or_const_expected: { code: 1152, category: 1, key: "'var', 'let' or 'const' expected." }, + let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1153, category: 1, 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: 1, key: "'const' declarations are only available when targeting ECMAScript 6 and higher." }, + const_declarations_must_be_initialized: { code: 1155, category: 1, key: "'const' declarations must be initialized" }, + const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: 1, key: "'const' declarations can only be declared inside a block." }, + let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: 1, key: "'let' declarations can only be declared inside a block." }, + Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1159, category: 1, key: "Tagged templates are only available when targeting ECMAScript 6 and higher." }, + Unterminated_template_literal: { code: 1160, category: 1, key: "Unterminated template literal." }, + Unterminated_regular_expression_literal: { code: 1161, category: 1, key: "Unterminated regular expression literal." }, + An_object_member_cannot_be_declared_optional: { code: 1162, category: 1, key: "An object member cannot be declared optional." }, + yield_expression_must_be_contained_within_a_generator_declaration: { code: 1163, category: 1, key: "'yield' expression must be contained_within a generator declaration." }, + Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: 1, 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: 1, 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: 1, 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: 1, 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: 1, 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: 1, 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: 1, key: "A computed property name in a type literal must directly refer to a built-in symbol." }, + A_comma_expression_is_not_allowed_in_a_computed_property_name: { code: 1171, category: 1, key: "A comma expression is not allowed in a computed property name." }, + extends_clause_already_seen: { code: 1172, category: 1, key: "'extends' clause already seen." }, + extends_clause_must_precede_implements_clause: { code: 1173, category: 1, key: "'extends' clause must precede 'implements' clause." }, + Classes_can_only_extend_a_single_class: { code: 1174, category: 1, key: "Classes can only extend a single class." }, + implements_clause_already_seen: { code: 1175, category: 1, key: "'implements' clause already seen." }, + Interface_declaration_cannot_have_implements_clause: { code: 1176, category: 1, key: "Interface declaration cannot have 'implements' clause." }, + Binary_digit_expected: { code: 1177, category: 1, key: "Binary digit expected." }, + Octal_digit_expected: { code: 1178, category: 1, key: "Octal digit expected." }, + Unexpected_token_expected: { code: 1179, category: 1, key: "Unexpected token. '{' expected." }, + Property_destructuring_pattern_expected: { code: 1180, category: 1, key: "Property destructuring pattern expected." }, + Array_element_destructuring_pattern_expected: { code: 1181, category: 1, key: "Array element destructuring pattern expected." }, + A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: 1, key: "A destructuring declaration must have an initializer." }, + Destructuring_declarations_are_not_allowed_in_ambient_contexts: { code: 1183, category: 1, key: "Destructuring declarations are not allowed in ambient contexts." }, + An_implementation_cannot_be_declared_in_ambient_contexts: { code: 1184, category: 1, key: "An implementation cannot be declared in ambient contexts." }, + Modifiers_cannot_appear_here: { code: 1184, category: 1, key: "Modifiers cannot appear here." }, + Merge_conflict_marker_encountered: { code: 1185, category: 1, key: "Merge conflict marker encountered." }, + A_rest_element_cannot_have_an_initializer: { code: 1186, category: 1, key: "A rest element cannot have an initializer." }, + A_parameter_property_may_not_be_a_binding_pattern: { code: 1187, category: 1, key: "A parameter property may not be a binding pattern." }, + Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: 1, key: "Only a single variable declaration is allowed in a 'for...of' statement." }, + The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: 1, key: "The variable declaration of a 'for...in' statement cannot have an initializer." }, + The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: 1, key: "The variable declaration of a 'for...of' statement cannot have an initializer." }, + An_import_declaration_cannot_have_modifiers: { code: 1191, category: 1, key: "An import declaration cannot have modifiers." }, + External_module_0_has_no_default_export_or_export_assignment: { code: 1192, category: 1, key: "External module '{0}' has no default export or export assignment." }, + An_export_declaration_cannot_have_modifiers: { code: 1193, category: 1, key: "An export declaration cannot have modifiers." }, + Export_declarations_are_not_permitted_in_an_internal_module: { code: 1194, category: 1, key: "Export declarations are not permitted in an internal module." }, + Duplicate_identifier_0: { code: 2300, category: 1, key: "Duplicate identifier '{0}'." }, + Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: 1, 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: 1, key: "Static members cannot reference class type parameters." }, + Circular_definition_of_import_alias_0: { code: 2303, category: 1, key: "Circular definition of import alias '{0}'." }, + Cannot_find_name_0: { code: 2304, category: 1, key: "Cannot find name '{0}'." }, + Module_0_has_no_exported_member_1: { code: 2305, category: 1, key: "Module '{0}' has no exported member '{1}'." }, + File_0_is_not_an_external_module: { code: 2306, category: 1, key: "File '{0}' is not an external module." }, + Cannot_find_external_module_0: { code: 2307, category: 1, key: "Cannot find external module '{0}'." }, + A_module_cannot_have_more_than_one_export_assignment: { code: 2308, category: 1, 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: 1, 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: 1, key: "Type '{0}' recursively references itself as a base type." }, + A_class_may_only_extend_another_class: { code: 2311, category: 1, key: "A class may only extend another class." }, + An_interface_may_only_extend_a_class_or_another_interface: { code: 2312, category: 1, key: "An interface may only extend a class or another interface." }, + Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list: { code: 2313, category: 1, key: "Constraint of a type parameter cannot reference any type parameter from the same type parameter list." }, + Generic_type_0_requires_1_type_argument_s: { code: 2314, category: 1, key: "Generic type '{0}' requires {1} type argument(s)." }, + Type_0_is_not_generic: { code: 2315, category: 1, key: "Type '{0}' is not generic." }, + Global_type_0_must_be_a_class_or_interface_type: { code: 2316, category: 1, key: "Global type '{0}' must be a class or interface type." }, + Global_type_0_must_have_1_type_parameter_s: { code: 2317, category: 1, key: "Global type '{0}' must have {1} type parameter(s)." }, + Cannot_find_global_type_0: { code: 2318, category: 1, key: "Cannot find global type '{0}'." }, + Named_property_0_of_types_1_and_2_are_not_identical: { code: 2319, category: 1, key: "Named property '{0}' of types '{1}' and '{2}' are not identical." }, + Interface_0_cannot_simultaneously_extend_types_1_and_2: { code: 2320, category: 1, key: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'." }, + Excessive_stack_depth_comparing_types_0_and_1: { code: 2321, category: 1, key: "Excessive stack depth comparing types '{0}' and '{1}'." }, + Type_0_is_not_assignable_to_type_1: { code: 2322, category: 1, key: "Type '{0}' is not assignable to type '{1}'." }, + Property_0_is_missing_in_type_1: { code: 2324, category: 1, key: "Property '{0}' is missing in type '{1}'." }, + Property_0_is_private_in_type_1_but_not_in_type_2: { code: 2325, category: 1, key: "Property '{0}' is private in type '{1}' but not in type '{2}'." }, + Types_of_property_0_are_incompatible: { code: 2326, category: 1, key: "Types of property '{0}' are incompatible." }, + Property_0_is_optional_in_type_1_but_required_in_type_2: { code: 2327, category: 1, key: "Property '{0}' is optional in type '{1}' but required in type '{2}'." }, + Types_of_parameters_0_and_1_are_incompatible: { code: 2328, category: 1, key: "Types of parameters '{0}' and '{1}' are incompatible." }, + Index_signature_is_missing_in_type_0: { code: 2329, category: 1, key: "Index signature is missing in type '{0}'." }, + Index_signatures_are_incompatible: { code: 2330, category: 1, key: "Index signatures are incompatible." }, + this_cannot_be_referenced_in_a_module_body: { code: 2331, category: 1, key: "'this' cannot be referenced in a module body." }, + this_cannot_be_referenced_in_current_location: { code: 2332, category: 1, key: "'this' cannot be referenced in current location." }, + this_cannot_be_referenced_in_constructor_arguments: { code: 2333, category: 1, key: "'this' cannot be referenced in constructor arguments." }, + this_cannot_be_referenced_in_a_static_property_initializer: { code: 2334, category: 1, key: "'this' cannot be referenced in a static property initializer." }, + super_can_only_be_referenced_in_a_derived_class: { code: 2335, category: 1, key: "'super' can only be referenced in a derived class." }, + super_cannot_be_referenced_in_constructor_arguments: { code: 2336, category: 1, key: "'super' cannot be referenced in constructor arguments." }, + Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: { code: 2337, category: 1, 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: 1, 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: 1, 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: 1, 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: 1, 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: 1, 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: 1, key: "Type '{0}' does not satisfy the constraint '{1}'." }, + Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: { code: 2345, category: 1, key: "Argument of type '{0}' is not assignable to parameter of type '{1}'." }, + Supplied_parameters_do_not_match_any_signature_of_call_target: { code: 2346, category: 1, key: "Supplied parameters do not match any signature of call target." }, + Untyped_function_calls_may_not_accept_type_arguments: { code: 2347, category: 1, key: "Untyped function calls may not accept type arguments." }, + Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: { code: 2348, category: 1, key: "Value of type '{0}' is not callable. Did you mean to include 'new'?" }, + Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: { code: 2349, category: 1, key: "Cannot invoke an expression whose type lacks a call signature." }, + Only_a_void_function_can_be_called_with_the_new_keyword: { code: 2350, category: 1, key: "Only a void function can be called with the 'new' keyword." }, + Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature: { code: 2351, category: 1, key: "Cannot use 'new' with an expression whose type lacks a call or construct signature." }, + Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: 1, key: "Neither type '{0}' nor type '{1}' is assignable to the other." }, + No_best_common_type_exists_among_return_expressions: { code: 2354, category: 1, key: "No best common type exists among return expressions." }, + A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: 1, key: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." }, + An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: 1, key: "An arithmetic operand must be of type 'any', 'number' or an enum type." }, + The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: 1, key: "The operand of an increment or decrement operator must be a variable, property or indexer." }, + The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: 1, key: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." }, + The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: { code: 2359, category: 1, key: "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type." }, + The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: { code: 2360, category: 1, key: "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'." }, + The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2361, category: 1, key: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter" }, + The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2362, category: 1, key: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." }, + The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2363, category: 1, key: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." }, + Invalid_left_hand_side_of_assignment_expression: { code: 2364, category: 1, key: "Invalid left-hand side of assignment expression." }, + Operator_0_cannot_be_applied_to_types_1_and_2: { code: 2365, category: 1, key: "Operator '{0}' cannot be applied to types '{1}' and '{2}'." }, + Type_parameter_name_cannot_be_0: { code: 2368, category: 1, key: "Type parameter name cannot be '{0}'" }, + A_parameter_property_is_only_allowed_in_a_constructor_implementation: { code: 2369, category: 1, key: "A parameter property is only allowed in a constructor implementation." }, + A_rest_parameter_must_be_of_an_array_type: { code: 2370, category: 1, key: "A rest parameter must be of an array type." }, + A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: { code: 2371, category: 1, key: "A parameter initializer is only allowed in a function or constructor implementation." }, + Parameter_0_cannot_be_referenced_in_its_initializer: { code: 2372, category: 1, key: "Parameter '{0}' cannot be referenced in its initializer." }, + Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: { code: 2373, category: 1, key: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it." }, + Duplicate_string_index_signature: { code: 2374, category: 1, key: "Duplicate string index signature." }, + Duplicate_number_index_signature: { code: 2375, category: 1, key: "Duplicate number index signature." }, + A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: 1, key: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." }, + Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: 1, key: "Constructors for derived classes must contain a 'super' call." }, + A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: 1, key: "A 'get' accessor must return a value or consist of a single 'throw' statement." }, + Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: 1, key: "Getter and setter accessors do not agree in visibility." }, + get_and_set_accessor_must_have_the_same_type: { code: 2380, category: 1, key: "'get' and 'set' accessor must have the same type." }, + A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: 1, key: "A signature with an implementation cannot use a string literal type." }, + Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: { code: 2382, category: 1, key: "Specialized overload signature is not assignable to any non-specialized signature." }, + Overload_signatures_must_all_be_exported_or_not_exported: { code: 2383, category: 1, key: "Overload signatures must all be exported or not exported." }, + Overload_signatures_must_all_be_ambient_or_non_ambient: { code: 2384, category: 1, key: "Overload signatures must all be ambient or non-ambient." }, + Overload_signatures_must_all_be_public_private_or_protected: { code: 2385, category: 1, key: "Overload signatures must all be public, private or protected." }, + Overload_signatures_must_all_be_optional_or_required: { code: 2386, category: 1, key: "Overload signatures must all be optional or required." }, + Function_overload_must_be_static: { code: 2387, category: 1, key: "Function overload must be static." }, + Function_overload_must_not_be_static: { code: 2388, category: 1, key: "Function overload must not be static." }, + Function_implementation_name_must_be_0: { code: 2389, category: 1, key: "Function implementation name must be '{0}'." }, + Constructor_implementation_is_missing: { code: 2390, category: 1, key: "Constructor implementation is missing." }, + Function_implementation_is_missing_or_not_immediately_following_the_declaration: { code: 2391, category: 1, key: "Function implementation is missing or not immediately following the declaration." }, + Multiple_constructor_implementations_are_not_allowed: { code: 2392, category: 1, key: "Multiple constructor implementations are not allowed." }, + Duplicate_function_implementation: { code: 2393, category: 1, key: "Duplicate function implementation." }, + Overload_signature_is_not_compatible_with_function_implementation: { code: 2394, category: 1, key: "Overload signature is not compatible with function implementation." }, + Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: { code: 2395, category: 1, key: "Individual declarations in merged declaration {0} must be all exported or all local." }, + Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: { code: 2396, category: 1, key: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters." }, + Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: { code: 2399, category: 1, key: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference." }, + Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: { code: 2400, category: 1, key: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference." }, + Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: { code: 2401, category: 1, key: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference." }, + Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: { code: 2402, category: 1, key: "Expression resolves to '_super' that compiler uses to capture base class reference." }, + Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: { code: 2403, category: 1, key: "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'." }, + The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: { code: 2404, category: 1, key: "The left-hand side of a 'for...in' statement cannot use a type annotation." }, + The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: { code: 2405, category: 1, key: "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'." }, + Invalid_left_hand_side_in_for_in_statement: { code: 2406, category: 1, key: "Invalid left-hand side in 'for...in' statement." }, + The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2407, category: 1, key: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter." }, + Setters_cannot_return_a_value: { code: 2408, category: 1, key: "Setters cannot return a value." }, + Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: { code: 2409, category: 1, key: "Return type of constructor signature must be assignable to the instance type of the class" }, + All_symbols_within_a_with_block_will_be_resolved_to_any: { code: 2410, category: 1, key: "All symbols within a 'with' block will be resolved to 'any'." }, + Property_0_of_type_1_is_not_assignable_to_string_index_type_2: { code: 2411, category: 1, key: "Property '{0}' of type '{1}' is not assignable to string index type '{2}'." }, + Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: { code: 2412, category: 1, key: "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'." }, + Numeric_index_type_0_is_not_assignable_to_string_index_type_1: { code: 2413, category: 1, key: "Numeric index type '{0}' is not assignable to string index type '{1}'." }, + Class_name_cannot_be_0: { code: 2414, category: 1, key: "Class name cannot be '{0}'" }, + Class_0_incorrectly_extends_base_class_1: { code: 2415, category: 1, key: "Class '{0}' incorrectly extends base class '{1}'." }, + Class_static_side_0_incorrectly_extends_base_class_static_side_1: { code: 2417, category: 1, key: "Class static side '{0}' incorrectly extends base class static side '{1}'." }, + Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0: { code: 2419, category: 1, key: "Type name '{0}' in extends clause does not reference constructor function for '{0}'." }, + Class_0_incorrectly_implements_interface_1: { code: 2420, category: 1, key: "Class '{0}' incorrectly implements interface '{1}'." }, + A_class_may_only_implement_another_class_or_interface: { code: 2422, category: 1, key: "A class may only implement another class or interface." }, + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: { code: 2423, category: 1, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor." }, + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: { code: 2424, category: 1, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property." }, + Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2425, category: 1, key: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function." }, + Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2426, category: 1, key: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function." }, + Interface_name_cannot_be_0: { code: 2427, category: 1, key: "Interface name cannot be '{0}'" }, + All_declarations_of_an_interface_must_have_identical_type_parameters: { code: 2428, category: 1, key: "All declarations of an interface must have identical type parameters." }, + Interface_0_incorrectly_extends_interface_1: { code: 2430, category: 1, key: "Interface '{0}' incorrectly extends interface '{1}'." }, + Enum_name_cannot_be_0: { code: 2431, category: 1, key: "Enum name cannot be '{0}'" }, + In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: { code: 2432, category: 1, key: "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element." }, + A_module_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: { code: 2433, category: 1, key: "A module declaration cannot be in a different file from a class or function with which it is merged" }, + A_module_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: { code: 2434, category: 1, key: "A module declaration cannot be located prior to a class or function with which it is merged" }, + Ambient_external_modules_cannot_be_nested_in_other_modules: { code: 2435, category: 1, key: "Ambient external modules cannot be nested in other modules." }, + Ambient_external_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: 1, key: "Ambient external module declaration cannot specify relative module name." }, + Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: 1, key: "Module '{0}' is hidden by a local declaration with the same name" }, + Import_name_cannot_be_0: { code: 2438, category: 1, key: "Import name cannot be '{0}'" }, + Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import or export declaration in an ambient external module declaration cannot reference external module through relative external module name." }, + Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: 1, key: "Import declaration conflicts with local declaration of '{0}'" }, + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: { code: 2441, category: 1, key: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module." }, + Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: 1, key: "Types have separate declarations of a private property '{0}'." }, + Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: { code: 2443, category: 1, key: "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'." }, + Property_0_is_protected_in_type_1_but_public_in_type_2: { code: 2444, category: 1, key: "Property '{0}' is protected in type '{1}' but public in type '{2}'." }, + Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: { code: 2445, category: 1, key: "Property '{0}' is protected and only accessible within class '{1}' and its subclasses." }, + Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: { code: 2446, category: 1, key: "Property '{0}' is protected and only accessible through an instance of class '{1}'." }, + The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: { code: 2447, category: 1, key: "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead." }, + Block_scoped_variable_0_used_before_its_declaration: { code: 2448, category: 1, key: "Block-scoped variable '{0}' used before its declaration." }, + The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant: { code: 2449, category: 1, key: "The operand of an increment or decrement operator cannot be a constant." }, + Left_hand_side_of_assignment_expression_cannot_be_a_constant: { code: 2450, category: 1, key: "Left-hand side of assignment expression cannot be a constant." }, + Cannot_redeclare_block_scoped_variable_0: { code: 2451, category: 1, key: "Cannot redeclare block-scoped variable '{0}'." }, + An_enum_member_cannot_have_a_numeric_name: { code: 2452, category: 1, key: "An enum member cannot have a numeric name." }, + The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: { code: 2453, category: 1, key: "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly." }, + Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: { code: 2455, category: 1, key: "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'." }, + Type_alias_0_circularly_references_itself: { code: 2456, category: 1, key: "Type alias '{0}' circularly references itself." }, + Type_alias_name_cannot_be_0: { code: 2457, category: 1, key: "Type alias name cannot be '{0}'" }, + An_AMD_module_cannot_have_multiple_name_assignments: { code: 2458, category: 1, key: "An AMD module cannot have multiple name assignments." }, + Type_0_has_no_property_1_and_no_string_index_signature: { code: 2459, category: 1, key: "Type '{0}' has no property '{1}' and no string index signature." }, + Type_0_has_no_property_1: { code: 2460, category: 1, key: "Type '{0}' has no property '{1}'." }, + Type_0_is_not_an_array_type: { code: 2461, category: 1, key: "Type '{0}' is not an array type." }, + A_rest_element_must_be_last_in_an_array_destructuring_pattern: { code: 2462, category: 1, key: "A rest element must be last in an array destructuring pattern" }, + A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: { code: 2463, category: 1, key: "A binding pattern parameter cannot be optional in an implementation signature." }, + A_computed_property_name_must_be_of_type_string_number_symbol_or_any: { code: 2464, category: 1, key: "A computed property name must be of type 'string', 'number', 'symbol', or 'any'." }, + this_cannot_be_referenced_in_a_computed_property_name: { code: 2465, category: 1, key: "'this' cannot be referenced in a computed property name." }, + super_cannot_be_referenced_in_a_computed_property_name: { code: 2466, category: 1, key: "'super' cannot be referenced in a computed property name." }, + A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: { code: 2467, category: 1, key: "A computed property name cannot reference a type parameter from its containing type." }, + Cannot_find_global_value_0: { code: 2468, category: 1, key: "Cannot find global value '{0}'." }, + The_0_operator_cannot_be_applied_to_type_symbol: { code: 2469, category: 1, key: "The '{0}' operator cannot be applied to type 'symbol'." }, + Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: { code: 2470, category: 1, key: "'Symbol' reference does not refer to the global Symbol constructor object." }, + A_computed_property_name_of_the_form_0_must_be_of_type_symbol: { code: 2471, category: 1, key: "A computed property name of the form '{0}' must be of type 'symbol'." }, + Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_6_and_higher: { code: 2472, category: 1, key: "Spread operator in 'new' expressions is only available when targeting ECMAScript 6 and higher." }, + Enum_declarations_must_all_be_const_or_non_const: { code: 2473, category: 1, key: "Enum declarations must all be const or non-const." }, + In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 2474, category: 1, key: "In 'const' enum declarations member initializer must be constant expression." }, + const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment: { code: 2475, category: 1, key: "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment." }, + A_const_enum_member_can_only_be_accessed_using_a_string_literal: { code: 2476, category: 1, key: "A const enum member can only be accessed using a string literal." }, + const_enum_member_initializer_was_evaluated_to_a_non_finite_value: { code: 2477, category: 1, key: "'const' enum member initializer was evaluated to a non-finite value." }, + const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: { code: 2478, category: 1, key: "'const' enum member initializer was evaluated to disallowed value 'NaN'." }, + Property_0_does_not_exist_on_const_enum_1: { code: 2479, category: 1, key: "Property '{0}' does not exist on 'const' enum '{1}'." }, + let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: { code: 2480, category: 1, key: "'let' is not allowed to be used as a name in 'let' or 'const' declarations." }, + Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: 1, key: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." }, + for_of_statements_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 2482, category: 1, key: "'for...of' statements are only available when targeting ECMAScript 6 or higher." }, + The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: 1, key: "The left-hand side of a 'for...of' statement cannot use a type annotation." }, + Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: 1, key: "Export declaration conflicts with exported declaration of '{0}'" }, + Import_declaration_0_is_using_private_name_1: { code: 4000, category: 1, 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: 1, 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: 1, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, + Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4006, category: 1, key: "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." }, + Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4008, category: 1, key: "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'." }, + Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4010, category: 1, key: "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'." }, + Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4012, category: 1, key: "Type parameter '{0}' of public method from exported class has or is using private name '{1}'." }, + Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4014, category: 1, key: "Type parameter '{0}' of method from exported interface has or is using private name '{1}'." }, + Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4016, category: 1, key: "Type parameter '{0}' of exported function has or is using private name '{1}'." }, + Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4019, category: 1, key: "Implements clause of exported class '{0}' has or is using private name '{1}'." }, + Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4020, category: 1, key: "Extends clause of exported class '{0}' has or is using private name '{1}'." }, + Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: { code: 4022, category: 1, key: "Extends clause of exported interface '{0}' has or is using private name '{1}'." }, + Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4023, category: 1, key: "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named." }, + Exported_variable_0_has_or_is_using_name_1_from_private_module_2: { code: 4024, category: 1, key: "Exported variable '{0}' has or is using name '{1}' from private module '{2}'." }, + Exported_variable_0_has_or_is_using_private_name_1: { code: 4025, category: 1, key: "Exported variable '{0}' has or is using private name '{1}'." }, + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4026, category: 1, key: "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." }, + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4027, category: 1, key: "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'." }, + Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4028, category: 1, key: "Public static property '{0}' of exported class has or is using private name '{1}'." }, + Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4029, category: 1, key: "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." }, + Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4030, category: 1, key: "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'." }, + Public_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4031, category: 1, key: "Public property '{0}' of exported class has or is using private name '{1}'." }, + Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4032, category: 1, key: "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'." }, + Property_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4033, category: 1, key: "Property '{0}' of exported interface has or is using private name '{1}'." }, + Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4034, category: 1, key: "Parameter '{0}' of public static property setter from exported class has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4035, category: 1, key: "Parameter '{0}' of public static property setter from exported class has or is using private name '{1}'." }, + Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4036, category: 1, key: "Parameter '{0}' of public property setter from exported class has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4037, category: 1, key: "Parameter '{0}' of public property setter from exported class has or is using private name '{1}'." }, + Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4038, category: 1, key: "Return type of public static property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." }, + Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4039, category: 1, key: "Return type of public static property getter from exported class has or is using name '{0}' from private module '{1}'." }, + Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4040, category: 1, key: "Return type of public static property getter from exported class has or is using private name '{0}'." }, + Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4041, category: 1, key: "Return type of public property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." }, + Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4042, category: 1, key: "Return type of public property getter from exported class has or is using name '{0}' from private module '{1}'." }, + Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4043, category: 1, key: "Return type of public property getter from exported class has or is using private name '{0}'." }, + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4044, category: 1, key: "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'." }, + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4045, category: 1, key: "Return type of constructor signature from exported interface has or is using private name '{0}'." }, + Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4046, category: 1, key: "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'." }, + Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4047, category: 1, key: "Return type of call signature from exported interface has or is using private name '{0}'." }, + Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4048, category: 1, key: "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'." }, + Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4049, category: 1, key: "Return type of index signature from exported interface has or is using private name '{0}'." }, + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4050, category: 1, key: "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named." }, + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4051, category: 1, key: "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'." }, + Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: { code: 4052, category: 1, key: "Return type of public static method from exported class has or is using private name '{0}'." }, + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4053, category: 1, key: "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named." }, + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4054, category: 1, key: "Return type of public method from exported class has or is using name '{0}' from private module '{1}'." }, + Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: { code: 4055, category: 1, key: "Return type of public method from exported class has or is using private name '{0}'." }, + Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4056, category: 1, key: "Return type of method from exported interface has or is using name '{0}' from private module '{1}'." }, + Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: { code: 4057, category: 1, key: "Return type of method from exported interface has or is using private name '{0}'." }, + Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4058, category: 1, key: "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named." }, + Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: { code: 4059, category: 1, key: "Return type of exported function has or is using name '{0}' from private module '{1}'." }, + Return_type_of_exported_function_has_or_is_using_private_name_0: { code: 4060, category: 1, key: "Return type of exported function has or is using private name '{0}'." }, + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4061, category: 1, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named." }, + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4062, category: 1, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: { code: 4063, category: 1, key: "Parameter '{0}' of constructor from exported class has or is using private name '{1}'." }, + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4064, category: 1, key: "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4065, category: 1, key: "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." }, + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4066, category: 1, key: "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4067, category: 1, key: "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'." }, + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4068, category: 1, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named." }, + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4069, category: 1, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4070, category: 1, key: "Parameter '{0}' of public static method from exported class has or is using private name '{1}'." }, + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4071, category: 1, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named." }, + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4072, category: 1, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4073, category: 1, key: "Parameter '{0}' of public method from exported class has or is using private name '{1}'." }, + Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4074, category: 1, key: "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4075, category: 1, key: "Parameter '{0}' of method from exported interface has or is using private name '{1}'." }, + Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4076, category: 1, key: "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named." }, + Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: 1, key: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." }, + Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: 1, key: "Parameter '{0}' of exported function has or is using private name '{1}'." }, + Exported_type_alias_0_has_or_is_using_private_name_1: { code: 4081, category: 1, key: "Exported type alias '{0}' has or is using private name '{1}'." }, + The_current_host_does_not_support_the_0_option: { code: 5001, category: 1, key: "The current host does not support the '{0}' option." }, + Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: 1, key: "Cannot find the common subdirectory path for the input files." }, + Cannot_read_file_0_Colon_1: { code: 5012, category: 1, key: "Cannot read file '{0}': {1}" }, + Unsupported_file_encoding: { code: 5013, category: 1, key: "Unsupported file encoding." }, + Unknown_compiler_option_0: { code: 5023, category: 1, key: "Unknown compiler option '{0}'." }, + Compiler_option_0_requires_a_value_of_type_1: { code: 5024, category: 1, key: "Compiler option '{0}' requires a value of type {1}." }, + Could_not_write_file_0_Colon_1: { code: 5033, category: 1, key: "Could not write file '{0}': {1}" }, + Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option: { code: 5038, category: 1, key: "Option 'mapRoot' cannot be specified without specifying 'sourcemap' option." }, + Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: { code: 5039, category: 1, key: "Option 'sourceRoot' cannot be specified without specifying 'sourcemap' option." }, + Option_noEmit_cannot_be_specified_with_option_out_or_outDir: { code: 5040, category: 1, key: "Option 'noEmit' cannot be specified with option 'out' or 'outDir'." }, + Option_noEmit_cannot_be_specified_with_option_declaration: { code: 5041, category: 1, key: "Option 'noEmit' cannot be specified with option 'declaration'." }, + Option_project_cannot_be_mixed_with_source_files_on_a_command_line: { code: 5042, category: 1, key: "Option 'project' cannot be mixed with source files on a command line." }, + Concatenate_and_emit_output_to_single_file: { code: 6001, category: 2, key: "Concatenate and emit output to single file." }, + Generates_corresponding_d_ts_file: { code: 6002, category: 2, key: "Generates corresponding '.d.ts' file." }, + Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: { code: 6003, category: 2, key: "Specifies the location where debugger should locate map files instead of generated locations." }, + Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: { code: 6004, category: 2, key: "Specifies the location where debugger should locate TypeScript files instead of source locations." }, + Watch_input_files: { code: 6005, category: 2, key: "Watch input files." }, + Redirect_output_structure_to_the_directory: { code: 6006, category: 2, key: "Redirect output structure to the directory." }, + Do_not_erase_const_enum_declarations_in_generated_code: { code: 6007, category: 2, key: "Do not erase const enum declarations in generated code." }, + Do_not_emit_outputs_if_any_type_checking_errors_were_reported: { code: 6008, category: 2, key: "Do not emit outputs if any type checking errors were reported." }, + Do_not_emit_comments_to_output: { code: 6009, category: 2, key: "Do not emit comments to output." }, + Do_not_emit_outputs: { code: 6010, category: 2, key: "Do not emit outputs." }, + Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental: { code: 6015, category: 2, key: "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES6' (experimental)" }, + Specify_module_code_generation_Colon_commonjs_or_amd: { code: 6016, category: 2, key: "Specify module code generation: 'commonjs' or 'amd'" }, + Print_this_message: { code: 6017, category: 2, key: "Print this message." }, + Print_the_compiler_s_version: { code: 6019, category: 2, key: "Print the compiler's version." }, + Compile_the_project_in_the_given_directory: { code: 6020, category: 2, key: "Compile the project in the given directory." }, + Syntax_Colon_0: { code: 6023, category: 2, key: "Syntax: {0}" }, + options: { code: 6024, category: 2, key: "options" }, + file: { code: 6025, category: 2, key: "file" }, + Examples_Colon_0: { code: 6026, category: 2, key: "Examples: {0}" }, + Options_Colon: { code: 6027, category: 2, key: "Options:" }, + Version_0: { code: 6029, category: 2, key: "Version {0}" }, + Insert_command_line_options_and_files_from_a_file: { code: 6030, category: 2, key: "Insert command line options and files from a file." }, + File_change_detected_Starting_incremental_compilation: { code: 6032, category: 2, key: "File change detected. Starting incremental compilation..." }, + KIND: { code: 6034, category: 2, key: "KIND" }, + FILE: { code: 6035, category: 2, key: "FILE" }, + VERSION: { code: 6036, category: 2, key: "VERSION" }, + LOCATION: { code: 6037, category: 2, key: "LOCATION" }, + DIRECTORY: { code: 6038, category: 2, key: "DIRECTORY" }, + Compilation_complete_Watching_for_file_changes: { code: 6042, category: 2, key: "Compilation complete. Watching for file changes." }, + Generates_corresponding_map_file: { code: 6043, category: 2, key: "Generates corresponding '.map' file." }, + Compiler_option_0_expects_an_argument: { code: 6044, category: 1, key: "Compiler option '{0}' expects an argument." }, + Unterminated_quoted_string_in_response_file_0: { code: 6045, category: 1, key: "Unterminated quoted string in response file '{0}'." }, + Argument_for_module_option_must_be_commonjs_or_amd: { code: 6046, category: 1, key: "Argument for '--module' option must be 'commonjs' or 'amd'." }, + Argument_for_target_option_must_be_es3_es5_or_es6: { code: 6047, category: 1, key: "Argument for '--target' option must be 'es3', 'es5', or 'es6'." }, + Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: { code: 6048, category: 1, key: "Locale must be of the form or -. For example '{0}' or '{1}'." }, + Unsupported_locale_0: { code: 6049, category: 1, key: "Unsupported locale '{0}'." }, + Unable_to_open_file_0: { code: 6050, category: 1, key: "Unable to open file '{0}'." }, + Corrupted_locale_file_0: { code: 6051, category: 1, key: "Corrupted locale file {0}." }, + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: 2, key: "Raise error on expressions and declarations with an implied 'any' type." }, + File_0_not_found: { code: 6053, category: 1, key: "File '{0}' not found." }, + File_0_must_have_extension_ts_or_d_ts: { code: 6054, category: 1, key: "File '{0}' must have extension '.ts' or '.d.ts'." }, + Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: 2, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." }, + Do_not_emit_declarations_for_code_that_has_an_internal_annotation: { code: 6056, category: 2, key: "Do not emit declarations for code that has an '@internal' annotation." }, + Variable_0_implicitly_has_an_1_type: { code: 7005, category: 1, key: "Variable '{0}' implicitly has an '{1}' type." }, + Parameter_0_implicitly_has_an_1_type: { code: 7006, category: 1, key: "Parameter '{0}' implicitly has an '{1}' type." }, + Member_0_implicitly_has_an_1_type: { code: 7008, category: 1, key: "Member '{0}' implicitly has an '{1}' type." }, + new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: { code: 7009, category: 1, key: "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type." }, + _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: { code: 7010, category: 1, key: "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type." }, + Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: { code: 7011, category: 1, key: "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type." }, + Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7013, category: 1, key: "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type." }, + Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation: { code: 7016, category: 1, key: "Property '{0}' implicitly has type 'any', because its 'set' accessor lacks a type annotation." }, + Index_signature_of_object_type_implicitly_has_an_any_type: { code: 7017, category: 1, key: "Index signature of object type implicitly has an 'any' type." }, + Object_literal_s_property_0_implicitly_has_an_1_type: { code: 7018, category: 1, key: "Object literal's property '{0}' implicitly has an '{1}' type." }, + Rest_parameter_0_implicitly_has_an_any_type: { code: 7019, category: 1, key: "Rest parameter '{0}' implicitly has an 'any[]' type." }, + Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7020, category: 1, key: "Call signature, which lacks return-type annotation, implicitly has an 'any' return type." }, + _0_implicitly_has_type_any_because_it_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 7021, category: 1, key: "'{0}' implicitly has type 'any' because it is referenced directly or indirectly in its own type annotation." }, + _0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: 1, key: "'{0}' implicitly has type 'any' because it is does not have a type annotation and is referenced directly or indirectly in its own initializer." }, + _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: 1, 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: 1, 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." }, + You_cannot_rename_this_element: { code: 8000, category: 1, key: "You cannot rename this element." }, + You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: 1, key: "You cannot rename elements that are defined in the standard TypeScript library." }, + yield_expressions_are_not_currently_supported: { code: 9000, category: 1, key: "'yield' expressions are not currently supported." }, + Generators_are_not_currently_supported: { code: 9001, category: 1, key: "Generators are not currently supported." }, + The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression: { code: 9002, category: 1, key: "The 'arguments' object cannot be referenced in an arrow function. Consider using a standard function expression." }, + for_of_statements_are_not_currently_supported: { code: 9003, category: 1, key: "'for...of' statements are not currently supported." } + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + var textToToken = { + "any": 112, + "as": 101, + "boolean": 113, + "break": 65, + "case": 66, + "catch": 67, + "class": 68, + "continue": 70, + "const": 69, + "constructor": 114, + "debugger": 71, + "declare": 115, + "default": 72, + "delete": 73, + "do": 74, + "else": 75, + "enum": 76, + "export": 77, + "extends": 78, + "false": 79, + "finally": 80, + "for": 81, + "from": 102, + "function": 82, + "get": 116, + "if": 83, + "implements": 103, + "import": 84, + "in": 85, + "instanceof": 86, + "interface": 104, + "let": 105, + "module": 117, + "new": 87, + "null": 88, + "number": 119, + "package": 106, + "private": 107, + "protected": 108, + "public": 109, + "require": 118, + "return": 89, + "set": 120, + "static": 110, + "string": 121, + "super": 90, + "switch": 91, + "symbol": 122, + "this": 92, + "throw": 93, + "true": 94, + "try": 95, + "type": 123, + "typeof": 96, + "var": 97, + "void": 98, + "while": 99, + "with": 100, + "yield": 111, + "of": 124, + "{": 14, + "}": 15, + "(": 16, + ")": 17, + "[": 18, + "]": 19, + ".": 20, + "...": 21, + ";": 22, + ",": 23, + "<": 24, + ">": 25, + "<=": 26, + ">=": 27, + "==": 28, + "!=": 29, + "===": 30, + "!==": 31, + "=>": 32, + "+": 33, + "-": 34, + "*": 35, + "/": 36, + "%": 37, + "++": 38, + "--": 39, + "<<": 40, + ">>": 41, + ">>>": 42, + "&": 43, + "|": 44, + "^": 45, + "!": 46, + "~": 47, + "&&": 48, + "||": 49, + "?": 50, + ":": 51, + "=": 52, + "+=": 53, + "-=": 54, + "*=": 55, + "/=": 56, + "%=": 57, + "<<=": 58, + ">>=": 59, + ">>>=": 60, + "&=": 61, + "|=": 62, + "^=": 63 + }; + var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + function lookupInUnicodeMap(code, map) { + if (code < map[0]) { + return false; + } + var lo = 0; + var hi = map.length; + var mid; + while (lo + 1 < hi) { + mid = lo + (hi - lo) / 2; + mid -= mid % 2; + if (map[mid] <= code && code <= map[mid + 1]) { + return true; + } + if (code < map[mid]) { + hi = mid; + } + else { + lo = mid + 2; + } + } + return false; + } + function isUnicodeIdentifierStart(code, languageVersion) { + return languageVersion >= 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : lookupInUnicodeMap(code, unicodeES3IdentifierStart); + } + ts.isUnicodeIdentifierStart = isUnicodeIdentifierStart; + function isUnicodeIdentifierPart(code, languageVersion) { + return languageVersion >= 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : lookupInUnicodeMap(code, unicodeES3IdentifierPart); + } + function makeReverseMap(source) { + var result = []; + for (var name in source) { + if (source.hasOwnProperty(name)) { + result[source[name]] = name; + } + } + return result; + } + var tokenStrings = makeReverseMap(textToToken); + function tokenToString(t) { + return tokenStrings[t]; + } + ts.tokenToString = tokenToString; + function computeLineStarts(text) { + var result = new Array(); + var pos = 0; + var lineStart = 0; + while (pos < text.length) { + var ch = text.charCodeAt(pos++); + switch (ch) { + case 13: + if (text.charCodeAt(pos) === 10) { + pos++; + } + case 10: + result.push(lineStart); + lineStart = pos; + break; + default: + if (ch > 127 && isLineBreak(ch)) { + result.push(lineStart); + lineStart = pos; + } + break; + } + } + result.push(lineStart); + return result; + } + ts.computeLineStarts = computeLineStarts; + function getPositionOfLineAndCharacter(sourceFile, line, character) { + return computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character); + } + ts.getPositionOfLineAndCharacter = getPositionOfLineAndCharacter; + function computePositionOfLineAndCharacter(lineStarts, line, character) { + ts.Debug.assert(line >= 0 && line < lineStarts.length); + return lineStarts[line] + character; + } + ts.computePositionOfLineAndCharacter = computePositionOfLineAndCharacter; + function getLineStarts(sourceFile) { + return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text)); + } + ts.getLineStarts = getLineStarts; + function computeLineAndCharacterOfPosition(lineStarts, position) { + var lineNumber = ts.binarySearch(lineStarts, position); + if (lineNumber < 0) { + lineNumber = ~lineNumber - 1; + } + return { + line: lineNumber, + character: position - lineStarts[lineNumber] + }; + } + ts.computeLineAndCharacterOfPosition = computeLineAndCharacterOfPosition; + function getLineAndCharacterOfPosition(sourceFile, position) { + return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position); + } + ts.getLineAndCharacterOfPosition = getLineAndCharacterOfPosition; + var hasOwnProperty = Object.prototype.hasOwnProperty; + function isWhiteSpace(ch) { + return ch === 32 || ch === 9 || ch === 11 || ch === 12 || + ch === 160 || ch === 5760 || ch >= 8192 && ch <= 8203 || + ch === 8239 || ch === 8287 || ch === 12288 || ch === 65279; + } + ts.isWhiteSpace = isWhiteSpace; + function isLineBreak(ch) { + return ch === 10 || ch === 13 || ch === 8232 || ch === 8233 || ch === 133; + } + ts.isLineBreak = isLineBreak; + function isDigit(ch) { + return ch >= 48 && ch <= 57; + } + function isOctalDigit(ch) { + return ch >= 48 && ch <= 55; + } + ts.isOctalDigit = isOctalDigit; + function skipTrivia(text, pos, stopAfterLineBreak) { + while (true) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + if (text.charCodeAt(pos + 1) === 10) { + pos++; + } + case 10: + pos++; + if (stopAfterLineBreak) { + return pos; + } + continue; + case 9: + case 11: + case 12: + case 32: + pos++; + continue; + case 47: + if (text.charCodeAt(pos + 1) === 47) { + pos += 2; + while (pos < text.length) { + if (isLineBreak(text.charCodeAt(pos))) { + break; + } + pos++; + } + continue; + } + if (text.charCodeAt(pos + 1) === 42) { + pos += 2; + while (pos < text.length) { + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { + pos += 2; + break; + } + pos++; + } + continue; + } + break; + case 60: + case 61: + case 62: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos); + continue; + } + break; + default: + if (ch > 127 && (isWhiteSpace(ch) || isLineBreak(ch))) { + pos++; + continue; + } + break; + } + return pos; + } + } + ts.skipTrivia = skipTrivia; + var mergeConflictMarkerLength = "<<<<<<<".length; + function isConflictMarkerTrivia(text, pos) { + ts.Debug.assert(pos >= 0); + if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) { + var ch = text.charCodeAt(pos); + if ((pos + mergeConflictMarkerLength) < text.length) { + for (var i = 0, n = mergeConflictMarkerLength; i < n; i++) { + if (text.charCodeAt(pos + i) !== ch) { + return false; + } + } + return ch === 61 || + text.charCodeAt(pos + mergeConflictMarkerLength) === 32; + } + } + return false; + } + function scanConflictMarkerTrivia(text, pos, error) { + if (error) { + error(ts.Diagnostics.Merge_conflict_marker_encountered, mergeConflictMarkerLength); + } + var ch = text.charCodeAt(pos); + var len = text.length; + if (ch === 60 || ch === 62) { + while (pos < len && !isLineBreak(text.charCodeAt(pos))) { + pos++; + } + } + else { + ts.Debug.assert(ch === 61); + while (pos < len) { + var ch = text.charCodeAt(pos); + if (ch === 62 && isConflictMarkerTrivia(text, pos)) { + break; + } + pos++; + } + } + return pos; + } + function getCommentRanges(text, pos, trailing) { + var result; + var collecting = trailing || pos === 0; + while (true) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13: + if (text.charCodeAt(pos + 1) === 10) + pos++; + case 10: + pos++; + if (trailing) { + return result; + } + collecting = true; + if (result && result.length) { + result[result.length - 1].hasTrailingNewLine = true; + } + continue; + case 9: + case 11: + case 12: + case 32: + pos++; + continue; + case 47: + var nextChar = text.charCodeAt(pos + 1); + var hasTrailingNewLine = false; + if (nextChar === 47 || nextChar === 42) { + var startPos = pos; + pos += 2; + if (nextChar === 47) { + while (pos < text.length) { + if (isLineBreak(text.charCodeAt(pos))) { + hasTrailingNewLine = true; + break; + } + pos++; + } + } + else { + while (pos < text.length) { + if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { + pos += 2; + break; + } + pos++; + } + } + if (collecting) { + if (!result) + result = []; + result.push({ pos: startPos, end: pos, hasTrailingNewLine: hasTrailingNewLine }); + } + continue; + } + break; + default: + if (ch > 127 && (isWhiteSpace(ch) || isLineBreak(ch))) { + if (result && result.length && isLineBreak(ch)) { + result[result.length - 1].hasTrailingNewLine = true; + } + pos++; + continue; + } + break; + } + return result; + } + } + function getLeadingCommentRanges(text, pos) { + return getCommentRanges(text, pos, false); + } + ts.getLeadingCommentRanges = getLeadingCommentRanges; + function getTrailingCommentRanges(text, pos) { + return getCommentRanges(text, pos, true); + } + ts.getTrailingCommentRanges = getTrailingCommentRanges; + function isIdentifierStart(ch, languageVersion) { + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierStart(ch, languageVersion); + } + ts.isIdentifierStart = isIdentifierStart; + function isIdentifierPart(ch, languageVersion) { + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch >= 48 && ch <= 57 || ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierPart(ch, languageVersion); + } + ts.isIdentifierPart = isIdentifierPart; + function createScanner(languageVersion, skipTrivia, text, onError) { + var pos; + var len; + var startPos; + var tokenPos; + var token; + var tokenValue; + var precedingLineBreak; + var tokenIsUnterminated; + function error(message, length) { + if (onError) { + onError(message, length || 0); + } + } + function isIdentifierStart(ch) { + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierStart(ch, languageVersion); + } + function isIdentifierPart(ch) { + return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || + ch >= 48 && ch <= 57 || ch === 36 || ch === 95 || + ch > 127 && isUnicodeIdentifierPart(ch, languageVersion); + } + function scanNumber() { + var start = pos; + while (isDigit(text.charCodeAt(pos))) + pos++; + if (text.charCodeAt(pos) === 46) { + pos++; + while (isDigit(text.charCodeAt(pos))) + pos++; + } + var end = pos; + if (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101) { + pos++; + if (text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) + pos++; + if (isDigit(text.charCodeAt(pos))) { + pos++; + while (isDigit(text.charCodeAt(pos))) + pos++; + end = pos; + } + else { + error(ts.Diagnostics.Digit_expected); + } + } + return +(text.substring(start, end)); + } + function scanOctalDigits() { + var start = pos; + while (isOctalDigit(text.charCodeAt(pos))) { + pos++; + } + return +(text.substring(start, pos)); + } + function scanHexDigits(count, mustMatchCount) { + var digits = 0; + var value = 0; + while (digits < count || !mustMatchCount) { + var ch = text.charCodeAt(pos); + if (ch >= 48 && ch <= 57) { + value = value * 16 + ch - 48; + } + else if (ch >= 65 && ch <= 70) { + value = value * 16 + ch - 65 + 10; + } + else if (ch >= 97 && ch <= 102) { + value = value * 16 + ch - 97 + 10; + } + else { + break; + } + pos++; + digits++; + } + if (digits < count) { + value = -1; + } + return value; + } + function scanString() { + var quote = text.charCodeAt(pos++); + var result = ""; + var start = pos; + while (true) { + if (pos >= len) { + result += text.substring(start, pos); + tokenIsUnterminated = true; + error(ts.Diagnostics.Unterminated_string_literal); + break; + } + var ch = text.charCodeAt(pos); + if (ch === quote) { + result += text.substring(start, pos); + pos++; + break; + } + if (ch === 92) { + result += text.substring(start, pos); + result += scanEscapeSequence(); + start = pos; + continue; + } + if (isLineBreak(ch)) { + result += text.substring(start, pos); + tokenIsUnterminated = true; + error(ts.Diagnostics.Unterminated_string_literal); + break; + } + pos++; + } + return result; + } + function scanTemplateAndSetTokenValue() { + var startedWithBacktick = text.charCodeAt(pos) === 96; + pos++; + var start = pos; + var contents = ""; + var resultingToken; + while (true) { + if (pos >= len) { + contents += text.substring(start, pos); + tokenIsUnterminated = true; + error(ts.Diagnostics.Unterminated_template_literal); + resultingToken = startedWithBacktick ? 10 : 13; + break; + } + var currChar = text.charCodeAt(pos); + if (currChar === 96) { + contents += text.substring(start, pos); + pos++; + resultingToken = startedWithBacktick ? 10 : 13; + break; + } + if (currChar === 36 && pos + 1 < len && text.charCodeAt(pos + 1) === 123) { + contents += text.substring(start, pos); + pos += 2; + resultingToken = startedWithBacktick ? 11 : 12; + break; + } + if (currChar === 92) { + contents += text.substring(start, pos); + contents += scanEscapeSequence(); + start = pos; + continue; + } + if (currChar === 13) { + contents += text.substring(start, pos); + pos++; + if (pos < len && text.charCodeAt(pos) === 10) { + pos++; + } + contents += "\n"; + start = pos; + continue; + } + pos++; + } + ts.Debug.assert(resultingToken !== undefined); + tokenValue = contents; + return resultingToken; + } + function scanEscapeSequence() { + pos++; + if (pos >= len) { + error(ts.Diagnostics.Unexpected_end_of_text); + return ""; + } + var ch = text.charCodeAt(pos++); + switch (ch) { + case 48: + return "\0"; + case 98: + return "\b"; + case 116: + return "\t"; + case 110: + return "\n"; + case 118: + return "\v"; + case 102: + return "\f"; + case 114: + return "\r"; + case 39: + return "\'"; + case 34: + return "\""; + case 120: + case 117: + var ch = scanHexDigits(ch === 120 ? 2 : 4, true); + if (ch >= 0) { + return String.fromCharCode(ch); + } + else { + error(ts.Diagnostics.Hexadecimal_digit_expected); + return ""; + } + case 13: + if (pos < len && text.charCodeAt(pos) === 10) { + pos++; + } + case 10: + case 8232: + case 8233: + return ""; + default: + return String.fromCharCode(ch); + } + } + function peekUnicodeEscape() { + if (pos + 5 < len && text.charCodeAt(pos + 1) === 117) { + var start = pos; + pos += 2; + var value = scanHexDigits(4, true); + pos = start; + return value; + } + return -1; + } + function scanIdentifierParts() { + var result = ""; + var start = pos; + while (pos < len) { + var ch = text.charCodeAt(pos); + if (isIdentifierPart(ch)) { + pos++; + } + else if (ch === 92) { + ch = peekUnicodeEscape(); + if (!(ch >= 0 && isIdentifierPart(ch))) { + break; + } + result += text.substring(start, pos); + result += String.fromCharCode(ch); + pos += 6; + start = pos; + } + else { + break; + } + } + result += text.substring(start, pos); + return result; + } + function getIdentifierToken() { + var len = tokenValue.length; + if (len >= 2 && len <= 11) { + var ch = tokenValue.charCodeAt(0); + if (ch >= 97 && ch <= 122 && hasOwnProperty.call(textToToken, tokenValue)) { + return token = textToToken[tokenValue]; + } + } + return token = 64; + } + function scanBinaryOrOctalDigits(base) { + ts.Debug.assert(base !== 2 || base !== 8, "Expected either base 2 or base 8"); + var value = 0; + var numberOfDigits = 0; + while (true) { + var ch = text.charCodeAt(pos); + var valueOfCh = ch - 48; + if (!isDigit(ch) || valueOfCh >= base) { + break; + } + value = value * base + valueOfCh; + pos++; + numberOfDigits++; + } + if (numberOfDigits === 0) { + return -1; + } + return value; + } + function scan() { + startPos = pos; + precedingLineBreak = false; + tokenIsUnterminated = false; + while (true) { + tokenPos = pos; + if (pos >= len) { + return token = 1; + } + var ch = text.charCodeAt(pos); + switch (ch) { + case 10: + case 13: + precedingLineBreak = true; + if (skipTrivia) { + pos++; + continue; + } + else { + if (ch === 13 && pos + 1 < len && text.charCodeAt(pos + 1) === 10) { + pos += 2; + } + else { + pos++; + } + return token = 4; + } + case 9: + case 11: + case 12: + case 32: + if (skipTrivia) { + pos++; + continue; + } + else { + while (pos < len && isWhiteSpace(text.charCodeAt(pos))) { + pos++; + } + return token = 5; + } + case 33: + if (text.charCodeAt(pos + 1) === 61) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 31; + } + return pos += 2, token = 29; + } + return pos++, token = 46; + case 34: + case 39: + tokenValue = scanString(); + return token = 8; + case 96: + return token = scanTemplateAndSetTokenValue(); + case 37: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 57; + } + return pos++, token = 37; + case 38: + if (text.charCodeAt(pos + 1) === 38) { + return pos += 2, token = 48; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 61; + } + return pos++, token = 43; + case 40: + return pos++, token = 16; + case 41: + return pos++, token = 17; + case 42: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 55; + } + return pos++, token = 35; + case 43: + if (text.charCodeAt(pos + 1) === 43) { + return pos += 2, token = 38; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 53; + } + return pos++, token = 33; + case 44: + return pos++, token = 23; + case 45: + if (text.charCodeAt(pos + 1) === 45) { + return pos += 2, token = 39; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 54; + } + return pos++, token = 34; + case 46: + if (isDigit(text.charCodeAt(pos + 1))) { + tokenValue = "" + scanNumber(); + return token = 7; + } + if (text.charCodeAt(pos + 1) === 46 && text.charCodeAt(pos + 2) === 46) { + return pos += 3, token = 21; + } + return pos++, token = 20; + case 47: + if (text.charCodeAt(pos + 1) === 47) { + pos += 2; + while (pos < len) { + if (isLineBreak(text.charCodeAt(pos))) { + break; + } + pos++; + } + if (skipTrivia) { + continue; + } + else { + return token = 2; + } + } + if (text.charCodeAt(pos + 1) === 42) { + pos += 2; + var commentClosed = false; + while (pos < len) { + var ch = text.charCodeAt(pos); + if (ch === 42 && text.charCodeAt(pos + 1) === 47) { + pos += 2; + commentClosed = true; + break; + } + if (isLineBreak(ch)) { + precedingLineBreak = true; + } + pos++; + } + if (!commentClosed) { + error(ts.Diagnostics.Asterisk_Slash_expected); + } + if (skipTrivia) { + continue; + } + else { + tokenIsUnterminated = !commentClosed; + return token = 3; + } + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 56; + } + return pos++, token = 36; + case 48: + if (pos + 2 < len && (text.charCodeAt(pos + 1) === 88 || text.charCodeAt(pos + 1) === 120)) { + pos += 2; + var value = scanHexDigits(1, false); + if (value < 0) { + error(ts.Diagnostics.Hexadecimal_digit_expected); + value = 0; + } + tokenValue = "" + value; + return token = 7; + } + else if (pos + 2 < len && (text.charCodeAt(pos + 1) === 66 || text.charCodeAt(pos + 1) === 98)) { + pos += 2; + var value = scanBinaryOrOctalDigits(2); + if (value < 0) { + error(ts.Diagnostics.Binary_digit_expected); + value = 0; + } + tokenValue = "" + value; + return token = 7; + } + else if (pos + 2 < len && (text.charCodeAt(pos + 1) === 79 || text.charCodeAt(pos + 1) === 111)) { + pos += 2; + var value = scanBinaryOrOctalDigits(8); + if (value < 0) { + error(ts.Diagnostics.Octal_digit_expected); + value = 0; + } + tokenValue = "" + value; + return token = 7; + } + if (pos + 1 < len && isOctalDigit(text.charCodeAt(pos + 1))) { + tokenValue = "" + scanOctalDigits(); + return token = 7; + } + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + tokenValue = "" + scanNumber(); + return token = 7; + case 58: + return pos++, token = 51; + case 59: + return pos++, token = 22; + case 60: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 6; + } + } + if (text.charCodeAt(pos + 1) === 60) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 58; + } + return pos += 2, token = 40; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 26; + } + return pos++, token = 24; + case 61: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 6; + } + } + if (text.charCodeAt(pos + 1) === 61) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 30; + } + return pos += 2, token = 28; + } + if (text.charCodeAt(pos + 1) === 62) { + return pos += 2, token = 32; + } + return pos++, token = 52; + case 62: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 6; + } + } + return pos++, token = 25; + case 63: + return pos++, token = 50; + case 91: + return pos++, token = 18; + case 93: + return pos++, token = 19; + case 94: + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 63; + } + return pos++, token = 45; + case 123: + return pos++, token = 14; + case 124: + if (text.charCodeAt(pos + 1) === 124) { + return pos += 2, token = 49; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 62; + } + return pos++, token = 44; + case 125: + return pos++, token = 15; + case 126: + return pos++, token = 47; + case 92: + var ch = peekUnicodeEscape(); + if (ch >= 0 && isIdentifierStart(ch)) { + pos += 6; + tokenValue = String.fromCharCode(ch) + scanIdentifierParts(); + return token = getIdentifierToken(); + } + error(ts.Diagnostics.Invalid_character); + return pos++, token = 0; + default: + if (isIdentifierStart(ch)) { + pos++; + while (pos < len && isIdentifierPart(ch = text.charCodeAt(pos))) + pos++; + tokenValue = text.substring(tokenPos, pos); + if (ch === 92) { + tokenValue += scanIdentifierParts(); + } + return token = getIdentifierToken(); + } + else if (isWhiteSpace(ch)) { + pos++; + continue; + } + else if (isLineBreak(ch)) { + precedingLineBreak = true; + pos++; + continue; + } + error(ts.Diagnostics.Invalid_character); + return pos++, token = 0; + } + } + } + function reScanGreaterToken() { + if (token === 25) { + if (text.charCodeAt(pos) === 62) { + if (text.charCodeAt(pos + 1) === 62) { + if (text.charCodeAt(pos + 2) === 61) { + return pos += 3, token = 60; + } + return pos += 2, token = 42; + } + if (text.charCodeAt(pos + 1) === 61) { + return pos += 2, token = 59; + } + return pos++, token = 41; + } + if (text.charCodeAt(pos) === 61) { + return pos++, token = 27; + } + } + return token; + } + function reScanSlashToken() { + if (token === 36 || token === 56) { + var p = tokenPos + 1; + var inEscape = false; + var inCharacterClass = false; + while (true) { + if (p >= len) { + tokenIsUnterminated = true; + error(ts.Diagnostics.Unterminated_regular_expression_literal); + break; + } + var ch = text.charCodeAt(p); + if (isLineBreak(ch)) { + tokenIsUnterminated = true; + error(ts.Diagnostics.Unterminated_regular_expression_literal); + break; + } + if (inEscape) { + inEscape = false; + } + else if (ch === 47 && !inCharacterClass) { + p++; + break; + } + else if (ch === 91) { + inCharacterClass = true; + } + else if (ch === 92) { + inEscape = true; + } + else if (ch === 93) { + inCharacterClass = false; + } + p++; + } + while (p < len && isIdentifierPart(text.charCodeAt(p))) { + p++; + } + pos = p; + tokenValue = text.substring(tokenPos, pos); + token = 9; + } + return token; + } + function reScanTemplateToken() { + ts.Debug.assert(token === 15, "'reScanTemplateToken' should only be called on a '}'"); + pos = tokenPos; + return token = scanTemplateAndSetTokenValue(); + } + function speculationHelper(callback, isLookahead) { + var savePos = pos; + var saveStartPos = startPos; + var saveTokenPos = tokenPos; + var saveToken = token; + var saveTokenValue = tokenValue; + var savePrecedingLineBreak = precedingLineBreak; + var result = callback(); + if (!result || isLookahead) { + pos = savePos; + startPos = saveStartPos; + tokenPos = saveTokenPos; + token = saveToken; + tokenValue = saveTokenValue; + precedingLineBreak = savePrecedingLineBreak; + } + return result; + } + function lookAhead(callback) { + return speculationHelper(callback, true); + } + function tryScan(callback) { + return speculationHelper(callback, false); + } + function setText(newText) { + text = newText || ""; + len = text.length; + setTextPos(0); + } + function setTextPos(textPos) { + pos = textPos; + startPos = textPos; + tokenPos = textPos; + token = 0; + precedingLineBreak = false; + } + setText(text); + return { + getStartPos: function () { return startPos; }, + getTextPos: function () { return pos; }, + getToken: function () { return token; }, + getTokenPos: function () { return tokenPos; }, + getTokenText: function () { return text.substring(tokenPos, pos); }, + getTokenValue: function () { return tokenValue; }, + hasPrecedingLineBreak: function () { return precedingLineBreak; }, + isIdentifier: function () { return token === 64 || token > 100; }, + isReservedWord: function () { return token >= 65 && token <= 100; }, + isUnterminated: function () { return tokenIsUnterminated; }, + reScanGreaterToken: reScanGreaterToken, + reScanSlashToken: reScanSlashToken, + reScanTemplateToken: reScanTemplateToken, + scan: scan, + setText: setText, + setTextPos: setTextPos, + tryScan: tryScan, + lookAhead: lookAhead + }; + } + ts.createScanner = createScanner; +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.optionDeclarations = [ + { + name: "charset", + type: "string" + }, + { + name: "codepage", + type: "number" + }, + { + name: "declaration", + shortName: "d", + type: "boolean", + description: ts.Diagnostics.Generates_corresponding_d_ts_file + }, + { + name: "diagnostics", + type: "boolean" + }, + { + name: "emitBOM", + type: "boolean" + }, + { + name: "help", + shortName: "h", + type: "boolean", + description: ts.Diagnostics.Print_this_message + }, + { + name: "listFiles", + type: "boolean" + }, + { + name: "locale", + type: "string" + }, + { + name: "mapRoot", + type: "string", + isFilePath: true, + description: ts.Diagnostics.Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations, + paramType: ts.Diagnostics.LOCATION + }, + { + name: "module", + shortName: "m", + type: { + "commonjs": 1, + "amd": 2 + }, + description: ts.Diagnostics.Specify_module_code_generation_Colon_commonjs_or_amd, + paramType: ts.Diagnostics.KIND, + error: ts.Diagnostics.Argument_for_module_option_must_be_commonjs_or_amd + }, + { + name: "noEmit", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_outputs + }, + { + name: "noEmitOnError", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_outputs_if_any_type_checking_errors_were_reported + }, + { + name: "noImplicitAny", + type: "boolean", + description: ts.Diagnostics.Raise_error_on_expressions_and_declarations_with_an_implied_any_type + }, + { + name: "noLib", + type: "boolean" + }, + { + name: "noLibCheck", + type: "boolean" + }, + { + name: "noResolve", + type: "boolean" + }, + { + name: "out", + type: "string", + description: ts.Diagnostics.Concatenate_and_emit_output_to_single_file, + paramType: ts.Diagnostics.FILE + }, + { + name: "outDir", + type: "string", + isFilePath: true, + description: ts.Diagnostics.Redirect_output_structure_to_the_directory, + paramType: ts.Diagnostics.DIRECTORY + }, + { + name: "preserveConstEnums", + type: "boolean", + description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code + }, + { + name: "project", + shortName: "p", + type: "string", + isFilePath: true, + description: ts.Diagnostics.Compile_the_project_in_the_given_directory, + paramType: ts.Diagnostics.DIRECTORY + }, + { + name: "removeComments", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_comments_to_output + }, + { + name: "sourceMap", + type: "boolean", + description: ts.Diagnostics.Generates_corresponding_map_file + }, + { + name: "sourceRoot", + type: "string", + isFilePath: true, + description: ts.Diagnostics.Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations, + paramType: ts.Diagnostics.LOCATION + }, + { + name: "suppressImplicitAnyIndexErrors", + type: "boolean", + description: ts.Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures + }, + { + name: "stripInternal", + type: "boolean", + description: ts.Diagnostics.Do_not_emit_declarations_for_code_that_has_an_internal_annotation, + experimental: true + }, + { + name: "target", + shortName: "t", + type: { "es3": 0, "es5": 1, "es6": 2 }, + description: ts.Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental, + paramType: ts.Diagnostics.VERSION, + error: ts.Diagnostics.Argument_for_target_option_must_be_es3_es5_or_es6 + }, + { + name: "version", + shortName: "v", + type: "boolean", + description: ts.Diagnostics.Print_the_compiler_s_version + }, + { + name: "watch", + shortName: "w", + type: "boolean", + description: ts.Diagnostics.Watch_input_files + } + ]; + function parseCommandLine(commandLine) { + var options = {}; + var fileNames = []; + var errors = []; + var shortOptionNames = {}; + var optionNameMap = {}; + ts.forEach(ts.optionDeclarations, function (option) { + optionNameMap[option.name.toLowerCase()] = option; + if (option.shortName) { + shortOptionNames[option.shortName] = option.name; + } + }); + parseStrings(commandLine); + return { + options: options, + fileNames: fileNames, + errors: errors + }; + function parseStrings(args) { + var i = 0; + while (i < args.length) { + var s = args[i++]; + if (s.charCodeAt(0) === 64) { + parseResponseFile(s.slice(1)); + } + else if (s.charCodeAt(0) === 45) { + s = s.slice(s.charCodeAt(1) === 45 ? 2 : 1).toLowerCase(); + if (ts.hasProperty(shortOptionNames, s)) { + s = shortOptionNames[s]; + } + if (ts.hasProperty(optionNameMap, s)) { + var opt = optionNameMap[s]; + if (!args[i] && opt.type !== "boolean") { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_expects_an_argument, opt.name)); + } + switch (opt.type) { + case "number": + options[opt.name] = parseInt(args[i++]); + break; + case "boolean": + options[opt.name] = true; + break; + case "string": + options[opt.name] = args[i++] || ""; + break; + default: + var map = opt.type; + var key = (args[i++] || "").toLowerCase(); + if (ts.hasProperty(map, key)) { + options[opt.name] = map[key]; + } + else { + errors.push(ts.createCompilerDiagnostic(opt.error)); + } + } + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_compiler_option_0, s)); + } + } + else { + fileNames.push(s); + } + } + } + function parseResponseFile(fileName) { + var text = ts.sys.readFile(fileName); + if (!text) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, fileName)); + return; + } + var args = []; + var pos = 0; + while (true) { + while (pos < text.length && text.charCodeAt(pos) <= 32) + pos++; + if (pos >= text.length) + break; + var start = pos; + if (text.charCodeAt(start) === 34) { + pos++; + while (pos < text.length && text.charCodeAt(pos) !== 34) + pos++; + if (pos < text.length) { + args.push(text.substring(start + 1, pos)); + pos++; + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName)); + } + } + else { + while (text.charCodeAt(pos) > 32) + pos++; + args.push(text.substring(start, pos)); + } + } + parseStrings(args); + } + } + ts.parseCommandLine = parseCommandLine; + function readConfigFile(fileName) { + try { + var text = ts.sys.readFile(fileName); + return /\S/.test(text) ? JSON.parse(text) : {}; + } + catch (e) { + } + } + ts.readConfigFile = readConfigFile; + function parseConfigFile(json, basePath) { + var errors = []; + return { + options: getCompilerOptions(), + fileNames: getFiles(), + errors: errors + }; + function getCompilerOptions() { + var options = {}; + var optionNameMap = {}; + ts.forEach(ts.optionDeclarations, function (option) { + optionNameMap[option.name] = option; + }); + var jsonOptions = json["compilerOptions"]; + if (jsonOptions) { + for (var id in jsonOptions) { + if (ts.hasProperty(optionNameMap, id)) { + var opt = optionNameMap[id]; + var optType = opt.type; + var value = jsonOptions[id]; + var expectedType = typeof optType === "string" ? optType : "string"; + if (typeof value === expectedType) { + if (typeof optType !== "string") { + var key = value.toLowerCase(); + if (ts.hasProperty(optType, key)) { + value = optType[key]; + } + else { + errors.push(ts.createCompilerDiagnostic(opt.error)); + value = 0; + } + } + if (opt.isFilePath) { + value = ts.normalizePath(ts.combinePaths(basePath, value)); + } + options[opt.name] = value; + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, id, expectedType)); + } + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_compiler_option_0, id)); + } + } + } + return options; + } + function getFiles() { + var files = []; + if (ts.hasProperty(json, "files")) { + if (json["files"] instanceof Array) { + var files = ts.map(json["files"], function (s) { return ts.combinePaths(basePath, s); }); + } + } + else { + var sysFiles = ts.sys.readDirectory(basePath, ".ts"); + for (var i = 0; i < sysFiles.length; i++) { + var name = sysFiles[i]; + if (!ts.fileExtensionIs(name, ".d.ts") || !ts.contains(sysFiles, name.substr(0, name.length - 5) + ".ts")) { + files.push(name); + } + } + } + return files; + } + } + ts.parseConfigFile = parseConfigFile; +})(ts || (ts = {})); +var ts; +(function (ts) { + function getDeclarationOfKind(symbol, kind) { + var declarations = symbol.declarations; + for (var i = 0; i < declarations.length; i++) { + var declaration = declarations[i]; + if (declaration.kind === kind) { + return declaration; + } + } + return undefined; + } + ts.getDeclarationOfKind = getDeclarationOfKind; + var stringWriters = []; + function getSingleLineStringWriter() { + if (stringWriters.length == 0) { + var str = ""; + var writeText = function (text) { return str += text; }; + return { + string: function () { return str; }, + writeKeyword: writeText, + writeOperator: writeText, + writePunctuation: writeText, + writeSpace: writeText, + writeStringLiteral: writeText, + writeParameter: writeText, + writeSymbol: writeText, + writeLine: function () { return str += " "; }, + increaseIndent: function () { }, + decreaseIndent: function () { }, + clear: function () { return str = ""; }, + trackSymbol: function () { } + }; + } + return stringWriters.pop(); + } + ts.getSingleLineStringWriter = getSingleLineStringWriter; + function releaseStringWriter(writer) { + writer.clear(); + stringWriters.push(writer); + } + ts.releaseStringWriter = releaseStringWriter; + function getFullWidth(node) { + return node.end - node.pos; + } + ts.getFullWidth = getFullWidth; + function containsParseError(node) { + aggregateChildData(node); + return (node.parserContextFlags & 32) !== 0; + } + ts.containsParseError = containsParseError; + function aggregateChildData(node) { + if (!(node.parserContextFlags & 64)) { + var thisNodeOrAnySubNodesHasError = ((node.parserContextFlags & 16) !== 0) || + ts.forEachChild(node, containsParseError); + if (thisNodeOrAnySubNodesHasError) { + node.parserContextFlags |= 32; + } + node.parserContextFlags |= 64; + } + } + function getSourceFileOfNode(node) { + while (node && node.kind !== 220) { + node = node.parent; + } + return node; + } + ts.getSourceFileOfNode = getSourceFileOfNode; + function getStartPositionOfLine(line, sourceFile) { + ts.Debug.assert(line >= 0); + return ts.getLineStarts(sourceFile)[line]; + } + ts.getStartPositionOfLine = getStartPositionOfLine; + function nodePosToString(node) { + var file = getSourceFileOfNode(node); + var loc = ts.getLineAndCharacterOfPosition(file, node.pos); + return file.fileName + "(" + (loc.line + 1) + "," + (loc.character + 1) + ")"; + } + ts.nodePosToString = nodePosToString; + function getStartPosOfNode(node) { + return node.pos; + } + ts.getStartPosOfNode = getStartPosOfNode; + function nodeIsMissing(node) { + if (!node) { + return true; + } + return node.pos === node.end && node.kind !== 1; + } + ts.nodeIsMissing = nodeIsMissing; + function nodeIsPresent(node) { + return !nodeIsMissing(node); + } + ts.nodeIsPresent = nodeIsPresent; + function getTokenPosOfNode(node, sourceFile) { + if (nodeIsMissing(node)) { + return node.pos; + } + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos); + } + ts.getTokenPosOfNode = getTokenPosOfNode; + function getSourceTextOfNodeFromSourceFile(sourceFile, node) { + if (nodeIsMissing(node)) { + return ""; + } + var text = sourceFile.text; + return text.substring(ts.skipTrivia(text, node.pos), node.end); + } + ts.getSourceTextOfNodeFromSourceFile = getSourceTextOfNodeFromSourceFile; + function getTextOfNodeFromSourceText(sourceText, node) { + if (nodeIsMissing(node)) { + return ""; + } + return sourceText.substring(ts.skipTrivia(sourceText, node.pos), node.end); + } + ts.getTextOfNodeFromSourceText = getTextOfNodeFromSourceText; + function getTextOfNode(node) { + return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node); + } + ts.getTextOfNode = getTextOfNode; + function escapeIdentifier(identifier) { + return identifier.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier; + } + ts.escapeIdentifier = escapeIdentifier; + function unescapeIdentifier(identifier) { + return identifier.length >= 3 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 && identifier.charCodeAt(2) === 95 ? identifier.substr(1) : identifier; + } + ts.unescapeIdentifier = unescapeIdentifier; + function makeIdentifierFromModuleName(moduleName) { + return ts.getBaseFileName(moduleName).replace(/\W/g, "_"); + } + ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; + function declarationNameToString(name) { + return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); + } + ts.declarationNameToString = declarationNameToString; + function createDiagnosticForNode(node, message, arg0, arg1, arg2) { + node = getErrorSpanForNode(node); + var file = getSourceFileOfNode(node); + var start = getTokenPosOfNode(node, file); + var length = node.end - start; + return ts.createFileDiagnostic(file, start, length, message, arg0, arg1, arg2); + } + ts.createDiagnosticForNode = createDiagnosticForNode; + function createDiagnosticForNodeFromMessageChain(node, messageChain) { + node = getErrorSpanForNode(node); + var file = getSourceFileOfNode(node); + var start = ts.skipTrivia(file.text, node.pos); + var length = node.end - start; + return { + file: file, + start: start, + length: length, + code: messageChain.code, + category: messageChain.category, + messageText: messageChain.next ? messageChain : messageChain.messageText + }; + } + ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain; + function getErrorSpanForNode(node) { + var errorSpan; + switch (node.kind) { + case 193: + case 150: + case 196: + case 197: + case 200: + case 199: + case 219: + errorSpan = node.name; + break; + } + return errorSpan && errorSpan.pos < errorSpan.end ? errorSpan : node; + } + ts.getErrorSpanForNode = getErrorSpanForNode; + function isExternalModule(file) { + return file.externalModuleIndicator !== undefined; + } + ts.isExternalModule = isExternalModule; + function isDeclarationFile(file) { + return (file.flags & 1024) !== 0; + } + ts.isDeclarationFile = isDeclarationFile; + function isConstEnumDeclaration(node) { + return node.kind === 199 && isConst(node); + } + ts.isConstEnumDeclaration = isConstEnumDeclaration; + function walkUpBindingElementsAndPatterns(node) { + while (node && (node.kind === 150 || isBindingPattern(node))) { + node = node.parent; + } + return node; + } + function getCombinedNodeFlags(node) { + node = walkUpBindingElementsAndPatterns(node); + var flags = node.flags; + if (node.kind === 193) { + node = node.parent; + } + if (node && node.kind === 194) { + flags |= node.flags; + node = node.parent; + } + if (node && node.kind === 175) { + flags |= node.flags; + } + return flags; + } + ts.getCombinedNodeFlags = getCombinedNodeFlags; + function isConst(node) { + return !!(getCombinedNodeFlags(node) & 4096); + } + ts.isConst = isConst; + function isLet(node) { + return !!(getCombinedNodeFlags(node) & 2048); + } + ts.isLet = isLet; + function isPrologueDirective(node) { + return node.kind === 177 && node.expression.kind === 8; + } + ts.isPrologueDirective = isPrologueDirective; + function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { + sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node); + if (node.kind === 128 || node.kind === 127) { + return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); + } + else { + return ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos); + } + } + ts.getLeadingCommentRangesOfNode = getLeadingCommentRangesOfNode; + function getJsDocComments(node, sourceFileOfNode) { + return ts.filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), isJsDocComment); + function isJsDocComment(comment) { + return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === 42 && + sourceFileOfNode.text.charCodeAt(comment.pos + 2) === 42 && + sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== 47; + } + } + ts.getJsDocComments = getJsDocComments; + ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; + function forEachReturnStatement(body, visitor) { + return traverse(body); + function traverse(node) { + switch (node.kind) { + case 186: + return visitor(node); + case 174: + case 178: + case 179: + case 180: + case 181: + case 182: + case 183: + case 187: + case 188: + case 213: + case 214: + case 189: + case 191: + case 216: + return ts.forEachChild(node, traverse); + } + } + } + ts.forEachReturnStatement = forEachReturnStatement; + function isAnyFunction(node) { + if (node) { + switch (node.kind) { + case 133: + case 160: + case 195: + case 161: + case 132: + case 131: + case 134: + case 135: + case 136: + case 137: + case 138: + case 140: + case 141: + case 160: + case 161: + case 195: + return true; + } + } + return false; + } + ts.isAnyFunction = isAnyFunction; + function isFunctionBlock(node) { + return node && node.kind === 174 && isAnyFunction(node.parent); + } + ts.isFunctionBlock = isFunctionBlock; + function isObjectLiteralMethod(node) { + return node && node.kind === 132 && node.parent.kind === 152; + } + ts.isObjectLiteralMethod = isObjectLiteralMethod; + function getContainingFunction(node) { + while (true) { + node = node.parent; + if (!node || isAnyFunction(node)) { + return node; + } + } + } + ts.getContainingFunction = getContainingFunction; + function getThisContainer(node, includeArrowFunctions) { + while (true) { + node = node.parent; + if (!node) { + return undefined; + } + switch (node.kind) { + case 126: + if (node.parent.parent.kind === 196) { + return node; + } + node = node.parent; + break; + case 161: + if (!includeArrowFunctions) { + continue; + } + case 195: + case 160: + case 200: + case 130: + case 129: + case 132: + case 131: + case 133: + case 134: + case 135: + case 199: + case 220: + return node; + } + } + } + ts.getThisContainer = getThisContainer; + function getSuperContainer(node, includeFunctions) { + while (true) { + node = node.parent; + if (!node) + return node; + switch (node.kind) { + case 126: + if (node.parent.parent.kind === 196) { + return node; + } + node = node.parent; + break; + case 195: + case 160: + case 161: + if (!includeFunctions) { + continue; + } + case 130: + case 129: + case 132: + case 131: + case 133: + case 134: + case 135: + return node; + } + } + } + ts.getSuperContainer = getSuperContainer; + function getInvokedExpression(node) { + if (node.kind === 157) { + return node.tag; + } + return node.expression; + } + ts.getInvokedExpression = getInvokedExpression; + function isExpression(node) { + switch (node.kind) { + case 92: + case 90: + case 88: + case 94: + case 79: + case 9: + case 151: + case 152: + case 153: + case 154: + case 155: + case 156: + case 157: + case 158: + case 159: + case 160: + case 161: + case 164: + case 162: + case 163: + case 165: + case 166: + case 167: + case 168: + case 171: + case 169: + case 10: + case 172: + return true; + case 125: + while (node.parent.kind === 125) { + node = node.parent; + } + return node.parent.kind === 142; + case 64: + if (node.parent.kind === 142) { + return true; + } + case 7: + case 8: + var parent = node.parent; + switch (parent.kind) { + case 193: + case 128: + case 130: + case 129: + case 219: + case 217: + case 150: + return parent.initializer === node; + case 177: + case 178: + case 179: + case 180: + case 186: + case 187: + case 188: + case 213: + case 190: + case 188: + return parent.expression === node; + case 181: + var forStatement = parent; + return (forStatement.initializer === node && forStatement.initializer.kind !== 194) || + forStatement.condition === node || + forStatement.iterator === node; + case 182: + case 183: + var forInStatement = parent; + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 194) || + forInStatement.expression === node; + case 158: + return node === parent.expression; + case 173: + return node === parent.expression; + case 126: + return node === parent.expression; + default: + if (isExpression(parent)) { + return true; + } + } + } + return false; + } + ts.isExpression = isExpression; + function isInstantiatedModule(node, preserveConstEnums) { + var moduleState = ts.getModuleInstanceState(node); + return moduleState === 1 || + (preserveConstEnums && moduleState === 2); + } + ts.isInstantiatedModule = isInstantiatedModule; + function isExternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind === 212; + } + ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; + function getExternalModuleImportEqualsDeclarationExpression(node) { + ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node)); + return node.moduleReference.expression; + } + ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; + function isInternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind !== 212; + } + ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; + function getExternalModuleName(node) { + if (node.kind === 203) { + return node.moduleSpecifier; + } + if (node.kind === 202) { + var reference = node.moduleReference; + if (reference.kind === 212) { + return reference.expression; + } + } + if (node.kind === 209) { + return node.moduleSpecifier; + } + } + ts.getExternalModuleName = getExternalModuleName; + function hasDotDotDotToken(node) { + return node && node.kind === 128 && node.dotDotDotToken !== undefined; + } + ts.hasDotDotDotToken = hasDotDotDotToken; + function hasQuestionToken(node) { + if (node) { + switch (node.kind) { + case 128: + return node.questionToken !== undefined; + case 132: + case 131: + return node.questionToken !== undefined; + case 218: + case 217: + case 130: + case 129: + return node.questionToken !== undefined; + } + } + return false; + } + ts.hasQuestionToken = hasQuestionToken; + function hasRestParameters(s) { + return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined; + } + ts.hasRestParameters = hasRestParameters; + function isLiteralKind(kind) { + return 7 <= kind && kind <= 10; + } + ts.isLiteralKind = isLiteralKind; + function isTextualLiteralKind(kind) { + return kind === 8 || kind === 10; + } + ts.isTextualLiteralKind = isTextualLiteralKind; + function isTemplateLiteralKind(kind) { + return 10 <= kind && kind <= 13; + } + ts.isTemplateLiteralKind = isTemplateLiteralKind; + function isBindingPattern(node) { + return node.kind === 149 || node.kind === 148; + } + ts.isBindingPattern = isBindingPattern; + function isInAmbientContext(node) { + while (node) { + if (node.flags & (2 | 1024)) { + return true; + } + node = node.parent; + } + return false; + } + ts.isInAmbientContext = isInAmbientContext; + function isDeclaration(node) { + switch (node.kind) { + case 127: + case 128: + case 193: + case 150: + case 130: + case 129: + case 217: + case 218: + case 219: + case 132: + case 131: + case 195: + case 134: + case 135: + case 133: + case 196: + case 197: + case 198: + case 199: + case 200: + case 202: + case 204: + case 207: + case 205: + case 211: + return true; + } + return false; + } + ts.isDeclaration = isDeclaration; + function isStatement(n) { + switch (n.kind) { + case 185: + case 184: + case 192: + case 179: + case 177: + case 176: + case 182: + case 183: + case 181: + case 178: + case 189: + case 186: + case 188: + case 93: + case 191: + case 175: + case 180: + case 187: + case 208: + return true; + default: + return false; + } + } + ts.isStatement = isStatement; + function isDeclarationOrFunctionExpressionOrCatchVariableName(name) { + if (name.kind !== 64 && name.kind !== 8 && name.kind !== 7) { + return false; + } + var parent = name.parent; + if (isDeclaration(parent) || parent.kind === 160) { + return parent.name === name; + } + if (parent.kind === 216) { + return parent.name === name; + } + return false; + } + ts.isDeclarationOrFunctionExpressionOrCatchVariableName = isDeclarationOrFunctionExpressionOrCatchVariableName; + function getClassBaseTypeNode(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 78); + return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; + } + ts.getClassBaseTypeNode = getClassBaseTypeNode; + function getClassImplementedTypeNodes(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 103); + return heritageClause ? heritageClause.types : undefined; + } + ts.getClassImplementedTypeNodes = getClassImplementedTypeNodes; + function getInterfaceBaseTypeNodes(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 78); + return heritageClause ? heritageClause.types : undefined; + } + ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes; + function getHeritageClause(clauses, kind) { + if (clauses) { + for (var i = 0, n = clauses.length; i < n; i++) { + if (clauses[i].token === kind) { + return clauses[i]; + } + } + } + return undefined; + } + ts.getHeritageClause = getHeritageClause; + function tryResolveScriptReference(host, sourceFile, reference) { + if (!host.getCompilerOptions().noResolve) { + var referenceFileName = ts.isRootedDiskPath(reference.fileName) ? reference.fileName : ts.combinePaths(ts.getDirectoryPath(sourceFile.fileName), reference.fileName); + referenceFileName = ts.getNormalizedAbsolutePath(referenceFileName, host.getCurrentDirectory()); + return host.getSourceFile(referenceFileName); + } + } + ts.tryResolveScriptReference = tryResolveScriptReference; + function getAncestor(node, kind) { + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; + } + return undefined; + } + ts.getAncestor = getAncestor; + function getFileReferenceFromReferencePath(comment, commentRange) { + var simpleReferenceRegEx = /^\/\/\/\s*/gim; + if (simpleReferenceRegEx.exec(comment)) { + if (isNoDefaultLibRegEx.exec(comment)) { + return { + isNoDefaultLib: true + }; + } + else { + var matchResult = ts.fullTripleSlashReferencePathRegEx.exec(comment); + if (matchResult) { + var start = commentRange.pos; + var end = commentRange.end; + return { + fileReference: { + pos: start, + end: end, + fileName: matchResult[3] + }, + isNoDefaultLib: false + }; + } + else { + return { + diagnosticMessage: ts.Diagnostics.Invalid_reference_directive_syntax, + isNoDefaultLib: false + }; + } + } + } + return undefined; + } + ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; + function isKeyword(token) { + return 65 <= token && token <= 124; + } + ts.isKeyword = isKeyword; + function isTrivia(token) { + return 2 <= token && token <= 6; + } + ts.isTrivia = isTrivia; + function hasDynamicName(declaration) { + return declaration.name && + declaration.name.kind === 126 && + !isWellKnownSymbolSyntactically(declaration.name.expression); + } + ts.hasDynamicName = hasDynamicName; + function isWellKnownSymbolSyntactically(node) { + return node.kind === 153 && isESSymbolIdentifier(node.expression); + } + ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; + function getPropertyNameForPropertyNameNode(name) { + if (name.kind === 64 || name.kind === 8 || name.kind === 7) { + return name.text; + } + if (name.kind === 126) { + var nameExpression = name.expression; + if (isWellKnownSymbolSyntactically(nameExpression)) { + var rightHandSideName = nameExpression.name.text; + return getPropertyNameForKnownSymbolName(rightHandSideName); + } + } + return undefined; + } + ts.getPropertyNameForPropertyNameNode = getPropertyNameForPropertyNameNode; + function getPropertyNameForKnownSymbolName(symbolName) { + return "__@" + symbolName; + } + ts.getPropertyNameForKnownSymbolName = getPropertyNameForKnownSymbolName; + function isESSymbolIdentifier(node) { + return node.kind === 64 && node.text === "Symbol"; + } + ts.isESSymbolIdentifier = isESSymbolIdentifier; + function isModifier(token) { + switch (token) { + case 109: + case 107: + case 108: + case 110: + case 77: + case 115: + case 69: + return true; + } + return false; + } + ts.isModifier = isModifier; + function textSpanEnd(span) { + return span.start + span.length; + } + ts.textSpanEnd = textSpanEnd; + function textSpanIsEmpty(span) { + return span.length === 0; + } + ts.textSpanIsEmpty = textSpanIsEmpty; + function textSpanContainsPosition(span, position) { + return position >= span.start && position < textSpanEnd(span); + } + ts.textSpanContainsPosition = textSpanContainsPosition; + function textSpanContainsTextSpan(span, other) { + return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span); + } + ts.textSpanContainsTextSpan = textSpanContainsTextSpan; + function textSpanOverlapsWith(span, other) { + var overlapStart = Math.max(span.start, other.start); + var overlapEnd = Math.min(textSpanEnd(span), textSpanEnd(other)); + return overlapStart < overlapEnd; + } + ts.textSpanOverlapsWith = textSpanOverlapsWith; + function textSpanOverlap(span1, span2) { + var overlapStart = Math.max(span1.start, span2.start); + var overlapEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2)); + if (overlapStart < overlapEnd) { + return createTextSpanFromBounds(overlapStart, overlapEnd); + } + return undefined; + } + ts.textSpanOverlap = textSpanOverlap; + function textSpanIntersectsWithTextSpan(span, other) { + return other.start <= textSpanEnd(span) && textSpanEnd(other) >= span.start; + } + ts.textSpanIntersectsWithTextSpan = textSpanIntersectsWithTextSpan; + function textSpanIntersectsWith(span, start, length) { + var end = start + length; + return start <= textSpanEnd(span) && end >= span.start; + } + ts.textSpanIntersectsWith = textSpanIntersectsWith; + function textSpanIntersectsWithPosition(span, position) { + return position <= textSpanEnd(span) && position >= span.start; + } + ts.textSpanIntersectsWithPosition = textSpanIntersectsWithPosition; + function textSpanIntersection(span1, span2) { + var intersectStart = Math.max(span1.start, span2.start); + var intersectEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2)); + if (intersectStart <= intersectEnd) { + return createTextSpanFromBounds(intersectStart, intersectEnd); + } + return undefined; + } + ts.textSpanIntersection = textSpanIntersection; + function createTextSpan(start, length) { + if (start < 0) { + throw new Error("start < 0"); + } + if (length < 0) { + throw new Error("length < 0"); + } + return { start: start, length: length }; + } + ts.createTextSpan = createTextSpan; + function createTextSpanFromBounds(start, end) { + return createTextSpan(start, end - start); + } + ts.createTextSpanFromBounds = createTextSpanFromBounds; + function textChangeRangeNewSpan(range) { + return createTextSpan(range.span.start, range.newLength); + } + ts.textChangeRangeNewSpan = textChangeRangeNewSpan; + function textChangeRangeIsUnchanged(range) { + return textSpanIsEmpty(range.span) && range.newLength === 0; + } + ts.textChangeRangeIsUnchanged = textChangeRangeIsUnchanged; + function createTextChangeRange(span, newLength) { + if (newLength < 0) { + throw new Error("newLength < 0"); + } + return { span: span, newLength: newLength }; + } + ts.createTextChangeRange = createTextChangeRange; + ts.unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0); + function collapseTextChangeRangesAcrossMultipleVersions(changes) { + if (changes.length === 0) { + return ts.unchangedTextChangeRange; + } + if (changes.length === 1) { + return changes[0]; + } + var change0 = changes[0]; + var oldStartN = change0.span.start; + var oldEndN = textSpanEnd(change0.span); + var newEndN = oldStartN + change0.newLength; + for (var i = 1; i < changes.length; i++) { + var nextChange = changes[i]; + var oldStart1 = oldStartN; + var oldEnd1 = oldEndN; + var newEnd1 = newEndN; + var oldStart2 = nextChange.span.start; + var oldEnd2 = textSpanEnd(nextChange.span); + var newEnd2 = oldStart2 + nextChange.newLength; + oldStartN = Math.min(oldStart1, oldStart2); + oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); + newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); + } + return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), newEndN - oldStartN); + } + ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; + function createDiagnosticCollection() { + var nonFileDiagnostics = []; + var fileDiagnostics = {}; + var diagnosticsModified = false; + var modificationCount = 0; + return { + add: add, + getGlobalDiagnostics: getGlobalDiagnostics, + getDiagnostics: getDiagnostics, + getModificationCount: getModificationCount + }; + function getModificationCount() { + return modificationCount; + } + function add(diagnostic) { + var diagnostics; + if (diagnostic.file) { + diagnostics = fileDiagnostics[diagnostic.file.fileName]; + if (!diagnostics) { + diagnostics = []; + fileDiagnostics[diagnostic.file.fileName] = diagnostics; + } + } + else { + diagnostics = nonFileDiagnostics; + } + diagnostics.push(diagnostic); + diagnosticsModified = true; + modificationCount++; + } + function getGlobalDiagnostics() { + sortAndDeduplicate(); + return nonFileDiagnostics; + } + function getDiagnostics(fileName) { + sortAndDeduplicate(); + if (fileName) { + return fileDiagnostics[fileName] || []; + } + var allDiagnostics = []; + function pushDiagnostic(d) { + allDiagnostics.push(d); + } + ts.forEach(nonFileDiagnostics, pushDiagnostic); + for (var key in fileDiagnostics) { + if (ts.hasProperty(fileDiagnostics, key)) { + ts.forEach(fileDiagnostics[key], pushDiagnostic); + } + } + return ts.sortAndDeduplicateDiagnostics(allDiagnostics); + } + function sortAndDeduplicate() { + if (!diagnosticsModified) { + return; + } + diagnosticsModified = false; + nonFileDiagnostics = ts.sortAndDeduplicateDiagnostics(nonFileDiagnostics); + for (var key in fileDiagnostics) { + if (ts.hasProperty(fileDiagnostics, key)) { + fileDiagnostics[key] = ts.sortAndDeduplicateDiagnostics(fileDiagnostics[key]); + } + } + } + } + ts.createDiagnosticCollection = createDiagnosticCollection; +})(ts || (ts = {})); +var ts; +(function (ts) { + var nodeConstructors = new Array(222); + ts.parseTime = 0; + function getNodeConstructor(kind) { + return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); + } + ts.getNodeConstructor = getNodeConstructor; + function createNode(kind) { + return new (getNodeConstructor(kind))(); + } + ts.createNode = createNode; + function visitNode(cbNode, node) { + if (node) { + return cbNode(node); + } + } + function visitNodeArray(cbNodes, nodes) { + if (nodes) { + return cbNodes(nodes); + } + } + function visitEachNode(cbNode, nodes) { + if (nodes) { + for (var i = 0, len = nodes.length; i < len; i++) { + var result = cbNode(nodes[i]); + if (result) { + return result; + } + } + } + } + function forEachChild(node, cbNode, cbNodeArray) { + if (!node) { + return; + } + var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; + var cbNodes = cbNodeArray || cbNode; + switch (node.kind) { + case 125: + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + case 127: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.constraint) || + visitNode(cbNode, node.expression); + case 128: + case 130: + case 129: + case 217: + case 218: + case 193: + case 150: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + case 140: + case 141: + case 136: + case 137: + case 138: + return visitNodes(cbNodes, node.modifiers) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.parameters) || + visitNode(cbNode, node.type); + case 132: + case 131: + case 133: + case 134: + case 135: + case 160: + case 195: + case 161: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + case 139: + return visitNode(cbNode, node.typeName) || + visitNodes(cbNodes, node.typeArguments); + case 142: + return visitNode(cbNode, node.exprName); + case 143: + return visitNodes(cbNodes, node.members); + case 144: + return visitNode(cbNode, node.elementType); + case 145: + return visitNodes(cbNodes, node.elementTypes); + case 146: + return visitNodes(cbNodes, node.types); + case 147: + return visitNode(cbNode, node.type); + case 148: + case 149: + return visitNodes(cbNodes, node.elements); + case 151: + return visitNodes(cbNodes, node.elements); + case 152: + return visitNodes(cbNodes, node.properties); + case 153: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.name); + case 154: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.argumentExpression); + case 155: + case 156: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.typeArguments) || + visitNodes(cbNodes, node.arguments); + case 157: + return visitNode(cbNode, node.tag) || + visitNode(cbNode, node.template); + case 158: + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.expression); + case 159: + return visitNode(cbNode, node.expression); + case 162: + return visitNode(cbNode, node.expression); + case 163: + return visitNode(cbNode, node.expression); + case 164: + return visitNode(cbNode, node.expression); + case 165: + return visitNode(cbNode, node.operand); + case 170: + return visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.expression); + case 166: + return visitNode(cbNode, node.operand); + case 167: + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.operatorToken) || + visitNode(cbNode, node.right); + case 168: + return visitNode(cbNode, node.condition) || + visitNode(cbNode, node.whenTrue) || + visitNode(cbNode, node.whenFalse); + case 171: + return visitNode(cbNode, node.expression); + case 174: + case 201: + return visitNodes(cbNodes, node.statements); + case 220: + return visitNodes(cbNodes, node.statements) || + visitNode(cbNode, node.endOfFileToken); + case 175: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.declarationList); + case 194: + return visitNodes(cbNodes, node.declarations); + case 177: + return visitNode(cbNode, node.expression); + case 178: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.thenStatement) || + visitNode(cbNode, node.elseStatement); + case 179: + return visitNode(cbNode, node.statement) || + visitNode(cbNode, node.expression); + case 180: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 181: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.condition) || + visitNode(cbNode, node.iterator) || + visitNode(cbNode, node.statement); + case 182: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 183: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 184: + case 185: + return visitNode(cbNode, node.label); + case 186: + return visitNode(cbNode, node.expression); + case 187: + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 188: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.clauses); + case 213: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.statements); + case 214: + return visitNodes(cbNodes, node.statements); + case 189: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 190: + return visitNode(cbNode, node.expression); + case 191: + return visitNode(cbNode, node.tryBlock) || + visitNode(cbNode, node.catchClause) || + visitNode(cbNode, node.finallyBlock); + case 216: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.block); + case 196: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || + visitNodes(cbNodes, node.members); + case 197: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || + visitNodes(cbNodes, node.members); + case 198: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.type); + case 199: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.members); + case 219: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + case 200: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + case 202: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.moduleReference); + case 203: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier); + case 204: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + case 205: + return visitNode(cbNode, node.name); + case 206: + case 210: + return visitNodes(cbNodes, node.elements); + case 209: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier); + case 207: + case 211: + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + case 208: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.exportName); + case 169: + return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); + case 173: + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); + case 126: + return visitNode(cbNode, node.expression); + case 215: + return visitNodes(cbNodes, node.types); + case 212: + return visitNode(cbNode, node.expression); + } + } + ts.forEachChild = forEachChild; + function parsingContextErrors(context) { + 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.Type_reference_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; + } + } + ; + function modifierToFlag(token) { + switch (token) { + case 110: return 128; + case 109: return 16; + case 108: return 64; + case 107: return 32; + case 77: return 1; + case 115: return 2; + case 69: return 4096; + } + return 0; + } + ts.modifierToFlag = modifierToFlag; + function fixupParentReferences(sourceFile) { + var parent = sourceFile; + forEachChild(sourceFile, visitNode); + return; + function visitNode(n) { + if (n.parent !== parent) { + n.parent = parent; + var saveParent = parent; + parent = n; + forEachChild(n, visitNode); + parent = saveParent; + } + } + } + function shouldCheckNode(node) { + switch (node.kind) { + case 8: + case 7: + case 64: + return true; + } + return false; + } + function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) { + if (isArray) { + visitArray(element); + } + else { + visitNode(element); + } + return; + function visitNode(node) { + if (aggressiveChecks && shouldCheckNode(node)) { + var text = oldText.substring(node.pos, node.end); + } + node._children = undefined; + node.pos += delta; + node.end += delta; + if (aggressiveChecks && shouldCheckNode(node)) { + ts.Debug.assert(text === newText.substring(node.pos, node.end)); + } + forEachChild(node, visitNode, visitArray); + checkNodePositions(node, aggressiveChecks); + } + function visitArray(array) { + array._children = undefined; + array.pos += delta; + array.end += delta; + for (var i = 0, n = array.length; i < n; i++) { + visitNode(array[i]); + } + } + } + function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) { + ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range"); + ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range"); + ts.Debug.assert(element.pos <= element.end); + element.pos = Math.min(element.pos, changeRangeNewEnd); + if (element.end >= changeRangeOldEnd) { + element.end += delta; + } + else { + element.end = Math.min(element.end, changeRangeNewEnd); + } + ts.Debug.assert(element.pos <= element.end); + if (element.parent) { + ts.Debug.assert(element.pos >= element.parent.pos); + ts.Debug.assert(element.end <= element.parent.end); + } + } + function checkNodePositions(node, aggressiveChecks) { + if (aggressiveChecks) { + var pos = node.pos; + forEachChild(node, function (child) { + ts.Debug.assert(child.pos >= pos); + pos = child.end; + }); + ts.Debug.assert(pos <= node.end); + } + } + function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) { + visitNode(sourceFile); + return; + function visitNode(child) { + ts.Debug.assert(child.pos <= child.end); + if (child.pos > changeRangeOldEnd) { + moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks); + return; + } + var fullEnd = child.end; + if (fullEnd >= changeStart) { + child.intersectsChange = true; + child._children = undefined; + adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); + forEachChild(child, visitNode, visitArray); + checkNodePositions(child, aggressiveChecks); + return; + } + ts.Debug.assert(fullEnd < changeStart); + } + function visitArray(array) { + ts.Debug.assert(array.pos <= array.end); + if (array.pos > changeRangeOldEnd) { + moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks); + return; + } + var fullEnd = array.end; + if (fullEnd >= changeStart) { + array.intersectsChange = true; + array._children = undefined; + adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); + for (var i = 0, n = array.length; i < n; i++) { + visitNode(array[i]); + } + return; + } + ts.Debug.assert(fullEnd < changeStart); + } + } + function extendToAffectedRange(sourceFile, changeRange) { + var maxLookahead = 1; + var start = changeRange.span.start; + for (var i = 0; start > 0 && i <= maxLookahead; i++) { + var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start); + ts.Debug.assert(nearestNode.pos <= start); + var position = nearestNode.pos; + start = Math.max(0, position - 1); + } + var finalSpan = ts.createTextSpanFromBounds(start, ts.textSpanEnd(changeRange.span)); + var finalLength = changeRange.newLength + (changeRange.span.start - start); + return ts.createTextChangeRange(finalSpan, finalLength); + } + function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) { + var bestResult = sourceFile; + var lastNodeEntirelyBeforePosition; + forEachChild(sourceFile, visit); + if (lastNodeEntirelyBeforePosition) { + var lastChildOfLastEntireNodeBeforePosition = getLastChild(lastNodeEntirelyBeforePosition); + if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) { + bestResult = lastChildOfLastEntireNodeBeforePosition; + } + } + return bestResult; + function getLastChild(node) { + while (true) { + var lastChild = getLastChildWorker(node); + if (lastChild) { + node = lastChild; + } + else { + return node; + } + } + } + function getLastChildWorker(node) { + var last = undefined; + forEachChild(node, function (child) { + if (ts.nodeIsPresent(child)) { + last = child; + } + }); + return last; + } + function visit(child) { + if (ts.nodeIsMissing(child)) { + return; + } + if (child.pos <= position) { + if (child.pos >= bestResult.pos) { + bestResult = child; + } + if (position < child.end) { + forEachChild(child, visit); + return true; + } + else { + ts.Debug.assert(child.end <= position); + lastNodeEntirelyBeforePosition = child; + } + } + else { + ts.Debug.assert(child.pos > position); + return true; + } + } + } + function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) { + var oldText = sourceFile.text; + if (textChangeRange) { + ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length); + if (aggressiveChecks || ts.Debug.shouldAssert(3)) { + var oldTextPrefix = oldText.substr(0, textChangeRange.span.start); + var newTextPrefix = newText.substr(0, textChangeRange.span.start); + ts.Debug.assert(oldTextPrefix === newTextPrefix); + var oldTextSuffix = oldText.substring(ts.textSpanEnd(textChangeRange.span), oldText.length); + var newTextSuffix = newText.substring(ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)), newText.length); + ts.Debug.assert(oldTextSuffix === newTextSuffix); + } + } + } + function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { + aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2); + checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks); + if (ts.textChangeRangeIsUnchanged(textChangeRange)) { + return sourceFile; + } + if (sourceFile.statements.length === 0) { + return parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, undefined, true); + } + var incrementalSourceFile = sourceFile; + ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed); + incrementalSourceFile.hasBeenIncrementallyParsed = true; + var oldText = sourceFile.text; + var syntaxCursor = createSyntaxCursor(sourceFile); + var changeRange = extendToAffectedRange(sourceFile, textChangeRange); + checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks); + ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start); + ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span)); + ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange))); + var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length; + updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks); + var result = parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true); + return result; + } + ts.updateSourceFile = updateSourceFile; + function isEvalOrArgumentsIdentifier(node) { + return node.kind === 64 && + (node.text === "eval" || node.text === "arguments"); + } + ts.isEvalOrArgumentsIdentifier = isEvalOrArgumentsIdentifier; + function isUseStrictPrologueDirective(sourceFile, node) { + ts.Debug.assert(ts.isPrologueDirective(node)); + var nodeText = ts.getSourceTextOfNodeFromSourceFile(sourceFile, node.expression); + return nodeText === '"use strict"' || nodeText === "'use strict'"; + } + function createSyntaxCursor(sourceFile) { + var currentArray = sourceFile.statements; + var currentArrayIndex = 0; + ts.Debug.assert(currentArrayIndex < currentArray.length); + var current = currentArray[currentArrayIndex]; + var lastQueriedPosition = -1; + return { + currentNode: function (position) { + if (position !== lastQueriedPosition) { + if (current && current.end === position && currentArrayIndex < (currentArray.length - 1)) { + currentArrayIndex++; + current = currentArray[currentArrayIndex]; + } + if (!current || current.pos !== position) { + findHighestListElementThatStartsAtPosition(position); + } + } + lastQueriedPosition = position; + ts.Debug.assert(!current || current.pos === position); + return current; + } + }; + function findHighestListElementThatStartsAtPosition(position) { + currentArray = undefined; + currentArrayIndex = -1; + current = undefined; + forEachChild(sourceFile, visitNode, visitArray); + return; + function visitNode(node) { + if (position >= node.pos && position < node.end) { + forEachChild(node, visitNode, visitArray); + return true; + } + return false; + } + function visitArray(array) { + if (position >= array.pos && position < array.end) { + for (var i = 0, n = array.length; i < n; i++) { + var child = array[i]; + if (child) { + if (child.pos === position) { + currentArray = array; + currentArrayIndex = i; + current = child; + return true; + } + else { + if (child.pos < position && position < child.end) { + forEachChild(child, visitNode, visitArray); + return true; + } + } + } + } + } + return false; + } + } + } + function createSourceFile(fileName, sourceText, languageVersion, setParentNodes) { + if (setParentNodes === void 0) { setParentNodes = false; } + var start = new Date().getTime(); + var result = parseSourceFile(fileName, sourceText, languageVersion, undefined, setParentNodes); + ts.parseTime += new Date().getTime() - start; + return result; + } + ts.createSourceFile = createSourceFile; + function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes) { + if (setParentNodes === void 0) { setParentNodes = false; } + var parsingContext = 0; + var identifiers = {}; + var identifierCount = 0; + var nodeCount = 0; + var token; + var sourceFile = createNode(220, 0); + sourceFile.pos = 0; + sourceFile.end = sourceText.length; + sourceFile.text = sourceText; + sourceFile.parseDiagnostics = []; + sourceFile.bindDiagnostics = []; + sourceFile.languageVersion = languageVersion; + sourceFile.fileName = ts.normalizePath(fileName); + sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 1024 : 0; + var contextFlags = 0; + var parseErrorBeforeNextFinishedNode = false; + var scanner = ts.createScanner(languageVersion, true, sourceText, scanError); + token = nextToken(); + processReferenceComments(sourceFile); + sourceFile.statements = parseList(0, true, parseSourceElement); + ts.Debug.assert(token === 1); + sourceFile.endOfFileToken = parseTokenNode(); + setExternalModuleIndicator(sourceFile); + sourceFile.nodeCount = nodeCount; + sourceFile.identifierCount = identifierCount; + sourceFile.identifiers = identifiers; + if (setParentNodes) { + fixupParentReferences(sourceFile); + } + syntaxCursor = undefined; + return sourceFile; + function setContextFlag(val, flag) { + if (val) { + contextFlags |= flag; + } + else { + contextFlags &= ~flag; + } + } + function setStrictModeContext(val) { + setContextFlag(val, 1); + } + function setDisallowInContext(val) { + setContextFlag(val, 2); + } + function setYieldContext(val) { + setContextFlag(val, 4); + } + function setGeneratorParameterContext(val) { + setContextFlag(val, 8); + } + function allowInAnd(func) { + if (contextFlags & 2) { + setDisallowInContext(false); + var result = func(); + setDisallowInContext(true); + return result; + } + return func(); + } + function disallowInAnd(func) { + if (contextFlags & 2) { + return func(); + } + setDisallowInContext(true); + var result = func(); + setDisallowInContext(false); + return result; + } + function doInYieldContext(func) { + if (contextFlags & 4) { + return func(); + } + setYieldContext(true); + var result = func(); + setYieldContext(false); + return result; + } + function doOutsideOfYieldContext(func) { + if (contextFlags & 4) { + setYieldContext(false); + var result = func(); + setYieldContext(true); + return result; + } + return func(); + } + function inYieldContext() { + return (contextFlags & 4) !== 0; + } + function inStrictModeContext() { + return (contextFlags & 1) !== 0; + } + function inGeneratorParameterContext() { + return (contextFlags & 8) !== 0; + } + function inDisallowInContext() { + return (contextFlags & 2) !== 0; + } + function parseErrorAtCurrentToken(message, arg0) { + var start = scanner.getTokenPos(); + var length = scanner.getTextPos() - start; + parseErrorAtPosition(start, length, message, arg0); + } + function parseErrorAtPosition(start, length, message, arg0) { + var lastError = ts.lastOrUndefined(sourceFile.parseDiagnostics); + if (!lastError || start !== lastError.start) { + sourceFile.parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, start, length, message, arg0)); + } + parseErrorBeforeNextFinishedNode = true; + } + function scanError(message, length) { + var pos = scanner.getTextPos(); + parseErrorAtPosition(pos, length || 0, message); + } + function getNodePos() { + return scanner.getStartPos(); + } + function getNodeEnd() { + return scanner.getStartPos(); + } + function nextToken() { + return token = scanner.scan(); + } + function getTokenPos(pos) { + return ts.skipTrivia(sourceText, pos); + } + function reScanGreaterToken() { + return token = scanner.reScanGreaterToken(); + } + function reScanSlashToken() { + return token = scanner.reScanSlashToken(); + } + function reScanTemplateToken() { + return token = scanner.reScanTemplateToken(); + } + function speculationHelper(callback, isLookAhead) { + var saveToken = token; + var saveParseDiagnosticsLength = sourceFile.parseDiagnostics.length; + var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; + var saveContextFlags = contextFlags; + var result = isLookAhead ? scanner.lookAhead(callback) : scanner.tryScan(callback); + ts.Debug.assert(saveContextFlags === contextFlags); + if (!result || isLookAhead) { + token = saveToken; + sourceFile.parseDiagnostics.length = saveParseDiagnosticsLength; + parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode; + } + return result; + } + function lookAhead(callback) { + return speculationHelper(callback, true); + } + function tryParse(callback) { + return speculationHelper(callback, false); + } + function isIdentifier() { + if (token === 64) { + return true; + } + if (token === 111 && inYieldContext()) { + return false; + } + return inStrictModeContext() ? token > 111 : token > 100; + } + function parseExpected(kind, diagnosticMessage) { + if (token === kind) { + nextToken(); + return true; + } + if (diagnosticMessage) { + parseErrorAtCurrentToken(diagnosticMessage); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind)); + } + return false; + } + function parseOptional(t) { + if (token === t) { + nextToken(); + return true; + } + return false; + } + function parseOptionalToken(t) { + if (token === t) { + var node = createNode(t); + nextToken(); + return finishNode(node); + } + return undefined; + } + function parseTokenNode() { + var node = createNode(token); + nextToken(); + return finishNode(node); + } + function canParseSemicolon() { + if (token === 22) { + return true; + } + return token === 15 || token === 1 || scanner.hasPrecedingLineBreak(); + } + function parseSemicolon() { + if (canParseSemicolon()) { + if (token === 22) { + nextToken(); + } + return true; + } + else { + return parseExpected(22); + } + } + function createNode(kind, pos) { + nodeCount++; + var node = new (nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)))(); + if (!(pos >= 0)) { + pos = scanner.getStartPos(); + } + node.pos = pos; + node.end = pos; + return node; + } + function finishNode(node) { + node.end = scanner.getStartPos(); + if (contextFlags) { + node.parserContextFlags = contextFlags; + } + if (parseErrorBeforeNextFinishedNode) { + parseErrorBeforeNextFinishedNode = false; + node.parserContextFlags |= 16; + } + return node; + } + function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) { + if (reportAtCurrentPosition) { + parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0); + } + else { + parseErrorAtCurrentToken(diagnosticMessage, arg0); + } + var result = createNode(kind, scanner.getStartPos()); + result.text = ""; + return finishNode(result); + } + function internIdentifier(text) { + text = ts.escapeIdentifier(text); + return ts.hasProperty(identifiers, text) ? identifiers[text] : (identifiers[text] = text); + } + function createIdentifier(isIdentifier, diagnosticMessage) { + identifierCount++; + if (isIdentifier) { + var node = createNode(64); + node.text = internIdentifier(scanner.getTokenValue()); + nextToken(); + return finishNode(node); + } + return createMissingNode(64, false, diagnosticMessage || ts.Diagnostics.Identifier_expected); + } + function parseIdentifier(diagnosticMessage) { + return createIdentifier(isIdentifier(), diagnosticMessage); + } + function parseIdentifierName() { + return createIdentifier(isIdentifierOrKeyword()); + } + function isLiteralPropertyName() { + return isIdentifierOrKeyword() || + token === 8 || + token === 7; + } + function parsePropertyName() { + if (token === 8 || token === 7) { + return parseLiteralNode(true); + } + if (token === 18) { + return parseComputedPropertyName(); + } + return parseIdentifierName(); + } + function parseComputedPropertyName() { + var node = createNode(126); + parseExpected(18); + var yieldContext = inYieldContext(); + if (inGeneratorParameterContext()) { + setYieldContext(false); + } + node.expression = allowInAnd(parseExpression); + if (inGeneratorParameterContext()) { + setYieldContext(yieldContext); + } + parseExpected(19); + return finishNode(node); + } + function parseContextualModifier(t) { + return token === t && tryParse(nextTokenCanFollowModifier); + } + function nextTokenCanFollowModifier() { + nextToken(); + return canFollowModifier(); + } + function parseAnyContextualModifier() { + return ts.isModifier(token) && tryParse(nextTokenCanFollowContextualModifier); + } + function nextTokenCanFollowContextualModifier() { + if (token === 69) { + return nextToken() === 76; + } + if (token === 77) { + nextToken(); + return token !== 35 && token !== 14 && canFollowModifier(); + } + nextToken(); + return canFollowModifier(); + } + function canFollowModifier() { + return token === 18 || token === 14 || token === 35 || isLiteralPropertyName(); + } + function isListElement(parsingContext, inErrorRecovery) { + var node = currentNode(parsingContext); + if (node) { + return true; + } + switch (parsingContext) { + case 0: + case 1: + return isSourceElement(inErrorRecovery); + case 2: + case 4: + return isStartOfStatement(inErrorRecovery); + case 3: + return token === 66 || token === 72; + case 5: + return isStartOfTypeMember(); + case 6: + return lookAhead(isClassMemberStart); + case 7: + return token === 18 || isLiteralPropertyName(); + case 13: + return token === 18 || token === 35 || isLiteralPropertyName(); + case 10: + return isLiteralPropertyName(); + case 8: + return isIdentifier() && !isNotHeritageClauseTypeName(); + case 9: + return isIdentifierOrPattern(); + case 11: + return token === 23 || token === 21 || isIdentifierOrPattern(); + case 16: + return isIdentifier(); + case 12: + case 14: + return token === 23 || token === 21 || isStartOfExpression(); + case 15: + return isStartOfParameter(); + case 17: + case 18: + return token === 23 || isStartOfType(); + case 19: + return isHeritageClause(); + case 20: + return isIdentifierOrKeyword(); + } + ts.Debug.fail("Non-exhaustive case in 'isListElement'."); + } + function nextTokenIsIdentifier() { + nextToken(); + return isIdentifier(); + } + function isNotHeritageClauseTypeName() { + if (token === 103 || + token === 78) { + return lookAhead(nextTokenIsIdentifier); + } + return false; + } + function isListTerminator(kind) { + if (token === 1) { + return true; + } + switch (kind) { + case 1: + case 2: + case 3: + case 5: + case 6: + case 7: + case 13: + case 10: + case 20: + return token === 15; + case 4: + return token === 15 || token === 66 || token === 72; + case 8: + return token === 14 || token === 78 || token === 103; + case 9: + return isVariableDeclaratorListTerminator(); + case 16: + return token === 25 || token === 16 || token === 14 || token === 78 || token === 103; + 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 19: + return token === 14 || token === 15; + } + } + function isVariableDeclaratorListTerminator() { + if (canParseSemicolon()) { + return true; + } + if (isInOrOfKeyword(token)) { + return true; + } + if (token === 32) { + return true; + } + return false; + } + function isInSomeParsingContext() { + for (var kind = 0; kind < 21; kind++) { + if (parsingContext & (1 << kind)) { + if (isListElement(kind, true) || isListTerminator(kind)) { + return true; + } + } + } + return false; + } + function parseList(kind, checkForStrictMode, 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(sourceFile, element)) { + setStrictModeContext(true); + checkForStrictMode = false; + } + } + else { + checkForStrictMode = false; + } + } + continue; + } + if (abortParsingListOrMoveToNextToken(kind)) { + break; + } + } + setStrictModeContext(savedStrictModeContext); + result.end = getNodeEnd(); + parsingContext = saveParsingContext; + return result; + } + function parseListElement(parsingContext, parseElement) { + var node = currentNode(parsingContext); + if (node) { + return consumeNode(node); + } + return parseElement(); + } + function currentNode(parsingContext) { + if (parseErrorBeforeNextFinishedNode) { + return undefined; + } + if (!syntaxCursor) { + return undefined; + } + var node = syntaxCursor.currentNode(scanner.getStartPos()); + if (ts.nodeIsMissing(node)) { + return undefined; + } + if (node.intersectsChange) { + return undefined; + } + if (ts.containsParseError(node)) { + return undefined; + } + var nodeContextFlags = node.parserContextFlags & 31; + if (nodeContextFlags !== contextFlags) { + return undefined; + } + if (!canReuseNode(node, parsingContext)) { + return undefined; + } + return node; + } + function consumeNode(node) { + scanner.setTextPos(node.end); + nextToken(); + return node; + } + 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 isReusableTypeMember(node); + case 9: + return isReusableVariableDeclaration(node); + case 15: + return isReusableParameter(node); + case 19: + case 8: + case 16: + case 18: + case 17: + case 12: + case 13: + } + return false; + } + function isReusableModuleElement(node) { + if (node) { + switch (node.kind) { + case 203: + case 202: + case 209: + case 208: + case 196: + case 197: + case 200: + case 199: + return true; + } + return isReusableStatement(node); + } + return false; + } + function isReusableClassMember(node) { + if (node) { + switch (node.kind) { + case 133: + case 138: + case 132: + case 134: + case 135: + case 130: + return true; + } + } + return false; + } + function isReusableSwitchClause(node) { + if (node) { + switch (node.kind) { + case 213: + case 214: + return true; + } + } + return false; + } + function isReusableStatement(node) { + if (node) { + switch (node.kind) { + case 195: + case 175: + case 174: + case 178: + case 177: + case 190: + case 186: + case 188: + case 185: + case 184: + case 182: + case 183: + case 181: + case 180: + case 187: + case 176: + case 191: + case 189: + case 179: + case 192: + return true; + } + } + return false; + } + function isReusableEnumMember(node) { + return node.kind === 219; + } + function isReusableTypeMember(node) { + if (node) { + switch (node.kind) { + case 137: + case 131: + case 138: + case 129: + case 136: + return true; + } + } + return false; + } + function isReusableVariableDeclaration(node) { + if (node.kind !== 193) { + return false; + } + var variableDeclarator = node; + return variableDeclarator.initializer === undefined; + } + function isReusableParameter(node) { + if (node.kind !== 128) { + return false; + } + var parameter = node; + return parameter.initializer === undefined; + } + function abortParsingListOrMoveToNextToken(kind) { + parseErrorAtCurrentToken(parsingContextErrors(kind)); + if (isInSomeParsingContext()) { + return true; + } + nextToken(); + return false; + } + function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimeter) { + var saveParsingContext = parsingContext; + parsingContext |= 1 << kind; + var result = []; + result.pos = getNodePos(); + var commaStart = -1; + while (true) { + if (isListElement(kind, false)) { + result.push(parseListElement(kind, parseElement)); + commaStart = scanner.getTokenPos(); + if (parseOptional(23)) { + continue; + } + commaStart = -1; + if (isListTerminator(kind)) { + break; + } + parseExpected(23); + if (considerSemicolonAsDelimeter && token === 22 && !scanner.hasPrecedingLineBreak()) { + nextToken(); + } + continue; + } + if (isListTerminator(kind)) { + break; + } + if (abortParsingListOrMoveToNextToken(kind)) { + break; + } + } + if (commaStart >= 0) { + result.hasTrailingComma = true; + } + result.end = getNodeEnd(); + parsingContext = saveParsingContext; + return result; + } + function createMissingList() { + var pos = getNodePos(); + var result = []; + result.pos = pos; + result.end = pos; + return result; + } + function parseBracketedList(kind, parseElement, open, close) { + if (parseExpected(open)) { + var result = parseDelimitedList(kind, parseElement); + parseExpected(close); + return result; + } + return createMissingList(); + } + function parseEntityName(allowReservedWords, diagnosticMessage) { + var entity = parseIdentifier(diagnosticMessage); + while (parseOptional(20)) { + var node = createNode(125, entity.pos); + node.left = entity; + node.right = parseRightSideOfDot(allowReservedWords); + entity = finishNode(node); + } + return entity; + } + function parseRightSideOfDot(allowIdentifierNames) { + if (scanner.hasPrecedingLineBreak() && scanner.isReservedWord()) { + var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); + if (matchesPattern) { + return createMissingNode(64, true, ts.Diagnostics.Identifier_expected); + } + } + return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); + } + function parseTemplateExpression() { + var template = createNode(169); + template.head = parseLiteralNode(); + ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); + var templateSpans = []; + templateSpans.pos = getNodePos(); + do { + templateSpans.push(parseTemplateSpan()); + } while (templateSpans[templateSpans.length - 1].literal.kind === 12); + templateSpans.end = getNodeEnd(); + template.templateSpans = templateSpans; + return finishNode(template); + } + function parseTemplateSpan() { + var span = createNode(173); + span.expression = allowInAnd(parseExpression); + var literal; + if (token === 15) { + reScanTemplateToken(); + literal = parseLiteralNode(); + } + else { + literal = createMissingNode(13, false, ts.Diagnostics._0_expected, ts.tokenToString(15)); + } + span.literal = literal; + return finishNode(span); + } + function parseLiteralNode(internName) { + var node = createNode(token); + var text = scanner.getTokenValue(); + node.text = internName ? internIdentifier(text) : text; + if (scanner.isUnterminated()) { + node.isUnterminated = true; + } + var tokenPos = scanner.getTokenPos(); + nextToken(); + finishNode(node); + if (node.kind === 7 && sourceText.charCodeAt(tokenPos) === 48 && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) { + node.flags |= 8192; + } + return node; + } + function parseTypeReference() { + var node = createNode(139); + node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); + if (!scanner.hasPrecedingLineBreak() && token === 24) { + node.typeArguments = parseBracketedList(17, parseType, 24, 25); + } + return finishNode(node); + } + function parseTypeQuery() { + var node = createNode(142); + parseExpected(96); + node.exprName = parseEntityName(true); + return finishNode(node); + } + function parseTypeParameter() { + var node = createNode(127); + node.name = parseIdentifier(); + if (parseOptional(78)) { + if (isStartOfType() || !isStartOfExpression()) { + node.constraint = parseType(); + } + else { + node.expression = parseUnaryExpressionOrHigher(); + } + } + return finishNode(node); + } + function parseTypeParameters() { + if (token === 24) { + return parseBracketedList(16, parseTypeParameter, 24, 25); + } + } + function parseParameterType() { + if (parseOptional(51)) { + return token === 8 ? parseLiteralNode(true) : parseType(); + } + return undefined; + } + function isStartOfParameter() { + return token === 21 || isIdentifierOrPattern() || ts.isModifier(token); + } + function setModifiers(node, modifiers) { + if (modifiers) { + node.flags |= modifiers.flags; + node.modifiers = modifiers; + } + } + function parseParameter() { + var node = createNode(128); + setModifiers(node, parseModifiers()); + node.dotDotDotToken = parseOptionalToken(21); + node.name = inGeneratorParameterContext() ? doInYieldContext(parseIdentifierOrPattern) : parseIdentifierOrPattern(); + if (ts.getFullWidth(node.name) === 0 && node.flags === 0 && ts.isModifier(token)) { + nextToken(); + } + node.questionToken = parseOptionalToken(50); + node.type = parseParameterType(); + node.initializer = inGeneratorParameterContext() ? doOutsideOfYieldContext(parseParameterInitializer) : parseParameterInitializer(); + return finishNode(node); + } + function parseParameterInitializer() { + return parseInitializer(true); + } + function fillSignature(returnToken, yieldAndGeneratorParameterContext, requireCompleteParameterList, signature) { + var returnTokenRequired = returnToken === 32; + signature.typeParameters = parseTypeParameters(); + signature.parameters = parseParameterList(yieldAndGeneratorParameterContext, requireCompleteParameterList); + if (returnTokenRequired) { + parseExpected(returnToken); + signature.type = parseType(); + } + else if (parseOptional(returnToken)) { + signature.type = parseType(); + } + } + function parseParameterList(yieldAndGeneratorParameterContext, requireCompleteParameterList) { + if (parseExpected(16)) { + var savedYieldContext = inYieldContext(); + var savedGeneratorParameterContext = inGeneratorParameterContext(); + setYieldContext(yieldAndGeneratorParameterContext); + setGeneratorParameterContext(yieldAndGeneratorParameterContext); + var result = parseDelimitedList(15, parseParameter); + setYieldContext(savedYieldContext); + setGeneratorParameterContext(savedGeneratorParameterContext); + if (!parseExpected(17) && requireCompleteParameterList) { + return undefined; + } + return result; + } + return requireCompleteParameterList ? undefined : createMissingList(); + } + function parseTypeMemberSemicolon() { + if (parseOptional(23)) { + return; + } + parseSemicolon(); + } + function parseSignatureMember(kind) { + var node = createNode(kind); + if (kind === 137) { + parseExpected(87); + } + fillSignature(51, false, false, node); + parseTypeMemberSemicolon(); + return finishNode(node); + } + function isIndexSignature() { + if (token !== 18) { + return false; + } + return lookAhead(isUnambiguouslyIndexSignature); + } + function isUnambiguouslyIndexSignature() { + nextToken(); + if (token === 21 || token === 19) { + return true; + } + if (ts.isModifier(token)) { + nextToken(); + if (isIdentifier()) { + return true; + } + } + else if (!isIdentifier()) { + return false; + } + else { + nextToken(); + } + if (token === 51 || token === 23) { + return true; + } + if (token !== 50) { + return false; + } + nextToken(); + return token === 51 || token === 23 || token === 19; + } + function parseIndexSignatureDeclaration(modifiers) { + var fullStart = modifiers ? modifiers.pos : scanner.getStartPos(); + var node = createNode(138, fullStart); + setModifiers(node, modifiers); + node.parameters = parseBracketedList(15, parseParameter, 18, 19); + node.type = parseTypeAnnotation(); + parseTypeMemberSemicolon(); + return finishNode(node); + } + function parsePropertyOrMethodSignature() { + var fullStart = scanner.getStartPos(); + var name = parsePropertyName(); + var questionToken = parseOptionalToken(50); + if (token === 16 || token === 24) { + var method = createNode(131, fullStart); + method.name = name; + method.questionToken = questionToken; + fillSignature(51, false, false, method); + parseTypeMemberSemicolon(); + return finishNode(method); + } + else { + var property = createNode(129, fullStart); + property.name = name; + property.questionToken = questionToken; + property.type = parseTypeAnnotation(); + parseTypeMemberSemicolon(); + return finishNode(property); + } + } + function isStartOfTypeMember() { + switch (token) { + case 16: + case 24: + case 18: + return true; + default: + if (ts.isModifier(token)) { + var result = lookAhead(isStartOfIndexSignatureDeclaration); + if (result) { + return result; + } + } + return isLiteralPropertyName() && lookAhead(isTypeMemberWithLiteralPropertyName); + } + } + function isStartOfIndexSignatureDeclaration() { + while (ts.isModifier(token)) { + nextToken(); + } + return isIndexSignature(); + } + function isTypeMemberWithLiteralPropertyName() { + nextToken(); + return token === 16 || + token === 24 || + token === 50 || + token === 51 || + canParseSemicolon(); + } + function parseTypeMember() { + switch (token) { + case 16: + case 24: + return parseSignatureMember(136); + case 18: + return isIndexSignature() ? parseIndexSignatureDeclaration(undefined) : parsePropertyOrMethodSignature(); + case 87: + if (lookAhead(isStartOfConstructSignature)) { + return parseSignatureMember(137); + } + case 8: + case 7: + return parsePropertyOrMethodSignature(); + default: + if (ts.isModifier(token)) { + var result = tryParse(parseIndexSignatureWithModifiers); + if (result) { + return result; + } + } + if (isIdentifierOrKeyword()) { + return parsePropertyOrMethodSignature(); + } + } + } + function parseIndexSignatureWithModifiers() { + var modifiers = parseModifiers(); + return isIndexSignature() ? parseIndexSignatureDeclaration(modifiers) : undefined; + } + function isStartOfConstructSignature() { + nextToken(); + return token === 16 || token === 24; + } + function parseTypeLiteral() { + var node = createNode(143); + node.members = parseObjectTypeMembers(); + return finishNode(node); + } + function parseObjectTypeMembers() { + var members; + if (parseExpected(14)) { + members = parseList(5, false, parseTypeMember); + parseExpected(15); + } + else { + members = createMissingList(); + } + return members; + } + function parseTupleType() { + var node = createNode(145); + node.elementTypes = parseBracketedList(18, parseType, 18, 19); + return finishNode(node); + } + function parseParenthesizedType() { + var node = createNode(147); + parseExpected(16); + node.type = parseType(); + parseExpected(17); + return finishNode(node); + } + function parseFunctionOrConstructorType(kind) { + var node = createNode(kind); + if (kind === 141) { + parseExpected(87); + } + fillSignature(32, false, false, node); + return finishNode(node); + } + function parseKeywordAndNoDot() { + var node = parseTokenNode(); + return token === 20 ? undefined : node; + } + function parseNonArrayType() { + switch (token) { + case 112: + case 121: + case 119: + case 113: + case 122: + var node = tryParse(parseKeywordAndNoDot); + return node || parseTypeReference(); + case 98: + return parseTokenNode(); + case 96: + return parseTypeQuery(); + case 14: + return parseTypeLiteral(); + case 18: + return parseTupleType(); + case 16: + return parseParenthesizedType(); + default: + return parseTypeReference(); + } + } + function isStartOfType() { + switch (token) { + case 112: + case 121: + case 119: + case 113: + case 122: + case 98: + case 96: + case 14: + case 18: + case 24: + case 87: + return true; + case 16: + return lookAhead(isStartOfParenthesizedOrFunctionType); + default: + return isIdentifier(); + } + } + function isStartOfParenthesizedOrFunctionType() { + nextToken(); + return token === 17 || isStartOfParameter() || isStartOfType(); + } + function parseArrayTypeOrHigher() { + var type = parseNonArrayType(); + while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { + parseExpected(19); + var node = createNode(144, type.pos); + node.elementType = type; + type = finishNode(node); + } + return type; + } + function parseUnionTypeOrHigher() { + var type = parseArrayTypeOrHigher(); + if (token === 44) { + var types = [type]; + types.pos = type.pos; + while (parseOptional(44)) { + types.push(parseArrayTypeOrHigher()); + } + types.end = getNodeEnd(); + var node = createNode(146, type.pos); + node.types = types; + type = finishNode(node); + } + return type; + } + function isStartOfFunctionType() { + if (token === 24) { + return true; + } + return token === 16 && lookAhead(isUnambiguouslyStartOfFunctionType); + } + function isUnambiguouslyStartOfFunctionType() { + nextToken(); + if (token === 17 || token === 21) { + return true; + } + if (isIdentifier() || ts.isModifier(token)) { + nextToken(); + if (token === 51 || token === 23 || + token === 50 || token === 52 || + isIdentifier() || ts.isModifier(token)) { + return true; + } + if (token === 17) { + nextToken(); + if (token === 32) { + return true; + } + } + } + return false; + } + function parseType() { + var savedYieldContext = inYieldContext(); + var savedGeneratorParameterContext = inGeneratorParameterContext(); + setYieldContext(false); + setGeneratorParameterContext(false); + var result = parseTypeWorker(); + setYieldContext(savedYieldContext); + setGeneratorParameterContext(savedGeneratorParameterContext); + return result; + } + function parseTypeWorker() { + if (isStartOfFunctionType()) { + return parseFunctionOrConstructorType(140); + } + if (token === 87) { + return parseFunctionOrConstructorType(141); + } + return parseUnionTypeOrHigher(); + } + function parseTypeAnnotation() { + return parseOptional(51) ? parseType() : undefined; + } + function isStartOfExpression() { + switch (token) { + case 92: + case 90: + case 88: + case 94: + case 79: + case 7: + case 8: + case 10: + case 11: + case 16: + case 18: + case 14: + case 82: + case 87: + case 36: + case 56: + case 33: + case 34: + case 47: + case 46: + case 73: + case 96: + case 98: + case 38: + case 39: + case 24: + case 64: + case 111: + return true; + default: + if (isBinaryOperator()) { + return true; + } + return isIdentifier(); + } + } + function isStartOfExpressionStatement() { + return token !== 14 && token !== 82 && isStartOfExpression(); + } + function parseExpression() { + var expr = parseAssignmentExpressionOrHigher(); + var operatorToken; + while ((operatorToken = parseOptionalToken(23))) { + expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher()); + } + return expr; + } + function parseInitializer(inParameter) { + if (token !== 52) { + if (scanner.hasPrecedingLineBreak() || (inParameter && token === 14) || !isStartOfExpression()) { + return undefined; + } + } + parseExpected(52); + return parseAssignmentExpressionOrHigher(); + } + function parseAssignmentExpressionOrHigher() { + if (isYieldExpression()) { + return parseYieldExpression(); + } + var arrowExpression = tryParseParenthesizedArrowFunctionExpression(); + if (arrowExpression) { + return arrowExpression; + } + var expr = parseBinaryExpressionOrHigher(0); + if (expr.kind === 64 && token === 32) { + return parseSimpleArrowFunctionExpression(expr); + } + if (isLeftHandSideExpression(expr) && isAssignmentOperator(reScanGreaterToken())) { + return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher()); + } + return parseConditionalExpressionRest(expr); + } + function isYieldExpression() { + if (token === 111) { + if (inYieldContext()) { + return true; + } + if (inStrictModeContext()) { + return true; + } + return lookAhead(nextTokenIsIdentifierOnSameLine); + } + return false; + } + function nextTokenIsIdentifierOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && isIdentifier(); + } + function parseYieldExpression() { + var node = createNode(170); + nextToken(); + if (!scanner.hasPrecedingLineBreak() && + (token === 35 || isStartOfExpression())) { + node.asteriskToken = parseOptionalToken(35); + node.expression = parseAssignmentExpressionOrHigher(); + return finishNode(node); + } + else { + return finishNode(node); + } + } + function parseSimpleArrowFunctionExpression(identifier) { + ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); + var node = createNode(161, identifier.pos); + var parameter = createNode(128, identifier.pos); + parameter.name = identifier; + finishNode(parameter); + node.parameters = [parameter]; + node.parameters.pos = parameter.pos; + node.parameters.end = parameter.end; + parseExpected(32); + node.body = parseArrowFunctionExpressionBody(); + return finishNode(node); + } + function tryParseParenthesizedArrowFunctionExpression() { + var triState = isParenthesizedArrowFunctionExpression(); + if (triState === 0) { + return undefined; + } + var arrowFunction = triState === 1 ? parseParenthesizedArrowFunctionExpressionHead(true) : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead); + if (!arrowFunction) { + return undefined; + } + if (parseExpected(32) || token === 14) { + arrowFunction.body = parseArrowFunctionExpressionBody(); + } + else { + arrowFunction.body = parseIdentifier(); + } + return finishNode(arrowFunction); + } + function isParenthesizedArrowFunctionExpression() { + if (token === 16 || token === 24) { + return lookAhead(isParenthesizedArrowFunctionExpressionWorker); + } + if (token === 32) { + return 1; + } + return 0; + } + function isParenthesizedArrowFunctionExpressionWorker() { + var first = token; + var second = nextToken(); + if (first === 16) { + if (second === 17) { + var third = nextToken(); + switch (third) { + case 32: + case 51: + case 14: + return 1; + default: + return 0; + } + } + if (second === 21) { + return 1; + } + if (!isIdentifier()) { + return 0; + } + if (nextToken() === 51) { + return 1; + } + return 2; + } + else { + ts.Debug.assert(first === 24); + if (!isIdentifier()) { + return 0; + } + return 2; + } + } + function parsePossibleParenthesizedArrowFunctionExpressionHead() { + return parseParenthesizedArrowFunctionExpressionHead(false); + } + function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { + var node = createNode(161); + fillSignature(51, false, !allowAmbiguity, node); + if (!node.parameters) { + return undefined; + } + if (!allowAmbiguity && token !== 32 && token !== 14) { + return undefined; + } + return node; + } + function parseArrowFunctionExpressionBody() { + if (token === 14) { + return parseFunctionBlock(false, false); + } + if (isStartOfStatement(true) && !isStartOfExpressionStatement() && token !== 82) { + return parseFunctionBlock(false, true); + } + return parseAssignmentExpressionOrHigher(); + } + function parseConditionalExpressionRest(leftOperand) { + if (!parseOptional(50)) { + return leftOperand; + } + var node = createNode(168, leftOperand.pos); + node.condition = leftOperand; + node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher); + parseExpected(51); + node.whenFalse = parseAssignmentExpressionOrHigher(); + return finishNode(node); + } + function parseBinaryExpressionOrHigher(precedence) { + var leftOperand = parseUnaryExpressionOrHigher(); + return parseBinaryExpressionRest(precedence, leftOperand); + } + function isInOrOfKeyword(t) { + return t === 85 || t === 124; + } + function parseBinaryExpressionRest(precedence, leftOperand) { + while (true) { + reScanGreaterToken(); + var newPrecedence = getBinaryOperatorPrecedence(); + if (newPrecedence <= precedence) { + break; + } + if (token === 85 && inDisallowInContext()) { + break; + } + leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence)); + } + return leftOperand; + } + function isBinaryOperator() { + if (inDisallowInContext() && token === 85) { + return false; + } + return getBinaryOperatorPrecedence() > 0; + } + function getBinaryOperatorPrecedence() { + switch (token) { + case 49: + return 1; + case 48: + return 2; + case 44: + return 3; + case 45: + return 4; + case 43: + return 5; + case 28: + case 29: + case 30: + case 31: + return 6; + case 24: + case 25: + case 26: + case 27: + case 86: + case 85: + return 7; + case 40: + case 41: + case 42: + return 8; + case 33: + case 34: + return 9; + case 35: + case 36: + case 37: + return 10; + } + return -1; + } + function makeBinaryExpression(left, operatorToken, right) { + var node = createNode(167, left.pos); + node.left = left; + node.operatorToken = operatorToken; + node.right = right; + return finishNode(node); + } + function parsePrefixUnaryExpression() { + var node = createNode(165); + node.operator = token; + nextToken(); + node.operand = parseUnaryExpressionOrHigher(); + return finishNode(node); + } + function parseDeleteExpression() { + var node = createNode(162); + nextToken(); + node.expression = parseUnaryExpressionOrHigher(); + return finishNode(node); + } + function parseTypeOfExpression() { + var node = createNode(163); + nextToken(); + node.expression = parseUnaryExpressionOrHigher(); + return finishNode(node); + } + function parseVoidExpression() { + var node = createNode(164); + nextToken(); + node.expression = parseUnaryExpressionOrHigher(); + return finishNode(node); + } + function parseUnaryExpressionOrHigher() { + switch (token) { + case 33: + case 34: + case 47: + case 46: + case 38: + case 39: + return parsePrefixUnaryExpression(); + case 73: + return parseDeleteExpression(); + case 96: + return parseTypeOfExpression(); + case 98: + return parseVoidExpression(); + case 24: + return parseTypeAssertion(); + default: + return parsePostfixExpressionOrHigher(); + } + } + function parsePostfixExpressionOrHigher() { + var expression = parseLeftHandSideExpressionOrHigher(); + ts.Debug.assert(isLeftHandSideExpression(expression)); + if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { + var node = createNode(166, expression.pos); + node.operand = expression; + node.operator = token; + nextToken(); + return finishNode(node); + } + return expression; + } + function parseLeftHandSideExpressionOrHigher() { + var expression = token === 90 ? parseSuperExpression() : parseMemberExpressionOrHigher(); + return parseCallExpressionRest(expression); + } + function parseMemberExpressionOrHigher() { + var expression = parsePrimaryExpression(); + return parseMemberExpressionRest(expression); + } + function parseSuperExpression() { + var expression = parseTokenNode(); + if (token === 16 || token === 20) { + return expression; + } + var node = createNode(153, expression.pos); + node.expression = expression; + parseExpected(20, 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(158); + parseExpected(24); + node.type = parseType(); + parseExpected(25); + node.expression = parseUnaryExpressionOrHigher(); + return finishNode(node); + } + function parseMemberExpressionRest(expression) { + while (true) { + var dotOrBracketStart = scanner.getTokenPos(); + if (parseOptional(20)) { + var propertyAccess = createNode(153, expression.pos); + propertyAccess.expression = expression; + propertyAccess.name = parseRightSideOfDot(true); + expression = finishNode(propertyAccess); + continue; + } + if (parseOptional(18)) { + var indexedAccess = createNode(154, expression.pos); + indexedAccess.expression = expression; + if (token !== 19) { + indexedAccess.argumentExpression = allowInAnd(parseExpression); + if (indexedAccess.argumentExpression.kind === 8 || indexedAccess.argumentExpression.kind === 7) { + var literal = indexedAccess.argumentExpression; + literal.text = internIdentifier(literal.text); + } + } + parseExpected(19); + expression = finishNode(indexedAccess); + continue; + } + if (token === 10 || token === 11) { + var tagExpression = createNode(157, expression.pos); + tagExpression.tag = expression; + tagExpression.template = token === 10 ? parseLiteralNode() : parseTemplateExpression(); + expression = finishNode(tagExpression); + continue; + } + return expression; + } + } + function parseCallExpressionRest(expression) { + while (true) { + expression = parseMemberExpressionRest(expression); + if (token === 24) { + var typeArguments = tryParse(parseTypeArgumentsInExpression); + if (!typeArguments) { + return expression; + } + var callExpr = createNode(155, expression.pos); + callExpr.expression = expression; + callExpr.typeArguments = typeArguments; + callExpr.arguments = parseArgumentList(); + expression = finishNode(callExpr); + continue; + } + else if (token === 16) { + var callExpr = createNode(155, expression.pos); + callExpr.expression = expression; + callExpr.arguments = parseArgumentList(); + expression = finishNode(callExpr); + continue; + } + return expression; + } + } + function parseArgumentList() { + parseExpected(16); + var result = parseDelimitedList(12, parseArgumentExpression); + parseExpected(17); + return result; + } + function parseTypeArgumentsInExpression() { + if (!parseOptional(24)) { + return undefined; + } + var typeArguments = parseDelimitedList(17, parseType); + if (!parseExpected(25)) { + return undefined; + } + return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined; + } + function canFollowTypeArgumentsInExpression() { + switch (token) { + case 16: + case 20: + case 17: + case 19: + case 51: + case 22: + case 23: + case 50: + case 28: + case 30: + case 29: + case 31: + case 48: + case 49: + case 45: + case 43: + case 44: + case 15: + case 1: + return true; + default: + return false; + } + } + function parsePrimaryExpression() { + switch (token) { + case 7: + case 8: + case 10: + return parseLiteralNode(); + case 92: + case 90: + case 88: + case 94: + case 79: + return parseTokenNode(); + case 16: + return parseParenthesizedExpression(); + case 18: + return parseArrayLiteralExpression(); + case 14: + return parseObjectLiteralExpression(); + case 82: + return parseFunctionExpression(); + case 87: + return parseNewExpression(); + case 36: + case 56: + if (reScanSlashToken() === 9) { + return parseLiteralNode(); + } + break; + case 11: + return parseTemplateExpression(); + } + return parseIdentifier(ts.Diagnostics.Expression_expected); + } + function parseParenthesizedExpression() { + var node = createNode(159); + parseExpected(16); + node.expression = allowInAnd(parseExpression); + parseExpected(17); + return finishNode(node); + } + function parseSpreadElement() { + var node = createNode(171); + parseExpected(21); + node.expression = parseAssignmentExpressionOrHigher(); + return finishNode(node); + } + function parseArgumentOrArrayLiteralElement() { + return token === 21 ? parseSpreadElement() : token === 23 ? createNode(172) : parseAssignmentExpressionOrHigher(); + } + function parseArgumentExpression() { + return allowInAnd(parseArgumentOrArrayLiteralElement); + } + function parseArrayLiteralExpression() { + var node = createNode(151); + parseExpected(18); + if (scanner.hasPrecedingLineBreak()) + node.flags |= 256; + node.elements = parseDelimitedList(14, parseArgumentOrArrayLiteralElement); + parseExpected(19); + return finishNode(node); + } + function tryParseAccessorDeclaration(fullStart, modifiers) { + if (parseContextualModifier(116)) { + return parseAccessorDeclaration(134, fullStart, modifiers); + } + else if (parseContextualModifier(120)) { + return parseAccessorDeclaration(135, fullStart, modifiers); + } + return undefined; + } + function parseObjectLiteralElement() { + var fullStart = scanner.getStartPos(); + var modifiers = parseModifiers(); + var accessor = tryParseAccessorDeclaration(fullStart, modifiers); + if (accessor) { + return accessor; + } + var asteriskToken = parseOptionalToken(35); + var tokenIsIdentifier = isIdentifier(); + var nameToken = token; + var propertyName = parsePropertyName(); + var questionToken = parseOptionalToken(50); + if (asteriskToken || token === 16 || token === 24) { + return parseMethodDeclaration(fullStart, modifiers, asteriskToken, propertyName, questionToken); + } + if ((token === 23 || token === 15) && tokenIsIdentifier) { + var shorthandDeclaration = createNode(218, fullStart); + shorthandDeclaration.name = propertyName; + shorthandDeclaration.questionToken = questionToken; + return finishNode(shorthandDeclaration); + } + else { + var propertyAssignment = createNode(217, fullStart); + propertyAssignment.name = propertyName; + propertyAssignment.questionToken = questionToken; + parseExpected(51); + propertyAssignment.initializer = allowInAnd(parseAssignmentExpressionOrHigher); + return finishNode(propertyAssignment); + } + } + function parseObjectLiteralExpression() { + var node = createNode(152); + parseExpected(14); + if (scanner.hasPrecedingLineBreak()) { + node.flags |= 256; + } + node.properties = parseDelimitedList(13, parseObjectLiteralElement, true); + parseExpected(15); + return finishNode(node); + } + function parseFunctionExpression() { + var node = createNode(160); + parseExpected(82); + node.asteriskToken = parseOptionalToken(35); + node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); + fillSignature(51, !!node.asteriskToken, false, node); + node.body = parseFunctionBlock(!!node.asteriskToken, false); + return finishNode(node); + } + function parseOptionalIdentifier() { + return isIdentifier() ? parseIdentifier() : undefined; + } + function parseNewExpression() { + var node = createNode(156); + parseExpected(87); + node.expression = parseMemberExpressionOrHigher(); + node.typeArguments = tryParse(parseTypeArgumentsInExpression); + if (node.typeArguments || token === 16) { + node.arguments = parseArgumentList(); + } + return finishNode(node); + } + function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { + var node = createNode(174); + if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { + node.statements = parseList(2, checkForStrictMode, parseStatement); + parseExpected(15); + } + else { + node.statements = createMissingList(); + } + return finishNode(node); + } + function parseFunctionBlock(allowYield, ignoreMissingOpenBrace, diagnosticMessage) { + var savedYieldContext = inYieldContext(); + setYieldContext(allowYield); + var block = parseBlock(ignoreMissingOpenBrace, true, diagnosticMessage); + setYieldContext(savedYieldContext); + return block; + } + function parseEmptyStatement() { + var node = createNode(176); + parseExpected(22); + return finishNode(node); + } + function parseIfStatement() { + var node = createNode(178); + parseExpected(83); + parseExpected(16); + node.expression = allowInAnd(parseExpression); + parseExpected(17); + node.thenStatement = parseStatement(); + node.elseStatement = parseOptional(75) ? parseStatement() : undefined; + return finishNode(node); + } + function parseDoStatement() { + var node = createNode(179); + parseExpected(74); + node.statement = parseStatement(); + parseExpected(99); + parseExpected(16); + node.expression = allowInAnd(parseExpression); + parseExpected(17); + parseOptional(22); + return finishNode(node); + } + function parseWhileStatement() { + var node = createNode(180); + parseExpected(99); + parseExpected(16); + node.expression = allowInAnd(parseExpression); + parseExpected(17); + node.statement = parseStatement(); + return finishNode(node); + } + function parseForOrForInOrForOfStatement() { + var pos = getNodePos(); + parseExpected(81); + parseExpected(16); + var initializer = undefined; + if (token !== 22) { + if (token === 97 || token === 105 || token === 69) { + initializer = parseVariableDeclarationList(true); + } + else { + initializer = disallowInAnd(parseExpression); + } + } + var forOrForInOrForOfStatement; + if (parseOptional(85)) { + var forInStatement = createNode(182, pos); + forInStatement.initializer = initializer; + forInStatement.expression = allowInAnd(parseExpression); + parseExpected(17); + forOrForInOrForOfStatement = forInStatement; + } + else if (parseOptional(124)) { + var forOfStatement = createNode(183, pos); + forOfStatement.initializer = initializer; + forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); + parseExpected(17); + forOrForInOrForOfStatement = forOfStatement; + } + else { + var forStatement = createNode(181, pos); + forStatement.initializer = initializer; + parseExpected(22); + if (token !== 22 && token !== 17) { + forStatement.condition = allowInAnd(parseExpression); + } + parseExpected(22); + if (token !== 17) { + forStatement.iterator = allowInAnd(parseExpression); + } + parseExpected(17); + forOrForInOrForOfStatement = forStatement; + } + forOrForInOrForOfStatement.statement = parseStatement(); + return finishNode(forOrForInOrForOfStatement); + } + function parseBreakOrContinueStatement(kind) { + var node = createNode(kind); + parseExpected(kind === 185 ? 65 : 70); + if (!canParseSemicolon()) { + node.label = parseIdentifier(); + } + parseSemicolon(); + return finishNode(node); + } + function parseReturnStatement() { + var node = createNode(186); + parseExpected(89); + if (!canParseSemicolon()) { + node.expression = allowInAnd(parseExpression); + } + parseSemicolon(); + return finishNode(node); + } + function parseWithStatement() { + var node = createNode(187); + parseExpected(100); + parseExpected(16); + node.expression = allowInAnd(parseExpression); + parseExpected(17); + node.statement = parseStatement(); + return finishNode(node); + } + function parseCaseClause() { + var node = createNode(213); + parseExpected(66); + node.expression = allowInAnd(parseExpression); + parseExpected(51); + node.statements = parseList(4, false, parseStatement); + return finishNode(node); + } + function parseDefaultClause() { + var node = createNode(214); + parseExpected(72); + parseExpected(51); + node.statements = parseList(4, false, parseStatement); + return finishNode(node); + } + function parseCaseOrDefaultClause() { + return token === 66 ? parseCaseClause() : parseDefaultClause(); + } + function parseSwitchStatement() { + var node = createNode(188); + parseExpected(91); + parseExpected(16); + node.expression = allowInAnd(parseExpression); + parseExpected(17); + parseExpected(14); + node.clauses = parseList(3, false, parseCaseOrDefaultClause); + parseExpected(15); + return finishNode(node); + } + function parseThrowStatement() { + var node = createNode(190); + parseExpected(93); + node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); + parseSemicolon(); + return finishNode(node); + } + function parseTryStatement() { + var node = createNode(191); + parseExpected(95); + node.tryBlock = parseBlock(false, false); + node.catchClause = token === 67 ? parseCatchClause() : undefined; + if (!node.catchClause || token === 80) { + parseExpected(80); + node.finallyBlock = parseBlock(false, false); + } + return finishNode(node); + } + function parseCatchClause() { + var result = createNode(216); + parseExpected(67); + parseExpected(16); + result.name = parseIdentifier(); + result.type = parseTypeAnnotation(); + parseExpected(17); + result.block = parseBlock(false, false); + return finishNode(result); + } + function parseDebuggerStatement() { + var node = createNode(192); + parseExpected(71); + parseSemicolon(); + return finishNode(node); + } + function parseExpressionOrLabeledStatement() { + var fullStart = scanner.getStartPos(); + var expression = allowInAnd(parseExpression); + if (expression.kind === 64 && parseOptional(51)) { + var labeledStatement = createNode(189, fullStart); + labeledStatement.label = expression; + labeledStatement.statement = parseStatement(); + return finishNode(labeledStatement); + } + else { + var expressionStatement = createNode(177, fullStart); + expressionStatement.expression = expression; + parseSemicolon(); + return finishNode(expressionStatement); + } + } + function isStartOfStatement(inErrorRecovery) { + if (ts.isModifier(token)) { + var result = lookAhead(parseVariableStatementOrFunctionDeclarationWithModifiers); + if (result) { + return true; + } + } + switch (token) { + case 22: + return !inErrorRecovery; + case 14: + case 97: + case 105: + case 82: + case 83: + case 74: + case 99: + case 81: + case 70: + case 65: + case 89: + case 100: + case 91: + case 93: + case 95: + case 71: + case 67: + case 80: + return true; + case 69: + var isConstEnum = lookAhead(nextTokenIsEnumKeyword); + return !isConstEnum; + case 104: + case 68: + case 117: + case 76: + case 123: + if (isDeclarationStart()) { + return false; + } + case 109: + case 107: + case 108: + case 110: + if (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine)) { + return false; + } + default: + return isStartOfExpression(); + } + } + function nextTokenIsEnumKeyword() { + nextToken(); + return token === 76; + } + function nextTokenIsIdentifierOrKeywordOnSameLine() { + nextToken(); + return isIdentifierOrKeyword() && !scanner.hasPrecedingLineBreak(); + } + function parseStatement() { + switch (token) { + case 14: + return parseBlock(false, false); + case 97: + case 69: + return parseVariableStatement(scanner.getStartPos(), undefined); + case 82: + return parseFunctionDeclaration(scanner.getStartPos(), undefined); + case 22: + return parseEmptyStatement(); + case 83: + return parseIfStatement(); + case 74: + return parseDoStatement(); + case 99: + return parseWhileStatement(); + case 81: + return parseForOrForInOrForOfStatement(); + case 70: + return parseBreakOrContinueStatement(184); + case 65: + return parseBreakOrContinueStatement(185); + case 89: + return parseReturnStatement(); + case 100: + return parseWithStatement(); + case 91: + return parseSwitchStatement(); + case 93: + return parseThrowStatement(); + case 95: + case 67: + case 80: + return parseTryStatement(); + case 71: + return parseDebuggerStatement(); + case 105: + if (isLetDeclaration()) { + return parseVariableStatement(scanner.getStartPos(), undefined); + } + default: + if (ts.isModifier(token)) { + var result = tryParse(parseVariableStatementOrFunctionDeclarationWithModifiers); + if (result) { + return result; + } + } + return parseExpressionOrLabeledStatement(); + } + } + function parseVariableStatementOrFunctionDeclarationWithModifiers() { + var start = scanner.getStartPos(); + var modifiers = parseModifiers(); + switch (token) { + case 69: + var nextTokenIsEnum = lookAhead(nextTokenIsEnumKeyword); + if (nextTokenIsEnum) { + return undefined; + } + return parseVariableStatement(start, modifiers); + case 105: + if (!isLetDeclaration()) { + return undefined; + } + return parseVariableStatement(start, modifiers); + case 97: + return parseVariableStatement(start, modifiers); + case 82: + return parseFunctionDeclaration(start, modifiers); + } + return undefined; + } + function parseFunctionBlockOrSemicolon(isGenerator, diagnosticMessage) { + if (token !== 14 && canParseSemicolon()) { + parseSemicolon(); + return; + } + return parseFunctionBlock(isGenerator, false, diagnosticMessage); + } + function parseArrayBindingElement() { + if (token === 23) { + return createNode(172); + } + var node = createNode(150); + node.dotDotDotToken = parseOptionalToken(21); + node.name = parseIdentifierOrPattern(); + node.initializer = parseInitializer(false); + return finishNode(node); + } + function parseObjectBindingElement() { + var node = createNode(150); + var id = parsePropertyName(); + if (id.kind === 64 && token !== 51) { + node.name = id; + } + else { + parseExpected(51); + node.propertyName = id; + node.name = parseIdentifierOrPattern(); + } + node.initializer = parseInitializer(false); + return finishNode(node); + } + function parseObjectBindingPattern() { + var node = createNode(148); + parseExpected(14); + node.elements = parseDelimitedList(10, parseObjectBindingElement); + parseExpected(15); + return finishNode(node); + } + function parseArrayBindingPattern() { + var node = createNode(149); + parseExpected(18); + node.elements = parseDelimitedList(11, parseArrayBindingElement); + parseExpected(19); + return finishNode(node); + } + function isIdentifierOrPattern() { + return token === 14 || token === 18 || isIdentifier(); + } + function parseIdentifierOrPattern() { + if (token === 18) { + return parseArrayBindingPattern(); + } + if (token === 14) { + return parseObjectBindingPattern(); + } + return parseIdentifier(); + } + function parseVariableDeclaration() { + var node = createNode(193); + node.name = parseIdentifierOrPattern(); + node.type = parseTypeAnnotation(); + if (!isInOrOfKeyword(token)) { + node.initializer = parseInitializer(false); + } + return finishNode(node); + } + function parseVariableDeclarationList(inForStatementInitializer) { + var node = createNode(194); + switch (token) { + case 97: + break; + case 105: + node.flags |= 2048; + break; + case 69: + node.flags |= 4096; + break; + default: + ts.Debug.fail(); + } + nextToken(); + if (token === 124 && lookAhead(canFollowContextualOfKeyword)) { + node.declarations = createMissingList(); + } + else { + var savedDisallowIn = inDisallowInContext(); + setDisallowInContext(inForStatementInitializer); + node.declarations = parseDelimitedList(9, parseVariableDeclaration); + setDisallowInContext(savedDisallowIn); + } + return finishNode(node); + } + function canFollowContextualOfKeyword() { + return nextTokenIsIdentifier() && nextToken() === 17; + } + function parseVariableStatement(fullStart, modifiers) { + var node = createNode(175, fullStart); + setModifiers(node, modifiers); + node.declarationList = parseVariableDeclarationList(false); + parseSemicolon(); + return finishNode(node); + } + function parseFunctionDeclaration(fullStart, modifiers) { + var node = createNode(195, fullStart); + setModifiers(node, modifiers); + parseExpected(82); + node.asteriskToken = parseOptionalToken(35); + node.name = parseIdentifier(); + fillSignature(51, !!node.asteriskToken, false, node); + node.body = parseFunctionBlockOrSemicolon(!!node.asteriskToken, ts.Diagnostics.or_expected); + return finishNode(node); + } + function parseConstructorDeclaration(pos, modifiers) { + var node = createNode(133, pos); + setModifiers(node, modifiers); + parseExpected(114); + fillSignature(51, false, false, node); + node.body = parseFunctionBlockOrSemicolon(false, ts.Diagnostics.or_expected); + return finishNode(node); + } + function parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { + var method = createNode(132, fullStart); + setModifiers(method, modifiers); + method.asteriskToken = asteriskToken; + method.name = name; + method.questionToken = questionToken; + fillSignature(51, !!asteriskToken, false, method); + method.body = parseFunctionBlockOrSemicolon(!!asteriskToken, diagnosticMessage); + return finishNode(method); + } + function parsePropertyOrMethodDeclaration(fullStart, modifiers) { + var asteriskToken = parseOptionalToken(35); + var name = parsePropertyName(); + var questionToken = parseOptionalToken(50); + if (asteriskToken || token === 16 || token === 24) { + return parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected); + } + else { + var property = createNode(130, fullStart); + setModifiers(property, modifiers); + property.name = name; + property.questionToken = questionToken; + property.type = parseTypeAnnotation(); + property.initializer = allowInAnd(parseNonParameterInitializer); + parseSemicolon(); + return finishNode(property); + } + } + function parseNonParameterInitializer() { + return parseInitializer(false); + } + function parseAccessorDeclaration(kind, fullStart, modifiers) { + var node = createNode(kind, fullStart); + setModifiers(node, modifiers); + node.name = parsePropertyName(); + fillSignature(51, false, false, node); + node.body = parseFunctionBlockOrSemicolon(false); + return finishNode(node); + } + function isClassMemberStart() { + var idToken; + while (ts.isModifier(token)) { + idToken = token; + nextToken(); + } + if (token === 35) { + return true; + } + if (isLiteralPropertyName()) { + idToken = token; + nextToken(); + } + if (token === 18) { + return true; + } + if (idToken !== undefined) { + if (!ts.isKeyword(idToken) || idToken === 120 || idToken === 116) { + return true; + } + switch (token) { + case 16: + case 24: + case 51: + case 52: + case 50: + return true; + default: + return canParseSemicolon(); + } + } + return false; + } + function parseModifiers() { + var flags = 0; + var modifiers; + while (true) { + var modifierStart = scanner.getStartPos(); + var modifierKind = token; + if (!parseAnyContextualModifier()) { + break; + } + if (!modifiers) { + modifiers = []; + modifiers.pos = modifierStart; + } + flags |= modifierToFlag(modifierKind); + modifiers.push(finishNode(createNode(modifierKind, modifierStart))); + } + if (modifiers) { + modifiers.flags = flags; + modifiers.end = scanner.getStartPos(); + } + return modifiers; + } + function parseClassElement() { + var fullStart = getNodePos(); + var modifiers = parseModifiers(); + var accessor = tryParseAccessorDeclaration(fullStart, modifiers); + if (accessor) { + return accessor; + } + if (token === 114) { + return parseConstructorDeclaration(fullStart, modifiers); + } + if (isIndexSignature()) { + return parseIndexSignatureDeclaration(modifiers); + } + if (isIdentifierOrKeyword() || + token === 8 || + token === 7 || + token === 35 || + token === 18) { + return parsePropertyOrMethodDeclaration(fullStart, modifiers); + } + ts.Debug.fail("Should not have attempted to parse class member declaration."); + } + function parseClassDeclaration(fullStart, modifiers) { + var node = createNode(196, fullStart); + setModifiers(node, modifiers); + parseExpected(68); + node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); + node.heritageClauses = parseHeritageClauses(true); + if (parseExpected(14)) { + node.members = inGeneratorParameterContext() ? doOutsideOfYieldContext(parseClassMembers) : parseClassMembers(); + parseExpected(15); + } + else { + node.members = createMissingList(); + } + return finishNode(node); + } + function parseHeritageClauses(isClassHeritageClause) { + if (isHeritageClause()) { + return isClassHeritageClause && inGeneratorParameterContext() ? doOutsideOfYieldContext(parseHeritageClausesWorker) : parseHeritageClausesWorker(); + } + return undefined; + } + function parseHeritageClausesWorker() { + return parseList(19, false, parseHeritageClause); + } + function parseHeritageClause() { + if (token === 78 || token === 103) { + var node = createNode(215); + node.token = token; + nextToken(); + node.types = parseDelimitedList(8, parseTypeReference); + return finishNode(node); + } + return undefined; + } + function isHeritageClause() { + return token === 78 || token === 103; + } + function parseClassMembers() { + return parseList(6, false, parseClassElement); + } + function parseInterfaceDeclaration(fullStart, modifiers) { + var node = createNode(197, fullStart); + setModifiers(node, modifiers); + parseExpected(104); + node.name = parseIdentifier(); + node.typeParameters = parseTypeParameters(); + node.heritageClauses = parseHeritageClauses(false); + node.members = parseObjectTypeMembers(); + return finishNode(node); + } + function parseTypeAliasDeclaration(fullStart, modifiers) { + var node = createNode(198, fullStart); + setModifiers(node, modifiers); + parseExpected(123); + node.name = parseIdentifier(); + parseExpected(52); + node.type = parseType(); + parseSemicolon(); + return finishNode(node); + } + function parseEnumMember() { + var node = createNode(219, scanner.getStartPos()); + node.name = parsePropertyName(); + node.initializer = allowInAnd(parseNonParameterInitializer); + return finishNode(node); + } + function parseEnumDeclaration(fullStart, modifiers) { + var node = createNode(199, fullStart); + setModifiers(node, modifiers); + parseExpected(76); + node.name = parseIdentifier(); + if (parseExpected(14)) { + node.members = parseDelimitedList(7, parseEnumMember); + parseExpected(15); + } + else { + node.members = createMissingList(); + } + return finishNode(node); + } + function parseModuleBlock() { + var node = createNode(201, scanner.getStartPos()); + if (parseExpected(14)) { + node.statements = parseList(1, false, parseModuleElement); + parseExpected(15); + } + else { + node.statements = createMissingList(); + } + return finishNode(node); + } + function parseInternalModuleTail(fullStart, modifiers, flags) { + var node = createNode(200, fullStart); + setModifiers(node, modifiers); + node.flags |= flags; + node.name = parseIdentifier(); + node.body = parseOptional(20) ? parseInternalModuleTail(getNodePos(), undefined, 1) : parseModuleBlock(); + return finishNode(node); + } + function parseAmbientExternalModuleDeclaration(fullStart, modifiers) { + var node = createNode(200, fullStart); + setModifiers(node, modifiers); + node.name = parseLiteralNode(true); + node.body = parseModuleBlock(); + return finishNode(node); + } + function parseModuleDeclaration(fullStart, modifiers) { + parseExpected(117); + return token === 8 ? parseAmbientExternalModuleDeclaration(fullStart, modifiers) : parseInternalModuleTail(fullStart, modifiers, modifiers ? modifiers.flags : 0); + } + function isExternalModuleReference() { + return token === 118 && + lookAhead(nextTokenIsOpenParen); + } + function nextTokenIsOpenParen() { + return nextToken() === 16; + } + function nextTokenIsCommaOrFromKeyword() { + nextToken(); + return token === 23 || + token === 102; + } + function parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers) { + parseExpected(84); + var afterImportPos = scanner.getStartPos(); + var identifier; + if (isIdentifier()) { + identifier = parseIdentifier(); + if (token !== 23 && token !== 102) { + var importEqualsDeclaration = createNode(202, fullStart); + setModifiers(importEqualsDeclaration, modifiers); + importEqualsDeclaration.name = identifier; + parseExpected(52); + importEqualsDeclaration.moduleReference = parseModuleReference(); + parseSemicolon(); + return finishNode(importEqualsDeclaration); + } + } + var importDeclaration = createNode(203, fullStart); + setModifiers(importDeclaration, modifiers); + if (identifier || + token === 35 || + token === 14) { + importDeclaration.importClause = parseImportClause(identifier, afterImportPos); + parseExpected(102); + } + importDeclaration.moduleSpecifier = parseModuleSpecifier(); + parseSemicolon(); + return finishNode(importDeclaration); + } + function parseImportClause(identifier, fullStart) { + var importClause = createNode(204, fullStart); + if (identifier) { + importClause.name = identifier; + } + if (!importClause.name || + parseOptional(23)) { + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(206); + } + return finishNode(importClause); + } + function parseModuleReference() { + return isExternalModuleReference() ? parseExternalModuleReference() : parseEntityName(false); + } + function parseExternalModuleReference() { + var node = createNode(212); + parseExpected(118); + parseExpected(16); + node.expression = parseModuleSpecifier(); + parseExpected(17); + return finishNode(node); + } + function parseModuleSpecifier() { + var result = parseExpression(); + if (result.kind === 8) { + internIdentifier(result.text); + } + return result; + } + function parseNamespaceImport() { + var namespaceImport = createNode(205); + parseExpected(35); + parseExpected(101); + namespaceImport.name = parseIdentifier(); + return finishNode(namespaceImport); + } + function parseNamedImportsOrExports(kind) { + var node = createNode(kind); + node.elements = parseBracketedList(20, kind === 206 ? parseImportSpecifier : parseExportSpecifier, 14, 15); + return finishNode(node); + } + function parseExportSpecifier() { + return parseImportOrExportSpecifier(211); + } + function parseImportSpecifier() { + return parseImportOrExportSpecifier(207); + } + function parseImportOrExportSpecifier(kind) { + var node = createNode(kind); + var isFirstIdentifierNameNotAnIdentifier = ts.isKeyword(token) && !isIdentifier(); + var start = scanner.getTokenPos(); + var identifierName = parseIdentifierName(); + if (token === 101) { + node.propertyName = identifierName; + parseExpected(101); + if (isIdentifier()) { + node.name = parseIdentifierName(); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected); + } + } + else { + node.name = identifierName; + if (isFirstIdentifierNameNotAnIdentifier) { + parseErrorAtPosition(start, identifierName.end - start, ts.Diagnostics.Identifier_expected); + } + } + return finishNode(node); + } + function parseExportDeclaration(fullStart, modifiers) { + var node = createNode(209, fullStart); + setModifiers(node, modifiers); + if (parseOptional(35)) { + parseExpected(102); + node.moduleSpecifier = parseModuleSpecifier(); + } + else { + node.exportClause = parseNamedImportsOrExports(210); + if (parseOptional(102)) { + node.moduleSpecifier = parseModuleSpecifier(); + } + } + parseSemicolon(); + return finishNode(node); + } + function parseExportAssignmentTail(fullStart, modifiers) { + var node = createNode(208, fullStart); + setModifiers(node, modifiers); + node.exportName = parseIdentifier(); + parseSemicolon(); + return finishNode(node); + } + function isLetDeclaration() { + return inStrictModeContext() || lookAhead(nextTokenIsIdentifierOnSameLine); + } + function isDeclarationStart() { + switch (token) { + case 97: + case 69: + case 82: + return true; + case 105: + return isLetDeclaration(); + case 68: + case 104: + case 76: + case 123: + return lookAhead(nextTokenIsIdentifierOrKeyword); + case 84: + return lookAhead(nextTokenCanFollowImportKeyword); + case 117: + return lookAhead(nextTokenIsIdentifierOrKeywordOrStringLiteral); + case 77: + return lookAhead(nextTokenCanFollowExportKeyword); + case 115: + case 109: + case 107: + case 108: + case 110: + return lookAhead(nextTokenIsDeclarationStart); + } + } + function isIdentifierOrKeyword() { + return token >= 64; + } + function nextTokenIsIdentifierOrKeyword() { + nextToken(); + return isIdentifierOrKeyword(); + } + function nextTokenIsIdentifierOrKeywordOrStringLiteral() { + nextToken(); + return isIdentifierOrKeyword() || token === 8; + } + function nextTokenCanFollowImportKeyword() { + nextToken(); + return isIdentifierOrKeyword() || token === 8 || + token === 35 || token === 14; + } + function nextTokenCanFollowExportKeyword() { + nextToken(); + return token === 52 || token === 35 || + token === 14 || isDeclarationStart(); + } + function nextTokenIsDeclarationStart() { + nextToken(); + return isDeclarationStart(); + } + function nextTokenIsAsKeyword() { + return nextToken() === 101; + } + function parseDeclaration() { + var fullStart = getNodePos(); + var modifiers = parseModifiers(); + if (token === 77) { + nextToken(); + if (parseOptional(52)) { + return parseExportAssignmentTail(fullStart, modifiers); + } + if (token === 35 || token === 14) { + return parseExportDeclaration(fullStart, modifiers); + } + } + switch (token) { + case 97: + case 105: + case 69: + return parseVariableStatement(fullStart, modifiers); + case 82: + return parseFunctionDeclaration(fullStart, modifiers); + case 68: + return parseClassDeclaration(fullStart, modifiers); + case 104: + return parseInterfaceDeclaration(fullStart, modifiers); + case 123: + return parseTypeAliasDeclaration(fullStart, modifiers); + case 76: + return parseEnumDeclaration(fullStart, modifiers); + case 117: + return parseModuleDeclaration(fullStart, modifiers); + case 84: + return parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers); + default: + ts.Debug.fail("Mismatch between isDeclarationStart and parseDeclaration"); + } + } + function isSourceElement(inErrorRecovery) { + return isDeclarationStart() || isStartOfStatement(inErrorRecovery); + } + function parseSourceElement() { + return parseSourceElementOrModuleElement(); + } + function parseModuleElement() { + return parseSourceElementOrModuleElement(); + } + function parseSourceElementOrModuleElement() { + return isDeclarationStart() ? parseDeclaration() : parseStatement(); + } + function processReferenceComments(sourceFile) { + var triviaScanner = ts.createScanner(sourceFile.languageVersion, false, sourceText); + var referencedFiles = []; + var amdDependencies = []; + var amdModuleName; + while (true) { + var kind = triviaScanner.scan(); + if (kind === 5 || kind === 4 || kind === 3) { + continue; + } + if (kind !== 2) { + break; + } + var range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos() }; + var comment = sourceText.substring(range.pos, range.end); + var referencePathMatchResult = ts.getFileReferenceFromReferencePath(comment, range); + if (referencePathMatchResult) { + var fileReference = referencePathMatchResult.fileReference; + sourceFile.hasNoDefaultLib = referencePathMatchResult.isNoDefaultLib; + var diagnosticMessage = referencePathMatchResult.diagnosticMessage; + if (fileReference) { + referencedFiles.push(fileReference); + } + if (diagnosticMessage) { + sourceFile.parseDiagnostics.push(ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, diagnosticMessage)); + } + } + else { + var amdModuleNameRegEx = /^\/\/\/\s*= 52 && token <= 63; + } + ts.isAssignmentOperator = isAssignmentOperator; +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.bindTime = 0; + function getModuleInstanceState(node) { + if (node.kind === 197 || node.kind === 198) { + return 0; + } + else if (ts.isConstEnumDeclaration(node)) { + return 2; + } + else if ((node.kind === 203 || node.kind === 202) && !(node.flags & 1)) { + return 0; + } + else if (node.kind === 201) { + var state = 0; + ts.forEachChild(node, function (n) { + switch (getModuleInstanceState(n)) { + case 0: + return false; + case 2: + state = 2; + return false; + case 1: + state = 1; + return true; + } + }); + return state; + } + else if (node.kind === 200) { + return getModuleInstanceState(node.body); + } + else { + return 1; + } + } + ts.getModuleInstanceState = getModuleInstanceState; + function bindSourceFile(file) { + var start = new Date().getTime(); + bindSourceFileWorker(file); + ts.bindTime += new Date().getTime() - start; + } + ts.bindSourceFile = bindSourceFile; + function bindSourceFileWorker(file) { + var parent; + var container; + var blockScopeContainer; + var lastContainer; + var symbolCount = 0; + var Symbol = ts.objectAllocator.getSymbolConstructor(); + if (!file.locals) { + file.locals = {}; + container = blockScopeContainer = file; + bind(file); + file.symbolCount = symbolCount; + } + function createSymbol(flags, name) { + symbolCount++; + return new Symbol(flags, name); + } + function addDeclarationToSymbol(symbol, node, symbolKind) { + symbol.flags |= symbolKind; + if (!symbol.declarations) + symbol.declarations = []; + symbol.declarations.push(node); + if (symbolKind & 1952 && !symbol.exports) + symbol.exports = {}; + if (symbolKind & 6240 && !symbol.members) + symbol.members = {}; + node.symbol = symbol; + if (symbolKind & 107455 && !symbol.valueDeclaration) + symbol.valueDeclaration = node; + } + function getDeclarationName(node) { + if (node.name) { + if (node.kind === 200 && node.name.kind === 8) { + return '"' + node.name.text + '"'; + } + if (node.name.kind === 126) { + var nameExpression = node.name.expression; + ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); + return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); + } + return node.name.text; + } + switch (node.kind) { + case 141: + case 133: + return "__constructor"; + case 140: + case 136: + return "__call"; + case 137: + return "__new"; + case 138: + return "__index"; + } + } + function getDisplayName(node) { + return node.name ? ts.declarationNameToString(node.name) : getDeclarationName(node); + } + function declareSymbol(symbols, parent, node, includes, excludes) { + ts.Debug.assert(!ts.hasDynamicName(node)); + var name = getDeclarationName(node); + if (name !== undefined) { + var symbol = ts.hasProperty(symbols, name) ? symbols[name] : (symbols[name] = createSymbol(0, name)); + if (symbol.flags & excludes) { + if (node.name) { + node.name.parent = node; + } + var message = symbol.flags & 2 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0; + ts.forEach(symbol.declarations, function (declaration) { + file.bindDiagnostics.push(ts.createDiagnosticForNode(declaration.name, message, getDisplayName(declaration))); + }); + file.bindDiagnostics.push(ts.createDiagnosticForNode(node.name, message, getDisplayName(node))); + symbol = createSymbol(0, name); + } + } + else { + symbol = createSymbol(0, "__missing"); + } + addDeclarationToSymbol(symbol, node, includes); + symbol.parent = parent; + if (node.kind === 196 && symbol.exports) { + var prototypeSymbol = createSymbol(4 | 134217728, "prototype"); + if (ts.hasProperty(symbol.exports, prototypeSymbol.name)) { + if (node.name) { + node.name.parent = node; + } + file.bindDiagnostics.push(ts.createDiagnosticForNode(symbol.exports[prototypeSymbol.name].declarations[0], ts.Diagnostics.Duplicate_identifier_0, prototypeSymbol.name)); + } + symbol.exports[prototypeSymbol.name] = prototypeSymbol; + prototypeSymbol.parent = symbol; + } + return symbol; + } + function isAmbientContext(node) { + while (node) { + if (node.flags & 2) + return true; + node = node.parent; + } + return false; + } + function declareModuleMember(node, symbolKind, symbolExcludes) { + var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; + if (symbolKind & 8388608) { + if (node.kind === 211 || (node.kind === 202 && hasExportModifier)) { + declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + } + else { + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); + } + } + else { + if (hasExportModifier || isAmbientContext(container)) { + var exportKind = (symbolKind & 107455 ? 1048576 : 0) | + (symbolKind & 793056 ? 2097152 : 0) | + (symbolKind & 1536 ? 4194304 : 0); + var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes); + local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + node.localSymbol = local; + } + else { + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); + } + } + } + function bindChildren(node, symbolKind, isBlockScopeContainer) { + if (symbolKind & 255504) { + node.locals = {}; + } + var saveParent = parent; + var saveContainer = container; + var savedBlockScopeContainer = blockScopeContainer; + parent = node; + if (symbolKind & 262128) { + container = node; + if (lastContainer) { + lastContainer.nextContainer = container; + } + lastContainer = container; + } + if (isBlockScopeContainer) { + blockScopeContainer = node; + } + ts.forEachChild(node, bind); + container = saveContainer; + parent = saveParent; + blockScopeContainer = savedBlockScopeContainer; + } + function bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer) { + switch (container.kind) { + case 200: + declareModuleMember(node, symbolKind, symbolExcludes); + break; + case 220: + if (ts.isExternalModule(container)) { + declareModuleMember(node, symbolKind, symbolExcludes); + break; + } + case 140: + case 141: + case 136: + case 137: + case 138: + case 132: + case 131: + case 133: + case 134: + case 135: + case 195: + case 160: + case 161: + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); + break; + case 196: + if (node.flags & 128) { + declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + break; + } + case 143: + case 152: + case 197: + declareSymbol(container.symbol.members, container.symbol, node, symbolKind, symbolExcludes); + break; + case 199: + declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + break; + } + bindChildren(node, symbolKind, isBlockScopeContainer); + } + function bindModuleDeclaration(node) { + if (node.name.kind === 8) { + bindDeclaration(node, 512, 106639, true); + } + else { + var state = getModuleInstanceState(node); + if (state === 0) { + bindDeclaration(node, 1024, 0, true); + } + else { + bindDeclaration(node, 512, 106639, true); + if (state === 2) { + node.symbol.constEnumOnlyModule = true; + } + else if (node.symbol.constEnumOnlyModule) { + node.symbol.constEnumOnlyModule = false; + } + } + } + } + function bindExportDeclaration(node) { + if (!node.exportClause) { + (container.exportStars || (container.exportStars = [])).push(node); + } + bindChildren(node, 0, false); + } + function bindFunctionOrConstructorType(node) { + var symbol = createSymbol(131072, getDeclarationName(node)); + addDeclarationToSymbol(symbol, node, 131072); + bindChildren(node, 131072, false); + var typeLiteralSymbol = createSymbol(2048, "__type"); + addDeclarationToSymbol(typeLiteralSymbol, node, 2048); + typeLiteralSymbol.members = {}; + typeLiteralSymbol.members[node.kind === 140 ? "__call" : "__new"] = symbol; + } + function bindAnonymousDeclaration(node, symbolKind, name, isBlockScopeContainer) { + var symbol = createSymbol(symbolKind, name); + addDeclarationToSymbol(symbol, node, symbolKind); + bindChildren(node, symbolKind, isBlockScopeContainer); + } + function bindCatchVariableDeclaration(node) { + var symbol = createSymbol(1, node.name.text || "__missing"); + addDeclarationToSymbol(symbol, node, 1); + var saveParent = parent; + var savedBlockScopeContainer = blockScopeContainer; + parent = blockScopeContainer = node; + ts.forEachChild(node, bind); + parent = saveParent; + blockScopeContainer = savedBlockScopeContainer; + } + function bindBlockScopedVariableDeclaration(node) { + switch (blockScopeContainer.kind) { + case 200: + declareModuleMember(node, 2, 107455); + break; + case 220: + if (ts.isExternalModule(container)) { + declareModuleMember(node, 2, 107455); + break; + } + default: + if (!blockScopeContainer.locals) { + blockScopeContainer.locals = {}; + } + declareSymbol(blockScopeContainer.locals, undefined, node, 2, 107455); + } + bindChildren(node, 2, false); + } + function getDestructuringParameterName(node) { + return "__" + ts.indexOf(node.parent.parameters, node); + } + function bind(node) { + node.parent = parent; + switch (node.kind) { + case 127: + bindDeclaration(node, 262144, 530912, false); + break; + case 128: + bindParameter(node); + break; + case 193: + case 150: + if (ts.isBindingPattern(node.name)) { + bindChildren(node, 0, false); + } + else if (ts.getCombinedNodeFlags(node) & 6144) { + bindBlockScopedVariableDeclaration(node); + } + else { + bindDeclaration(node, 1, 107454, false); + } + break; + case 130: + case 129: + bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); + break; + case 217: + case 218: + bindPropertyOrMethodOrAccessor(node, 4, 107455, false); + break; + case 219: + bindPropertyOrMethodOrAccessor(node, 8, 107455, false); + break; + case 136: + case 137: + case 138: + bindDeclaration(node, 131072, 0, false); + break; + case 132: + case 131: + bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); + break; + case 195: + bindDeclaration(node, 16, 106927, true); + break; + case 133: + bindDeclaration(node, 16384, 0, true); + break; + case 134: + bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); + break; + case 135: + bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); + break; + case 140: + case 141: + bindFunctionOrConstructorType(node); + break; + case 143: + bindAnonymousDeclaration(node, 2048, "__type", false); + break; + case 152: + bindAnonymousDeclaration(node, 4096, "__object", false); + break; + case 160: + case 161: + bindAnonymousDeclaration(node, 16, "__function", true); + break; + case 216: + bindCatchVariableDeclaration(node); + break; + case 196: + bindDeclaration(node, 32, 899583, false); + break; + case 197: + bindDeclaration(node, 64, 792992, false); + break; + case 198: + bindDeclaration(node, 524288, 793056, false); + break; + case 199: + if (ts.isConst(node)) { + bindDeclaration(node, 128, 899967, false); + } + else { + bindDeclaration(node, 256, 899327, false); + } + break; + case 200: + bindModuleDeclaration(node); + break; + case 202: + case 205: + case 207: + case 211: + bindDeclaration(node, 8388608, 8388608, false); + break; + case 209: + bindExportDeclaration(node); + break; + case 204: + if (node.name) { + bindDeclaration(node, 8388608, 8388608, false); + } + else { + bindChildren(node, 0, false); + } + break; + case 220: + if (ts.isExternalModule(node)) { + bindAnonymousDeclaration(node, 512, '"' + ts.removeFileExtension(node.fileName) + '"', true); + break; + } + case 174: + bindChildren(node, 0, !ts.isAnyFunction(node.parent)); + break; + case 216: + case 181: + case 182: + case 183: + case 188: + bindChildren(node, 0, true); + break; + default: + var saveParent = parent; + parent = node; + ts.forEachChild(node, bind); + parent = saveParent; + } + } + function bindParameter(node) { + if (ts.isBindingPattern(node.name)) { + bindAnonymousDeclaration(node, 1, getDestructuringParameterName(node), false); + } + else { + bindDeclaration(node, 1, 107455, false); + } + if (node.flags & 112 && + node.parent.kind === 133 && + node.parent.parent.kind === 196) { + var classDeclaration = node.parent.parent; + declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); + } + } + function bindPropertyOrMethodOrAccessor(node, symbolKind, symbolExcludes, isBlockScopeContainer) { + if (ts.hasDynamicName(node)) { + bindAnonymousDeclaration(node, symbolKind, "__computed", isBlockScopeContainer); + } + else { + bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer); + } + } + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var nextSymbolId = 1; + var nextNodeId = 1; + var nextMergeId = 1; + ts.checkTime = 0; + function createTypeChecker(host, produceDiagnostics) { + var Symbol = ts.objectAllocator.getSymbolConstructor(); + var Type = ts.objectAllocator.getTypeConstructor(); + var Signature = ts.objectAllocator.getSignatureConstructor(); + var typeCount = 0; + var emptyArray = []; + var emptySymbols = {}; + var compilerOptions = host.getCompilerOptions(); + var languageVersion = compilerOptions.target || 0; + var emitResolver = createResolver(); + var checker = { + getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); }, + getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); }, + getSymbolCount: function () { return ts.sum(host.getSourceFiles(), "symbolCount"); }, + getTypeCount: function () { return typeCount; }, + isUndefinedSymbol: function (symbol) { return symbol === undefinedSymbol; }, + isArgumentsSymbol: function (symbol) { return symbol === argumentsSymbol; }, + getDiagnostics: getDiagnostics, + getGlobalDiagnostics: getGlobalDiagnostics, + getTypeOfSymbolAtLocation: getTypeOfSymbolAtLocation, + getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol, + getPropertiesOfType: getPropertiesOfType, + getPropertyOfType: getPropertyOfType, + getSignaturesOfType: getSignaturesOfType, + getIndexTypeOfType: getIndexTypeOfType, + getReturnTypeOfSignature: getReturnTypeOfSignature, + getSymbolsInScope: getSymbolsInScope, + getSymbolAtLocation: getSymbolAtLocation, + getShorthandAssignmentValueSymbol: getShorthandAssignmentValueSymbol, + getTypeAtLocation: getTypeAtLocation, + typeToString: typeToString, + getSymbolDisplayBuilder: getSymbolDisplayBuilder, + symbolToString: symbolToString, + getAugmentedPropertiesOfType: getAugmentedPropertiesOfType, + getRootSymbols: getRootSymbols, + getContextualType: getContextualType, + getFullyQualifiedName: getFullyQualifiedName, + getResolvedSignature: getResolvedSignature, + getConstantValue: getConstantValue, + isValidPropertyAccess: isValidPropertyAccess, + getSignatureFromDeclaration: getSignatureFromDeclaration, + isImplementationOfOverload: isImplementationOfOverload, + getAliasedSymbol: resolveImport, + getEmitResolver: getEmitResolver + }; + var undefinedSymbol = createSymbol(4 | 67108864, "undefined"); + var argumentsSymbol = createSymbol(4 | 67108864, "arguments"); + var unknownSymbol = createSymbol(4 | 67108864, "unknown"); + var resolvingSymbol = createSymbol(67108864, "__resolving__"); + var anyType = createIntrinsicType(1, "any"); + var stringType = createIntrinsicType(2, "string"); + var numberType = createIntrinsicType(4, "number"); + var booleanType = createIntrinsicType(8, "boolean"); + var esSymbolType = createIntrinsicType(1048576, "symbol"); + var voidType = createIntrinsicType(16, "void"); + var undefinedType = createIntrinsicType(32 | 262144, "undefined"); + var nullType = createIntrinsicType(64 | 262144, "null"); + var unknownType = createIntrinsicType(1, "unknown"); + var resolvingType = createIntrinsicType(1, "__resolving__"); + var emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + var anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + var inferenceFailureType = 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 globals = {}; + var globalArraySymbol; + var globalESSymbolConstructorSymbol; + var globalObjectType; + var globalFunctionType; + var globalArrayType; + var globalStringType; + var globalNumberType; + var globalBooleanType; + var globalRegExpType; + var globalTemplateStringsArrayType; + var globalESSymbolType; + var anyArrayType; + var tupleTypes = {}; + var unionTypes = {}; + var stringLiteralTypes = {}; + var emitExtends = false; + var mergedSymbols = []; + var symbolLinks = []; + var nodeLinks = []; + var potentialThisCollisions = []; + var diagnostics = ts.createDiagnosticCollection(); + var primitiveTypeInfo = { + "string": { + type: stringType, + flags: 258 + }, + "number": { + type: numberType, + flags: 132 + }, + "boolean": { + type: booleanType, + flags: 8 + }, + "symbol": { + type: esSymbolType, + flags: 1048576 + } + }; + function getEmitResolver(sourceFile) { + getDiagnostics(sourceFile); + return emitResolver; + } + function error(location, message, arg0, arg1, arg2) { + var diagnostic = location ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2) : ts.createCompilerDiagnostic(message, arg0, arg1, arg2); + diagnostics.add(diagnostic); + } + function createSymbol(flags, name) { + return new Symbol(flags, name); + } + function getExcludedSymbolFlags(flags) { + var result = 0; + if (flags & 2) + result |= 107455; + if (flags & 1) + result |= 107454; + if (flags & 4) + result |= 107455; + if (flags & 8) + result |= 107455; + if (flags & 16) + result |= 106927; + if (flags & 32) + result |= 899583; + if (flags & 64) + result |= 792992; + if (flags & 256) + result |= 899327; + if (flags & 128) + result |= 899967; + if (flags & 512) + result |= 106639; + if (flags & 8192) + result |= 99263; + if (flags & 32768) + result |= 41919; + if (flags & 65536) + result |= 74687; + if (flags & 262144) + result |= 530912; + if (flags & 524288) + result |= 793056; + if (flags & 8388608) + result |= 8388608; + return result; + } + function recordMergedSymbol(target, source) { + if (!source.mergeId) + source.mergeId = nextMergeId++; + mergedSymbols[source.mergeId] = target; + } + function cloneSymbol(symbol) { + var result = createSymbol(symbol.flags | 33554432, symbol.name); + result.declarations = symbol.declarations.slice(0); + result.parent = symbol.parent; + if (symbol.valueDeclaration) + result.valueDeclaration = symbol.valueDeclaration; + if (symbol.constEnumOnlyModule) + result.constEnumOnlyModule = true; + if (symbol.members) + result.members = cloneSymbolTable(symbol.members); + if (symbol.exports) + result.exports = cloneSymbolTable(symbol.exports); + recordMergedSymbol(result, symbol); + return result; + } + function mergeSymbol(target, source) { + if (!(target.flags & getExcludedSymbolFlags(source.flags))) { + if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) { + target.constEnumOnlyModule = false; + } + target.flags |= source.flags; + if (!target.valueDeclaration && source.valueDeclaration) + target.valueDeclaration = source.valueDeclaration; + ts.forEach(source.declarations, function (node) { + target.declarations.push(node); + }); + if (source.members) { + if (!target.members) + target.members = {}; + mergeSymbolTable(target.members, source.members); + } + if (source.exports) { + if (!target.exports) + target.exports = {}; + mergeSymbolTable(target.exports, source.exports); + } + recordMergedSymbol(target, source); + } + else { + var message = target.flags & 2 || source.flags & 2 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0; + ts.forEach(source.declarations, function (node) { + error(node.name ? node.name : node, message, symbolToString(source)); + }); + ts.forEach(target.declarations, function (node) { + error(node.name ? node.name : node, message, symbolToString(source)); + }); + } + } + function cloneSymbolTable(symbolTable) { + var result = {}; + for (var id in symbolTable) { + if (ts.hasProperty(symbolTable, id)) { + result[id] = symbolTable[id]; + } + } + return result; + } + function mergeSymbolTable(target, source) { + for (var id in source) { + if (ts.hasProperty(source, id)) { + if (!ts.hasProperty(target, id)) { + target[id] = source[id]; + } + else { + var symbol = target[id]; + if (!(symbol.flags & 33554432)) { + target[id] = symbol = cloneSymbol(symbol); + } + mergeSymbol(symbol, source[id]); + } + } + } + } + function extendSymbolTable(target, source) { + for (var id in source) { + if (!ts.hasProperty(target, id)) { + target[id] = source[id]; + } + } + } + function getSymbolLinks(symbol) { + if (symbol.flags & 67108864) + return symbol; + if (!symbol.id) + symbol.id = nextSymbolId++; + return symbolLinks[symbol.id] || (symbolLinks[symbol.id] = {}); + } + function getNodeLinks(node) { + if (!node.id) + node.id = nextNodeId++; + return nodeLinks[node.id] || (nodeLinks[node.id] = {}); + } + function getSourceFile(node) { + return ts.getAncestor(node, 220); + } + function isGlobalSourceFile(node) { + return node.kind === 220 && !ts.isExternalModule(node); + } + function getSymbol(symbols, name, meaning) { + if (meaning && ts.hasProperty(symbols, name)) { + var symbol = symbols[name]; + ts.Debug.assert((symbol.flags & 16777216) === 0, "Should never get an instantiated symbol here."); + if (symbol.flags & meaning) { + return symbol; + } + if (symbol.flags & 8388608) { + var target = resolveImport(symbol); + if (target === unknownSymbol || target.flags & meaning) { + return symbol; + } + } + } + } + function isDefinedBefore(node1, node2) { + var file1 = ts.getSourceFileOfNode(node1); + var file2 = ts.getSourceFileOfNode(node2); + if (file1 === file2) { + return node1.pos <= node2.pos; + } + if (!compilerOptions.out) { + return true; + } + var sourceFiles = host.getSourceFiles(); + return sourceFiles.indexOf(file1) <= sourceFiles.indexOf(file2); + } + function resolveName(location, name, meaning, nameNotFoundMessage, nameArg) { + var result; + var lastLocation; + var propertyWithInvalidInitializer; + var errorLocation = location; + loop: while (location) { + if (location.locals && !isGlobalSourceFile(location)) { + if (result = getSymbol(location.locals, name, meaning)) { + break loop; + } + } + switch (location.kind) { + case 220: + if (!ts.isExternalModule(location)) + break; + case 200: + if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { + if (!(result.flags & 8388608 && getDeclarationOfImportSymbol(result).kind === 211)) { + break loop; + } + result = undefined; + } + break; + case 199: + if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { + break loop; + } + break; + case 130: + case 129: + if (location.parent.kind === 196 && !(location.flags & 128)) { + var ctor = findConstructorDeclaration(location.parent); + if (ctor && ctor.locals) { + if (getSymbol(ctor.locals, name, meaning & 107455)) { + propertyWithInvalidInitializer = location; + } + } + } + break; + case 196: + case 197: + 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); + return undefined; + } + break loop; + } + break; + case 126: + var grandparent = location.parent.parent; + if (grandparent.kind === 196 || grandparent.kind === 197) { + 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 132: + case 131: + case 133: + case 134: + case 135: + case 195: + case 161: + if (name === "arguments") { + result = argumentsSymbol; + break loop; + } + break; + case 160: + if (name === "arguments") { + result = argumentsSymbol; + break loop; + } + var id = location.name; + if (id && name === id.text) { + result = location.symbol; + break loop; + } + break; + case 216: + var id = location.name; + if (name === id.text) { + result = location.symbol; + break loop; + } + break; + } + lastLocation = location; + location = location.parent; + } + if (!result) { + result = getSymbol(globals, name, meaning); + } + if (!result) { + if (nameNotFoundMessage) { + error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg)); + } + return undefined; + } + if (nameNotFoundMessage) { + if (propertyWithInvalidInitializer) { + var propertyName = propertyWithInvalidInitializer.name; + error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), typeof nameArg === "string" ? nameArg : ts.declarationNameToString(nameArg)); + return undefined; + } + if (result.flags & 2) { + var declaration = ts.forEach(result.declarations, function (d) { return ts.getCombinedNodeFlags(d) & 6144 ? d : undefined; }); + ts.Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined"); + if (!isDefinedBefore(declaration, errorLocation)) { + error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, ts.declarationNameToString(declaration.name)); + } + } + } + return result; + } + function isImportSymbolDeclaration(node) { + return node.kind === 202 || + node.kind === 204 && !!node.name || + node.kind === 205 || + node.kind === 207 || + node.kind === 211; + } + function getDeclarationOfImportSymbol(symbol) { + return ts.forEach(symbol.declarations, function (d) { return isImportSymbolDeclaration(d) ? d : undefined; }); + } + function getTargetOfImportEqualsDeclaration(node) { + if (node.moduleReference.kind === 212) { + var moduleSymbol = resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node)); + var exportAssignmentSymbol = moduleSymbol && getResolvedExportAssignmentSymbol(moduleSymbol); + return exportAssignmentSymbol || moduleSymbol; + } + return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); + } + function getTargetOfImportClause(node) { + var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); + if (moduleSymbol) { + var exportAssignmentSymbol = getResolvedExportAssignmentSymbol(moduleSymbol); + if (!exportAssignmentSymbol) { + error(node.name, ts.Diagnostics.External_module_0_has_no_default_export_or_export_assignment, symbolToString(moduleSymbol)); + } + return exportAssignmentSymbol; + } + } + function getTargetOfNamespaceImport(node) { + return resolveExternalModuleName(node, node.parent.parent.moduleSpecifier); + } + function getExternalModuleMember(node, specifier) { + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleSymbol) { + var name = specifier.propertyName || specifier.name; + if (name.text) { + var symbol = getSymbol(getExportsOfSymbol(moduleSymbol), name.text, 107455 | 793056 | 1536); + if (!symbol) { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(moduleSymbol), ts.declarationNameToString(name)); + return; + } + return symbol.flags & (107455 | 793056 | 1536) ? symbol : resolveImport(symbol); + } + } + } + function getTargetOfImportSpecifier(node) { + return getExternalModuleMember(node.parent.parent.parent, node); + } + function getTargetOfExportSpecifier(node) { + return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : resolveEntityName(node, node.propertyName || node.name, 107455 | 793056 | 1536); + } + function getTargetOfImportDeclaration(node) { + switch (node.kind) { + case 202: + return getTargetOfImportEqualsDeclaration(node); + case 204: + return getTargetOfImportClause(node); + case 205: + return getTargetOfNamespaceImport(node); + case 207: + return getTargetOfImportSpecifier(node); + case 211: + return getTargetOfExportSpecifier(node); + } + } + function resolveImport(symbol) { + ts.Debug.assert((symbol.flags & 8388608) !== 0, "Should only get Imports here."); + var links = getSymbolLinks(symbol); + if (!links.target) { + links.target = resolvingSymbol; + var node = getDeclarationOfImportSymbol(symbol); + var target = getTargetOfImportDeclaration(node); + if (links.target === resolvingSymbol) { + links.target = target || unknownSymbol; + } + else { + error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol)); + } + } + else if (links.target === resolvingSymbol) { + links.target = unknownSymbol; + } + return links.target; + } + function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { + if (!importDeclaration) { + importDeclaration = ts.getAncestor(entityName, 202); + ts.Debug.assert(importDeclaration !== undefined); + } + if (entityName.kind === 64 && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { + entityName = entityName.parent; + } + if (entityName.kind === 64 || entityName.parent.kind === 125) { + return resolveEntityName(importDeclaration, entityName, 1536); + } + else { + ts.Debug.assert(entityName.parent.kind === 202); + return resolveEntityName(importDeclaration, entityName, 107455 | 793056 | 1536); + } + } + function getFullyQualifiedName(symbol) { + return symbol.parent ? getFullyQualifiedName(symbol.parent) + "." + symbolToString(symbol) : symbolToString(symbol); + } + function resolveEntityName(location, name, meaning) { + if (ts.getFullWidth(name) === 0) { + return undefined; + } + if (name.kind === 64) { + var symbol = resolveName(location, name.text, meaning, ts.Diagnostics.Cannot_find_name_0, name); + if (!symbol) { + return; + } + } + else if (name.kind === 125) { + var namespace = resolveEntityName(location, name.left, 1536); + if (!namespace || namespace === unknownSymbol || ts.getFullWidth(name.right) === 0) + return; + var symbol = getSymbol(getExportsOfSymbol(namespace), name.right.text, meaning); + if (!symbol) { + error(location, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(name.right)); + return; + } + } + ts.Debug.assert((symbol.flags & 16777216) === 0, "Should never get an instantiated symbol here."); + return symbol.flags & meaning ? symbol : resolveImport(symbol); + } + function isExternalModuleNameRelative(moduleName) { + return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\"; + } + function resolveExternalModuleName(location, moduleReferenceExpression) { + if (moduleReferenceExpression.kind !== 8) { + return; + } + var moduleReferenceLiteral = moduleReferenceExpression; + var searchPath = ts.getDirectoryPath(getSourceFile(location).fileName); + var moduleName = ts.escapeIdentifier(moduleReferenceLiteral.text); + if (!moduleName) + return; + var isRelative = isExternalModuleNameRelative(moduleName); + if (!isRelative) { + var symbol = getSymbol(globals, '"' + moduleName + '"', 512); + if (symbol) { + return symbol; + } + } + while (true) { + var fileName = ts.normalizePath(ts.combinePaths(searchPath, moduleName)); + var sourceFile = host.getSourceFile(fileName + ".ts") || host.getSourceFile(fileName + ".d.ts"); + if (sourceFile || isRelative) + break; + var parentPath = ts.getDirectoryPath(searchPath); + if (parentPath === searchPath) + break; + searchPath = parentPath; + } + if (sourceFile) { + if (sourceFile.symbol) { + return sourceFile.symbol; + } + error(moduleReferenceLiteral, ts.Diagnostics.File_0_is_not_an_external_module, sourceFile.fileName); + return; + } + error(moduleReferenceLiteral, ts.Diagnostics.Cannot_find_external_module_0, moduleName); + } + function getResolvedExportAssignmentSymbol(moduleSymbol) { + var symbol = getExportAssignmentSymbol(moduleSymbol); + if (symbol) { + if (symbol.flags & (107455 | 793056 | 1536)) { + return symbol; + } + if (symbol.flags & 8388608) { + return resolveImport(symbol); + } + } + } + function getExportAssignmentSymbol(symbol) { + checkTypeOfExportAssignmentSymbol(symbol); + return getSymbolLinks(symbol).exportAssignmentSymbol; + } + function checkTypeOfExportAssignmentSymbol(containerSymbol) { + var symbolLinks = getSymbolLinks(containerSymbol); + if (!symbolLinks.exportAssignmentChecked) { + var exportInformation = collectExportInformationForSourceFileOrModule(containerSymbol); + if (exportInformation.exportAssignments.length) { + if (exportInformation.exportAssignments.length > 1) { + ts.forEach(exportInformation.exportAssignments, function (node) { return error(node, ts.Diagnostics.A_module_cannot_have_more_than_one_export_assignment); }); + } + var node = exportInformation.exportAssignments[0]; + if (exportInformation.hasExportedMember) { + error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements); + } + if (node.exportName.text) { + var meaning = 107455 | 793056 | 1536; + var exportSymbol = resolveName(node, node.exportName.text, meaning, ts.Diagnostics.Cannot_find_name_0, node.exportName); + } + symbolLinks.exportAssignmentSymbol = exportSymbol || unknownSymbol; + } + symbolLinks.exportAssignmentChecked = true; + } + } + function collectExportInformationForSourceFileOrModule(symbol) { + var seenExportedMember = false; + var result = []; + ts.forEach(symbol.declarations, function (declaration) { + var block = (declaration.kind === 220 ? declaration : declaration.body); + ts.forEach(block.statements, function (node) { + if (node.kind === 208) { + result.push(node); + } + else { + seenExportedMember = seenExportedMember || (node.flags & 1) !== 0; + } + }); + }); + return { + hasExportedMember: seenExportedMember, + exportAssignments: result + }; + } + function getExportsOfSymbol(symbol) { + return symbol.flags & 1536 ? getExportsOfModule(symbol) : symbol.exports; + } + function getExportsOfModule(symbol) { + var links = getSymbolLinks(symbol); + return links.resolvedExports || (links.resolvedExports = getExportsForModule(symbol)); + } + function getExportsForModule(symbol) { + var result; + var visitedSymbols = []; + visit(symbol); + return result; + function visit(symbol) { + if (!ts.contains(visitedSymbols, symbol)) { + visitedSymbols.push(symbol); + if (!result) { + result = symbol.exports; + } + else { + extendSymbolTable(result, symbol.exports); + } + ts.forEach(symbol.declarations, function (node) { + if (node.kind === 220 || node.kind === 200) { + ts.forEach(node.exportStars, function (exportStar) { + visit(resolveExternalModuleName(exportStar, exportStar.moduleSpecifier)); + }); + } + }); + } + } + } + function getMergedSymbol(symbol) { + var merged; + return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol; + } + function getSymbolOfNode(node) { + return getMergedSymbol(node.symbol); + } + function getParentOfSymbol(symbol) { + return getMergedSymbol(symbol.parent); + } + function getExportSymbolOfValueSymbolIfExported(symbol) { + return symbol && (symbol.flags & 1048576) !== 0 ? getMergedSymbol(symbol.exportSymbol) : symbol; + } + function symbolIsValue(symbol) { + if (symbol.flags & 16777216) { + return symbolIsValue(getSymbolLinks(symbol).target); + } + if (symbol.flags & 107455) { + return true; + } + if (symbol.flags & 8388608) { + return (resolveImport(symbol).flags & 107455) !== 0; + } + return false; + } + function findConstructorDeclaration(node) { + var members = node.members; + for (var i = 0; i < members.length; i++) { + var member = members[i]; + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { + return member; + } + } + } + function createType(flags) { + var result = new Type(checker, flags); + result.id = typeCount++; + return result; + } + function createIntrinsicType(kind, intrinsicName) { + var type = createType(kind); + type.intrinsicName = intrinsicName; + return type; + } + function createObjectType(kind, symbol) { + var type = createType(kind); + type.symbol = symbol; + return type; + } + function isReservedMemberName(name) { + return name.charCodeAt(0) === 95 && + name.charCodeAt(1) === 95 && + name.charCodeAt(2) !== 95 && + name.charCodeAt(2) !== 64; + } + function getNamedMembers(members) { + var result; + for (var id in members) { + if (ts.hasProperty(members, id)) { + if (!isReservedMemberName(id)) { + if (!result) + result = []; + var symbol = members[id]; + if (symbolIsValue(symbol)) { + result.push(symbol); + } + } + } + } + return result || emptyArray; + } + function setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType) { + type.members = members; + type.properties = getNamedMembers(members); + type.callSignatures = callSignatures; + type.constructSignatures = constructSignatures; + if (stringIndexType) + type.stringIndexType = stringIndexType; + if (numberIndexType) + type.numberIndexType = numberIndexType; + return type; + } + function createAnonymousType(symbol, members, callSignatures, constructSignatures, stringIndexType, numberIndexType) { + return setObjectTypeMembers(createObjectType(32768, symbol), members, callSignatures, constructSignatures, stringIndexType, numberIndexType); + } + function forEachSymbolTableInScope(enclosingDeclaration, callback) { + var result; + for (var location = enclosingDeclaration; location; location = location.parent) { + if (location.locals && !isGlobalSourceFile(location)) { + if (result = callback(location.locals)) { + return result; + } + } + switch (location.kind) { + case 220: + if (!ts.isExternalModule(location)) { + break; + } + case 200: + if (result = callback(getSymbolOfNode(location).exports)) { + return result; + } + break; + case 196: + case 197: + if (result = callback(getSymbolOfNode(location).members)) { + return result; + } + break; + } + } + return callback(globals); + } + function getQualifiedLeftMeaning(rightMeaning) { + return rightMeaning === 107455 ? 107455 : 1536; + } + function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing) { + function getAccessibleSymbolChainFromSymbolTable(symbols) { + function canQualifySymbol(symbolFromSymbolTable, meaning) { + if (!needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning)) { + return true; + } + var accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing); + return !!accessibleParent; + } + function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol) { + if (symbol === (resolvedAliasSymbol || symbolFromSymbolTable)) { + return !ts.forEach(symbolFromSymbolTable.declarations, hasExternalModuleSymbol) && + canQualifySymbol(symbolFromSymbolTable, meaning); + } + } + if (isAccessible(ts.lookUp(symbols, symbol.name))) { + return [symbol]; + } + return ts.forEachValue(symbols, function (symbolFromSymbolTable) { + if (symbolFromSymbolTable.flags & 8388608) { + if (!useOnlyExternalAliasing || + ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) { + var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable); + if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) { + return [symbolFromSymbolTable]; + } + var accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined; + if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) { + return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports); + } + } + } + }); + } + if (symbol) { + return forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable); + } + } + function needsQualification(symbol, enclosingDeclaration, meaning) { + var qualify = false; + forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) { + if (!ts.hasProperty(symbolTable, symbol.name)) { + return false; + } + var symbolFromSymbolTable = symbolTable[symbol.name]; + if (symbolFromSymbolTable === symbol) { + return true; + } + symbolFromSymbolTable = (symbolFromSymbolTable.flags & 8388608) ? resolveImport(symbolFromSymbolTable) : symbolFromSymbolTable; + if (symbolFromSymbolTable.flags & meaning) { + qualify = true; + return true; + } + return false; + }); + return qualify; + } + function isSymbolAccessible(symbol, enclosingDeclaration, meaning) { + if (symbol && enclosingDeclaration && !(symbol.flags & 262144)) { + var initialSymbol = symbol; + var meaningToLook = meaning; + while (symbol) { + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, false); + if (accessibleSymbolChain) { + var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]); + if (!hasAccessibleDeclarations) { + return { + accessibility: 1, + errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), + errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, 1536) : undefined + }; + } + return hasAccessibleDeclarations; + } + meaningToLook = getQualifiedLeftMeaning(meaning); + symbol = getParentOfSymbol(symbol); + } + var symbolExternalModule = ts.forEach(initialSymbol.declarations, getExternalModuleContainer); + if (symbolExternalModule) { + var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration); + if (symbolExternalModule !== enclosingExternalModule) { + return { + accessibility: 2, + errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), + errorModuleName: symbolToString(symbolExternalModule) + }; + } + } + return { + accessibility: 1, + errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning) + }; + } + return { accessibility: 0 }; + function getExternalModuleContainer(declaration) { + for (; declaration; declaration = declaration.parent) { + if (hasExternalModuleSymbol(declaration)) { + return getSymbolOfNode(declaration); + } + } + } + } + function hasExternalModuleSymbol(declaration) { + return (declaration.kind === 200 && declaration.name.kind === 8) || + (declaration.kind === 220 && ts.isExternalModule(declaration)); + } + function hasVisibleDeclarations(symbol) { + var aliasesToMakeVisible; + if (ts.forEach(symbol.declarations, function (declaration) { return !getIsDeclarationVisible(declaration); })) { + return undefined; + } + return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible }; + function getIsDeclarationVisible(declaration) { + if (!isDeclarationVisible(declaration)) { + if (declaration.kind === 202 && + !(declaration.flags & 1) && + isDeclarationVisible(declaration.parent)) { + getNodeLinks(declaration).isVisible = true; + if (aliasesToMakeVisible) { + if (!ts.contains(aliasesToMakeVisible, declaration)) { + aliasesToMakeVisible.push(declaration); + } + } + else { + aliasesToMakeVisible = [declaration]; + } + return true; + } + return false; + } + return true; + } + } + function isEntityNameVisible(entityName, enclosingDeclaration) { + var meaning; + if (entityName.parent.kind === 142) { + meaning = 107455 | 1048576; + } + else if (entityName.kind === 125 || + entityName.parent.kind === 202) { + meaning = 1536; + } + else { + meaning = 793056; + } + var firstIdentifier = getFirstIdentifier(entityName); + var symbol = resolveName(enclosingDeclaration, firstIdentifier.text, meaning, undefined, undefined); + return (symbol && hasVisibleDeclarations(symbol)) || { + accessibility: 1, + errorSymbolName: ts.getTextOfNode(firstIdentifier), + errorNode: firstIdentifier + }; + } + function writeKeyword(writer, kind) { + writer.writeKeyword(ts.tokenToString(kind)); + } + function writePunctuation(writer, kind) { + writer.writePunctuation(ts.tokenToString(kind)); + } + function writeSpace(writer) { + writer.writeSpace(" "); + } + function symbolToString(symbol, enclosingDeclaration, meaning) { + var writer = ts.getSingleLineStringWriter(); + getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning); + var result = writer.string(); + ts.releaseStringWriter(writer); + return result; + } + function typeToString(type, enclosingDeclaration, flags) { + var writer = ts.getSingleLineStringWriter(); + getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); + var result = writer.string(); + ts.releaseStringWriter(writer); + var maxLength = compilerOptions.noErrorTruncation || flags & 4 ? undefined : 100; + if (maxLength && result.length >= maxLength) { + result = result.substr(0, maxLength - "...".length) + "..."; + } + return result; + } + function getTypeAliasForTypeLiteral(type) { + if (type.symbol && type.symbol.flags & 2048) { + var node = type.symbol.declarations[0].parent; + while (node.kind === 147) { + node = node.parent; + } + if (node.kind === 198) { + return getSymbolOfNode(node); + } + } + return undefined; + } + var _displayBuilder; + function getSymbolDisplayBuilder() { + 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); + } + function buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags) { + var parentSymbol; + function appendParentTypeArgumentsAndSymbolName(symbol) { + if (parentSymbol) { + if (flags & 1) { + if (symbol.flags & 16777216) { + buildDisplayForTypeArgumentsAndDelimiters(getTypeParametersOfClassOrInterface(parentSymbol), symbol.mapper, writer, enclosingDeclaration); + } + else { + buildTypeParameterDisplayFromSymbol(parentSymbol, writer, enclosingDeclaration); + } + } + writePunctuation(writer, 20); + } + parentSymbol = symbol; + appendSymbolNameOnly(symbol, writer); + } + writer.trackSymbol(symbol, enclosingDeclaration, meaning); + function walkSymbol(symbol, meaning) { + if (symbol) { + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & 2)); + if (!accessibleSymbolChain || + needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) { + walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning)); + } + if (accessibleSymbolChain) { + for (var i = 0, n = accessibleSymbolChain.length; i < n; i++) { + appendParentTypeArgumentsAndSymbolName(accessibleSymbolChain[i]); + } + } + else { + if (!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) { + return; + } + if (symbol.flags & 2048 || symbol.flags & 4096) { + return; + } + appendParentTypeArgumentsAndSymbolName(symbol); + } + } + } + var isTypeParameter = symbol.flags & 262144; + var typeFormatFlag = 128 & typeFlags; + if (!isTypeParameter && (enclosingDeclaration || typeFormatFlag)) { + walkSymbol(symbol, meaning); + return; + } + return appendParentTypeArgumentsAndSymbolName(symbol); + } + function buildTypeDisplay(type, writer, enclosingDeclaration, globalFlags, typeStack) { + var globalFlagsToPass = globalFlags & 16; + return writeType(type, globalFlags); + function writeType(type, flags) { + if (type.flags & 1048703) { + writer.writeKeyword(!(globalFlags & 16) && + (type.flags & 1) ? "any" : type.intrinsicName); + } + else if (type.flags & 4096) { + writeTypeReference(type, flags); + } + else if (type.flags & (1024 | 2048 | 128 | 512)) { + buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793056, 0, flags); + } + else if (type.flags & 8192) { + writeTupleType(type); + } + else if (type.flags & 16384) { + writeUnionType(type, flags); + } + else if (type.flags & 32768) { + writeAnonymousType(type, flags); + } + else if (type.flags & 256) { + writer.writeStringLiteral(type.text); + } + else { + writePunctuation(writer, 14); + writeSpace(writer); + writePunctuation(writer, 21); + writeSpace(writer); + writePunctuation(writer, 15); + } + } + function writeTypeList(types, union) { + for (var i = 0; i < types.length; i++) { + if (i > 0) { + if (union) { + writeSpace(writer); + } + writePunctuation(writer, union ? 44 : 23); + writeSpace(writer); + } + writeType(types[i], union ? 64 : 0); + } + } + function writeTypeReference(type, flags) { + if (type.target === globalArrayType && !(flags & 1)) { + writeType(type.typeArguments[0], 64); + writePunctuation(writer, 18); + writePunctuation(writer, 19); + } + else { + buildSymbolDisplay(type.target.symbol, writer, enclosingDeclaration, 793056); + writePunctuation(writer, 24); + writeTypeList(type.typeArguments, false); + writePunctuation(writer, 25); + } + } + function writeTupleType(type) { + writePunctuation(writer, 18); + writeTypeList(type.elementTypes, false); + writePunctuation(writer, 19); + } + function writeUnionType(type, flags) { + if (flags & 64) { + writePunctuation(writer, 16); + } + writeTypeList(type.types, true); + if (flags & 64) { + writePunctuation(writer, 17); + } + } + function writeAnonymousType(type, flags) { + if (type.symbol && type.symbol.flags & (32 | 384 | 512)) { + writeTypeofSymbol(type, flags); + } + else if (shouldWriteTypeOfFunctionSymbol()) { + writeTypeofSymbol(type, flags); + } + else if (typeStack && ts.contains(typeStack, type)) { + var typeAlias = getTypeAliasForTypeLiteral(type); + if (typeAlias) { + buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056, 0, flags); + } + else { + writeKeyword(writer, 112); + } + } + else { + if (!typeStack) { + typeStack = []; + } + typeStack.push(type); + writeLiteralType(type, flags); + typeStack.pop(); + } + function shouldWriteTypeOfFunctionSymbol() { + if (type.symbol) { + var isStaticMethodSymbol = !!(type.symbol.flags & 8192 && + ts.forEach(type.symbol.declarations, function (declaration) { return declaration.flags & 128; })); + var isNonLocalFunctionSymbol = !!(type.symbol.flags & 16) && + (type.symbol.parent || + ts.forEach(type.symbol.declarations, function (declaration) { + return declaration.parent.kind === 220 || declaration.parent.kind === 201; + })); + if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { + return !!(flags & 2) || + (typeStack && ts.contains(typeStack, type)); + } + } + } + } + function writeTypeofSymbol(type, typeFormatFlags) { + writeKeyword(writer, 96); + writeSpace(writer); + buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 107455, 0, typeFormatFlags); + } + function getIndexerParameterName(type, indexKind, fallbackName) { + var declaration = getIndexDeclarationOfSymbol(type.symbol, indexKind); + if (!declaration) { + return fallbackName; + } + ts.Debug.assert(declaration.parameters.length !== 0); + return ts.declarationNameToString(declaration.parameters[0].name); + } + function writeLiteralType(type, flags) { + var resolved = resolveObjectOrUnionTypeMembers(type); + if (!resolved.properties.length && !resolved.stringIndexType && !resolved.numberIndexType) { + if (!resolved.callSignatures.length && !resolved.constructSignatures.length) { + writePunctuation(writer, 14); + writePunctuation(writer, 15); + return; + } + if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) { + if (flags & 64) { + writePunctuation(writer, 16); + } + buildSignatureDisplay(resolved.callSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8, typeStack); + if (flags & 64) { + writePunctuation(writer, 17); + } + return; + } + if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) { + if (flags & 64) { + writePunctuation(writer, 16); + } + writeKeyword(writer, 87); + writeSpace(writer); + buildSignatureDisplay(resolved.constructSignatures[0], writer, enclosingDeclaration, globalFlagsToPass | 8, typeStack); + if (flags & 64) { + writePunctuation(writer, 17); + } + return; + } + } + writePunctuation(writer, 14); + writer.writeLine(); + writer.increaseIndent(); + for (var i = 0; i < resolved.callSignatures.length; i++) { + buildSignatureDisplay(resolved.callSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack); + writePunctuation(writer, 22); + writer.writeLine(); + } + for (var i = 0; i < resolved.constructSignatures.length; i++) { + writeKeyword(writer, 87); + writeSpace(writer); + buildSignatureDisplay(resolved.constructSignatures[i], writer, enclosingDeclaration, globalFlagsToPass, typeStack); + writePunctuation(writer, 22); + writer.writeLine(); + } + if (resolved.stringIndexType) { + writePunctuation(writer, 18); + writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); + writePunctuation(writer, 51); + writeSpace(writer); + writeKeyword(writer, 121); + writePunctuation(writer, 19); + writePunctuation(writer, 51); + writeSpace(writer); + writeType(resolved.stringIndexType, 0); + writePunctuation(writer, 22); + writer.writeLine(); + } + if (resolved.numberIndexType) { + writePunctuation(writer, 18); + writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); + writePunctuation(writer, 51); + writeSpace(writer); + writeKeyword(writer, 119); + writePunctuation(writer, 19); + writePunctuation(writer, 51); + writeSpace(writer); + writeType(resolved.numberIndexType, 0); + writePunctuation(writer, 22); + writer.writeLine(); + } + for (var i = 0; i < resolved.properties.length; i++) { + var p = resolved.properties[i]; + var t = getTypeOfSymbol(p); + if (p.flags & (16 | 8192) && !getPropertiesOfObjectType(t).length) { + var signatures = getSignaturesOfType(t, 0); + for (var j = 0; j < signatures.length; j++) { + buildSymbolDisplay(p, writer); + if (p.flags & 536870912) { + writePunctuation(writer, 50); + } + buildSignatureDisplay(signatures[j], writer, enclosingDeclaration, globalFlagsToPass, typeStack); + writePunctuation(writer, 22); + writer.writeLine(); + } + } + else { + buildSymbolDisplay(p, writer); + if (p.flags & 536870912) { + writePunctuation(writer, 50); + } + writePunctuation(writer, 51); + writeSpace(writer); + writeType(t, 0); + writePunctuation(writer, 22); + writer.writeLine(); + } + } + writer.decreaseIndent(); + writePunctuation(writer, 15); + } + } + function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) { + var targetSymbol = getTargetSymbol(symbol); + if (targetSymbol.flags & 32 || targetSymbol.flags & 64) { + buildDisplayForTypeParametersAndDelimiters(getTypeParametersOfClassOrInterface(symbol), writer, enclosingDeclaraiton, flags); + } + } + function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, typeStack) { + appendSymbolNameOnly(tp.symbol, writer); + var constraint = getConstraintOfTypeParameter(tp); + if (constraint) { + writeSpace(writer); + writeKeyword(writer, 78); + writeSpace(writer); + buildTypeDisplay(constraint, writer, enclosingDeclaration, flags, typeStack); + } + } + function buildParameterDisplay(p, writer, enclosingDeclaration, flags, typeStack) { + if (ts.hasDotDotDotToken(p.valueDeclaration)) { + writePunctuation(writer, 21); + } + appendSymbolNameOnly(p, writer); + if (ts.hasQuestionToken(p.valueDeclaration) || p.valueDeclaration.initializer) { + writePunctuation(writer, 50); + } + writePunctuation(writer, 51); + writeSpace(writer); + buildTypeDisplay(getTypeOfSymbol(p), writer, enclosingDeclaration, flags, typeStack); + } + function buildDisplayForTypeParametersAndDelimiters(typeParameters, writer, enclosingDeclaration, flags, typeStack) { + if (typeParameters && typeParameters.length) { + writePunctuation(writer, 24); + for (var i = 0; i < typeParameters.length; i++) { + if (i > 0) { + writePunctuation(writer, 23); + writeSpace(writer); + } + buildTypeParameterDisplay(typeParameters[i], writer, enclosingDeclaration, flags, typeStack); + } + writePunctuation(writer, 25); + } + } + function buildDisplayForTypeArgumentsAndDelimiters(typeParameters, mapper, writer, enclosingDeclaration, flags, typeStack) { + if (typeParameters && typeParameters.length) { + writePunctuation(writer, 24); + for (var i = 0; i < typeParameters.length; i++) { + if (i > 0) { + writePunctuation(writer, 23); + writeSpace(writer); + } + buildTypeDisplay(mapper(typeParameters[i]), writer, enclosingDeclaration, 0); + } + writePunctuation(writer, 25); + } + } + function buildDisplayForParametersAndDelimiters(parameters, writer, enclosingDeclaration, flags, typeStack) { + writePunctuation(writer, 16); + for (var i = 0; i < parameters.length; i++) { + if (i > 0) { + writePunctuation(writer, 23); + writeSpace(writer); + } + buildParameterDisplay(parameters[i], writer, enclosingDeclaration, flags, typeStack); + } + writePunctuation(writer, 17); + } + function buildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, typeStack) { + if (flags & 8) { + writeSpace(writer); + writePunctuation(writer, 32); + } + else { + writePunctuation(writer, 51); + } + writeSpace(writer); + buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags, typeStack); + } + function buildSignatureDisplay(signature, writer, enclosingDeclaration, flags, typeStack) { + if (signature.target && (flags & 32)) { + buildDisplayForTypeArgumentsAndDelimiters(signature.target.typeParameters, signature.mapper, writer, enclosingDeclaration); + } + else { + buildDisplayForTypeParametersAndDelimiters(signature.typeParameters, writer, enclosingDeclaration, flags, typeStack); + } + buildDisplayForParametersAndDelimiters(signature.parameters, writer, enclosingDeclaration, flags, typeStack); + buildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, typeStack); + } + return _displayBuilder || (_displayBuilder = { + symbolToString: symbolToString, + typeToString: typeToString, + buildSymbolDisplay: buildSymbolDisplay, + buildTypeDisplay: buildTypeDisplay, + buildTypeParameterDisplay: buildTypeParameterDisplay, + buildParameterDisplay: buildParameterDisplay, + buildDisplayForParametersAndDelimiters: buildDisplayForParametersAndDelimiters, + buildDisplayForTypeParametersAndDelimiters: buildDisplayForTypeParametersAndDelimiters, + buildDisplayForTypeArgumentsAndDelimiters: buildDisplayForTypeArgumentsAndDelimiters, + buildTypeParameterDisplayFromSymbol: buildTypeParameterDisplayFromSymbol, + buildSignatureDisplay: buildSignatureDisplay, + buildReturnTypeDisplay: buildReturnTypeDisplay + }); + } + function isDeclarationVisible(node) { + function getContainingExternalModule(node) { + for (; node; node = node.parent) { + if (node.kind === 200) { + if (node.name.kind === 8) { + return node; + } + } + else if (node.kind === 220) { + return ts.isExternalModule(node) ? node : undefined; + } + } + ts.Debug.fail("getContainingModule cant reach here"); + } + function isUsedInExportAssignment(node) { + var externalModule = getContainingExternalModule(node); + if (externalModule) { + var externalModuleSymbol = getSymbolOfNode(externalModule); + var exportAssignmentSymbol = getExportAssignmentSymbol(externalModuleSymbol); + var resolvedExportSymbol; + var symbolOfNode = getSymbolOfNode(node); + if (isSymbolUsedInExportAssignment(symbolOfNode)) { + return true; + } + if (symbolOfNode.flags & 8388608) { + return isSymbolUsedInExportAssignment(resolveImport(symbolOfNode)); + } + } + function isSymbolUsedInExportAssignment(symbol) { + if (exportAssignmentSymbol === symbol) { + return true; + } + if (exportAssignmentSymbol && !!(exportAssignmentSymbol.flags & 8388608)) { + resolvedExportSymbol = resolvedExportSymbol || resolveImport(exportAssignmentSymbol); + if (resolvedExportSymbol === symbol) { + return true; + } + return ts.forEach(resolvedExportSymbol.declarations, function (current) { + while (current) { + if (current === node) { + return true; + } + current = current.parent; + } + }); + } + } + } + function determineIfDeclarationIsVisible() { + switch (node.kind) { + case 193: + case 150: + case 200: + case 196: + case 197: + case 198: + case 195: + case 199: + case 202: + var parent = getDeclarationContainer(node); + if (!(ts.getCombinedNodeFlags(node) & 1) && + !(node.kind !== 202 && parent.kind !== 220 && ts.isInAmbientContext(parent))) { + return isGlobalSourceFile(parent) || isUsedInExportAssignment(node); + } + return isDeclarationVisible(parent); + case 130: + case 129: + case 134: + case 135: + case 132: + case 131: + if (node.flags & (32 | 64)) { + return false; + } + case 133: + case 137: + case 136: + case 138: + case 128: + case 201: + case 140: + case 141: + case 143: + case 139: + case 144: + case 145: + case 146: + case 147: + return isDeclarationVisible(node.parent); + case 127: + case 220: + return true; + default: + ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); + } + } + if (node) { + var links = getNodeLinks(node); + if (links.isVisible === undefined) { + links.isVisible = !!determineIfDeclarationIsVisible(); + } + return links.isVisible; + } + } + function getRootDeclaration(node) { + while (node.kind === 150) { + node = node.parent.parent; + } + return node; + } + function getDeclarationContainer(node) { + node = getRootDeclaration(node); + return node.kind === 193 ? node.parent.parent.parent : node.parent; + } + function getTypeOfPrototypeProperty(prototype) { + var classType = getDeclaredTypeOfSymbol(prototype.parent); + return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType; + } + function getTypeOfPropertyOfType(type, name) { + var prop = getPropertyOfType(type, name); + return prop ? getTypeOfSymbol(prop) : undefined; + } + function getTypeForBindingElement(declaration) { + var pattern = declaration.parent; + var parentType = getTypeForVariableLikeDeclaration(pattern.parent); + if (parentType === unknownType) { + return unknownType; + } + if (!parentType || parentType === anyType) { + if (declaration.initializer) { + return checkExpressionCached(declaration.initializer); + } + return parentType; + } + if (pattern.kind === 148) { + var name = declaration.propertyName || declaration.name; + var type = getTypeOfPropertyOfType(parentType, name.text) || + isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, 1) || + getIndexTypeOfType(parentType, 0); + if (!type) { + error(name, ts.Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), ts.declarationNameToString(name)); + return unknownType; + } + } + else { + if (!isArrayLikeType(parentType)) { + error(pattern, ts.Diagnostics.Type_0_is_not_an_array_type, typeToString(parentType)); + return unknownType; + } + if (!declaration.dotDotDotToken) { + var propName = "" + ts.indexOf(pattern.elements, declaration); + var type = isTupleLikeType(parentType) ? getTypeOfPropertyOfType(parentType, propName) : getIndexTypeOfType(parentType, 1); + if (!type) { + error(declaration, ts.Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName); + return unknownType; + } + } + else { + var type = createArrayType(getIndexTypeOfType(parentType, 1)); + } + } + return type; + } + function getTypeForVariableLikeDeclaration(declaration) { + if (declaration.parent.parent.kind === 182) { + return anyType; + } + if (ts.isBindingPattern(declaration.parent)) { + return getTypeForBindingElement(declaration); + } + if (declaration.type) { + return getTypeFromTypeNode(declaration.type); + } + if (declaration.kind === 128) { + var func = declaration.parent; + if (func.kind === 135 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 134); + if (getter) { + return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); + } + } + var type = getContextuallyTypedParameterType(declaration); + if (type) { + return type; + } + } + if (declaration.initializer) { + return checkExpressionCached(declaration.initializer); + } + if (declaration.kind === 218) { + return checkIdentifier(declaration.name); + } + return undefined; + } + function getTypeFromBindingElement(element) { + if (element.initializer) { + return getWidenedType(checkExpressionCached(element.initializer)); + } + if (ts.isBindingPattern(element.name)) { + return getTypeFromBindingPattern(element.name); + } + return anyType; + } + function getTypeFromObjectBindingPattern(pattern) { + var members = {}; + ts.forEach(pattern.elements, function (e) { + var flags = 4 | 67108864 | (e.initializer ? 536870912 : 0); + var name = e.propertyName || e.name; + var symbol = createSymbol(flags, name.text); + symbol.type = getTypeFromBindingElement(e); + members[symbol.name] = symbol; + }); + return createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined); + } + function getTypeFromArrayBindingPattern(pattern) { + var hasSpreadElement = false; + var elementTypes = []; + ts.forEach(pattern.elements, function (e) { + elementTypes.push(e.kind === 172 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + if (e.dotDotDotToken) { + hasSpreadElement = true; + } + }); + return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes); + } + function getTypeFromBindingPattern(pattern) { + return pattern.kind === 148 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); + } + function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { + var type = getTypeForVariableLikeDeclaration(declaration); + if (type) { + if (reportErrors) { + reportErrorsFromWidening(declaration, type); + } + return declaration.kind !== 217 ? getWidenedType(type) : type; + } + if (ts.isBindingPattern(declaration.name)) { + return getTypeFromBindingPattern(declaration.name); + } + type = declaration.dotDotDotToken ? anyArrayType : anyType; + if (reportErrors && compilerOptions.noImplicitAny) { + var root = getRootDeclaration(declaration); + if (!isPrivateWithinAmbient(root) && !(root.kind === 128 && isPrivateWithinAmbient(root.parent))) { + reportImplicitAnyError(declaration, type); + } + } + return type; + } + function getTypeOfVariableOrParameterOrProperty(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + if (symbol.flags & 134217728) { + return links.type = getTypeOfPrototypeProperty(symbol); + } + var declaration = symbol.valueDeclaration; + if (declaration.kind === 216) { + return links.type = anyType; + } + links.type = resolvingType; + var type = getWidenedTypeForVariableLikeDeclaration(declaration, true); + if (links.type === resolvingType) { + links.type = type; + } + } + else if (links.type === resolvingType) { + links.type = anyType; + if (compilerOptions.noImplicitAny) { + var diagnostic = symbol.valueDeclaration.type ? ts.Diagnostics._0_implicitly_has_type_any_because_it_is_referenced_directly_or_indirectly_in_its_own_type_annotation : ts.Diagnostics._0_implicitly_has_type_any_because_it_is_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer; + error(symbol.valueDeclaration, diagnostic, symbolToString(symbol)); + } + } + return links.type; + } + function getSetAccessorTypeAnnotationNode(accessor) { + return accessor && accessor.parameters.length > 0 && accessor.parameters[0].type; + } + function getAnnotatedAccessorType(accessor) { + if (accessor) { + if (accessor.kind === 134) { + return accessor.type && getTypeFromTypeNode(accessor.type); + } + else { + var setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor); + return setterTypeAnnotation && getTypeFromTypeNode(setterTypeAnnotation); + } + } + return undefined; + } + function getTypeOfAccessors(symbol) { + var links = getSymbolLinks(symbol); + checkAndStoreTypeOfAccessors(symbol, links); + return links.type; + } + function checkAndStoreTypeOfAccessors(symbol, links) { + links = links || getSymbolLinks(symbol); + if (!links.type) { + links.type = resolvingType; + var getter = ts.getDeclarationOfKind(symbol, 134); + var setter = ts.getDeclarationOfKind(symbol, 135); + var type; + var getterReturnType = getAnnotatedAccessorType(getter); + if (getterReturnType) { + type = getterReturnType; + } + else { + var setterParameterType = getAnnotatedAccessorType(setter); + if (setterParameterType) { + type = setterParameterType; + } + else { + if (getter && getter.body) { + type = getReturnTypeFromBody(getter); + } + else { + if (compilerOptions.noImplicitAny) { + error(setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation, symbolToString(symbol)); + } + type = anyType; + } + } + } + if (links.type === resolvingType) { + links.type = type; + } + } + else if (links.type === resolvingType) { + links.type = anyType; + if (compilerOptions.noImplicitAny) { + var getter = ts.getDeclarationOfKind(symbol, 134); + error(getter, 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)); + } + } + } + function getTypeOfFuncClassEnumModule(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + links.type = createObjectType(32768, symbol); + } + return links.type; + } + function getTypeOfEnumMember(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + links.type = getDeclaredTypeOfEnum(getParentOfSymbol(symbol)); + } + return links.type; + } + function getTypeOfImport(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + links.type = getTypeOfSymbol(resolveImport(symbol)); + } + return links.type; + } + function getTypeOfInstantiatedSymbol(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper); + } + return links.type; + } + function getTypeOfSymbol(symbol) { + if (symbol.flags & 16777216) { + return getTypeOfInstantiatedSymbol(symbol); + } + if (symbol.flags & (3 | 4)) { + return getTypeOfVariableOrParameterOrProperty(symbol); + } + if (symbol.flags & (16 | 8192 | 32 | 384 | 512)) { + return getTypeOfFuncClassEnumModule(symbol); + } + if (symbol.flags & 8) { + return getTypeOfEnumMember(symbol); + } + if (symbol.flags & 98304) { + return getTypeOfAccessors(symbol); + } + if (symbol.flags & 8388608) { + return getTypeOfImport(symbol); + } + return unknownType; + } + function getTargetType(type) { + return type.flags & 4096 ? type.target : type; + } + function hasBaseType(type, checkBase) { + return check(type); + function check(type) { + var target = getTargetType(type); + return target === checkBase || ts.forEach(target.baseTypes, check); + } + } + function getTypeParametersOfClassOrInterface(symbol) { + var result; + ts.forEach(symbol.declarations, function (node) { + if (node.kind === 197 || node.kind === 196) { + var declaration = node; + if (declaration.typeParameters && declaration.typeParameters.length) { + ts.forEach(declaration.typeParameters, function (node) { + var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node)); + if (!result) { + result = [tp]; + } + else if (!ts.contains(result, tp)) { + result.push(tp); + } + }); + } + } + }); + return result; + } + function getDeclaredTypeOfClass(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + var type = links.declaredType = createObjectType(1024, symbol); + var typeParameters = getTypeParametersOfClassOrInterface(symbol); + if (typeParameters) { + type.flags |= 4096; + type.typeParameters = typeParameters; + type.instantiations = {}; + type.instantiations[getTypeListId(type.typeParameters)] = type; + type.target = type; + type.typeArguments = type.typeParameters; + } + type.baseTypes = []; + var declaration = ts.getDeclarationOfKind(symbol, 196); + var baseTypeNode = ts.getClassBaseTypeNode(declaration); + if (baseTypeNode) { + var baseType = getTypeFromTypeReferenceNode(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.declaredProperties = getNamedMembers(symbol.members); + type.declaredCallSignatures = emptyArray; + type.declaredConstructSignatures = emptyArray; + type.declaredStringIndexType = getIndexTypeOfSymbol(symbol, 0); + type.declaredNumberIndexType = getIndexTypeOfSymbol(symbol, 1); + } + return links.declaredType; + } + function getDeclaredTypeOfInterface(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + var type = links.declaredType = createObjectType(2048, symbol); + var typeParameters = getTypeParametersOfClassOrInterface(symbol); + if (typeParameters) { + type.flags |= 4096; + type.typeParameters = typeParameters; + type.instantiations = {}; + type.instantiations[getTypeListId(type.typeParameters)] = type; + type.target = type; + type.typeArguments = type.typeParameters; + } + type.baseTypes = []; + ts.forEach(symbol.declarations, function (declaration) { + if (declaration.kind === 197 && ts.getInterfaceBaseTypeNodes(declaration)) { + ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), function (node) { + var baseType = getTypeFromTypeReferenceNode(node); + if (baseType !== unknownType) { + if (getTargetType(baseType).flags & (1024 | 2048)) { + 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(node, ts.Diagnostics.An_interface_may_only_extend_a_class_or_another_interface); + } + } + }); + } + }); + type.declaredProperties = getNamedMembers(symbol.members); + type.declaredCallSignatures = getSignaturesOfSymbol(symbol.members["__call"]); + type.declaredConstructSignatures = getSignaturesOfSymbol(symbol.members["__new"]); + type.declaredStringIndexType = getIndexTypeOfSymbol(symbol, 0); + type.declaredNumberIndexType = getIndexTypeOfSymbol(symbol, 1); + } + return links.declaredType; + } + function getDeclaredTypeOfTypeAlias(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + links.declaredType = resolvingType; + var declaration = ts.getDeclarationOfKind(symbol, 198); + var type = getTypeFromTypeNode(declaration.type); + if (links.declaredType === resolvingType) { + links.declaredType = type; + } + } + else if (links.declaredType === resolvingType) { + links.declaredType = unknownType; + var declaration = ts.getDeclarationOfKind(symbol, 198); + error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); + } + return links.declaredType; + } + function getDeclaredTypeOfEnum(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + var type = createType(128); + type.symbol = symbol; + links.declaredType = type; + } + return links.declaredType; + } + function getDeclaredTypeOfTypeParameter(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + var type = createType(512); + type.symbol = symbol; + if (!ts.getDeclarationOfKind(symbol, 127).constraint) { + type.constraint = noConstraintType; + } + links.declaredType = type; + } + return links.declaredType; + } + function getDeclaredTypeOfImport(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + links.declaredType = getDeclaredTypeOfSymbol(resolveImport(symbol)); + } + return links.declaredType; + } + function getDeclaredTypeOfSymbol(symbol) { + ts.Debug.assert((symbol.flags & 16777216) === 0); + if (symbol.flags & 32) { + return getDeclaredTypeOfClass(symbol); + } + if (symbol.flags & 64) { + return getDeclaredTypeOfInterface(symbol); + } + if (symbol.flags & 524288) { + return getDeclaredTypeOfTypeAlias(symbol); + } + if (symbol.flags & 384) { + return getDeclaredTypeOfEnum(symbol); + } + if (symbol.flags & 262144) { + return getDeclaredTypeOfTypeParameter(symbol); + } + if (symbol.flags & 8388608) { + return getDeclaredTypeOfImport(symbol); + } + return unknownType; + } + function createSymbolTable(symbols) { + var result = {}; + for (var i = 0; i < symbols.length; i++) { + var symbol = symbols[i]; + result[symbol.name] = symbol; + } + return result; + } + function createInstantiatedSymbolTable(symbols, mapper) { + var result = {}; + for (var i = 0; i < symbols.length; i++) { + var symbol = symbols[i]; + result[symbol.name] = instantiateSymbol(symbol, mapper); + } + return result; + } + function addInheritedMembers(symbols, baseSymbols) { + for (var i = 0; i < baseSymbols.length; i++) { + var s = baseSymbols[i]; + if (!ts.hasProperty(symbols, s.name)) { + symbols[s.name] = s; + } + } + } + function addInheritedSignatures(signatures, baseSignatures) { + if (baseSignatures) { + for (var i = 0; i < baseSignatures.length; i++) { + signatures.push(baseSignatures[i]); + } + } + } + function resolveClassOrInterfaceMembers(type) { + var members = type.symbol.members; + var callSignatures = type.declaredCallSignatures; + var constructSignatures = type.declaredConstructSignatures; + var stringIndexType = type.declaredStringIndexType; + var numberIndexType = type.declaredNumberIndexType; + if (type.baseTypes.length) { + members = createSymbolTable(type.declaredProperties); + ts.forEach(type.baseTypes, function (baseType) { + addInheritedMembers(members, getPropertiesOfObjectType(baseType)); + callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(baseType, 0)); + constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(baseType, 1)); + stringIndexType = stringIndexType || getIndexTypeOfType(baseType, 0); + numberIndexType = numberIndexType || getIndexTypeOfType(baseType, 1); + }); + } + setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); + } + function resolveTypeReferenceMembers(type) { + var target = type.target; + var mapper = createTypeMapper(target.typeParameters, type.typeArguments); + var members = createInstantiatedSymbolTable(target.declaredProperties, mapper); + var callSignatures = instantiateList(target.declaredCallSignatures, mapper, instantiateSignature); + var constructSignatures = instantiateList(target.declaredConstructSignatures, mapper, instantiateSignature); + var stringIndexType = target.declaredStringIndexType ? instantiateType(target.declaredStringIndexType, mapper) : undefined; + var numberIndexType = target.declaredNumberIndexType ? instantiateType(target.declaredNumberIndexType, mapper) : undefined; + ts.forEach(target.baseTypes, function (baseType) { + var instantiatedBaseType = instantiateType(baseType, mapper); + addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType)); + callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0)); + constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1)); + stringIndexType = stringIndexType || getIndexTypeOfType(instantiatedBaseType, 0); + numberIndexType = numberIndexType || getIndexTypeOfType(instantiatedBaseType, 1); + }); + setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); + } + function createSignature(declaration, typeParameters, parameters, resolvedReturnType, minArgumentCount, hasRestParameter, hasStringLiterals) { + var sig = new Signature(checker); + sig.declaration = declaration; + sig.typeParameters = typeParameters; + sig.parameters = parameters; + sig.resolvedReturnType = resolvedReturnType; + 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); + } + function getDefaultConstructSignatures(classType) { + if (classType.baseTypes.length) { + var baseType = classType.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.typeParameters; + signature.resolvedReturnType = classType; + return signature; + }); + } + return [createSignature(undefined, classType.typeParameters, emptyArray, classType, 0, false, false)]; + } + function createTupleTypeMemberSymbols(memberTypes) { + var members = {}; + for (var i = 0; i < memberTypes.length; i++) { + var symbol = createSymbol(4 | 67108864, "" + i); + symbol.type = memberTypes[i]; + members[i] = symbol; + } + return members; + } + function resolveTupleTypeMembers(type) { + var arrayType = resolveObjectOrUnionTypeMembers(createArrayType(getUnionType(type.elementTypes))); + var members = createTupleTypeMemberSymbols(type.elementTypes); + addInheritedMembers(members, arrayType.properties); + setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType); + } + function signatureListsIdentical(s, t) { + if (s.length !== t.length) { + return false; + } + for (var i = 0; i < s.length; i++) { + if (!compareSignatures(s[i], t[i], false, compareTypes)) { + return false; + } + } + return true; + } + function getUnionSignatures(types, kind) { + var signatureLists = ts.map(types, function (t) { return getSignaturesOfType(t, kind); }); + var signatures = signatureLists[0]; + for (var i = 0; i < signatures.length; i++) { + if (signatures[i].typeParameters) { + return emptyArray; + } + } + for (var i = 1; i < signatureLists.length; i++) { + if (!signatureListsIdentical(signatures, signatureLists[i])) { + return emptyArray; + } + } + var result = ts.map(signatures, cloneSignature); + for (var i = 0; i < result.length; i++) { + var s = result[i]; + s.resolvedReturnType = undefined; + s.unionSignatures = ts.map(signatureLists, function (signatures) { return signatures[i]; }); + } + return result; + } + function getUnionIndexType(types, kind) { + var indexTypes = []; + for (var i = 0; i < types.length; i++) { + var indexType = getIndexTypeOfType(types[i], kind); + if (!indexType) { + return undefined; + } + indexTypes.push(indexType); + } + return getUnionType(indexTypes); + } + function resolveUnionTypeMembers(type) { + var callSignatures = getUnionSignatures(type.types, 0); + var constructSignatures = getUnionSignatures(type.types, 1); + var stringIndexType = getUnionIndexType(type.types, 0); + var numberIndexType = getUnionIndexType(type.types, 1); + setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType); + } + function resolveAnonymousTypeMembers(type) { + var symbol = type.symbol; + if (symbol.flags & 2048) { + var members = symbol.members; + var callSignatures = getSignaturesOfSymbol(members["__call"]); + var constructSignatures = getSignaturesOfSymbol(members["__new"]); + var stringIndexType = getIndexTypeOfSymbol(symbol, 0); + var numberIndexType = getIndexTypeOfSymbol(symbol, 1); + } + else { + var members = emptySymbols; + var callSignatures = emptyArray; + var constructSignatures = emptyArray; + if (symbol.flags & 1952) { + members = getExportsOfSymbol(symbol); + } + if (symbol.flags & (16 | 8192)) { + callSignatures = getSignaturesOfSymbol(symbol); + } + if (symbol.flags & 32) { + var classType = getDeclaredTypeOfClass(symbol); + constructSignatures = getSignaturesOfSymbol(symbol.members["__constructor"]); + if (!constructSignatures.length) { + constructSignatures = getDefaultConstructSignatures(classType); + } + if (classType.baseTypes.length) { + members = createSymbolTable(getNamedMembers(members)); + addInheritedMembers(members, getPropertiesOfObjectType(getTypeOfSymbol(classType.baseTypes[0].symbol))); + } + } + var stringIndexType = undefined; + var numberIndexType = (symbol.flags & 384) ? stringType : undefined; + } + setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); + } + function resolveObjectOrUnionTypeMembers(type) { + if (!type.members) { + if (type.flags & (1024 | 2048)) { + resolveClassOrInterfaceMembers(type); + } + else if (type.flags & 32768) { + resolveAnonymousTypeMembers(type); + } + else if (type.flags & 8192) { + resolveTupleTypeMembers(type); + } + else if (type.flags & 16384) { + resolveUnionTypeMembers(type); + } + else { + resolveTypeReferenceMembers(type); + } + } + return type; + } + function getPropertiesOfObjectType(type) { + if (type.flags & 48128) { + return resolveObjectOrUnionTypeMembers(type).properties; + } + return emptyArray; + } + function getPropertyOfObjectType(type, name) { + if (type.flags & 48128) { + var resolved = resolveObjectOrUnionTypeMembers(type); + if (ts.hasProperty(resolved.members, name)) { + var symbol = resolved.members[name]; + if (symbolIsValue(symbol)) { + return symbol; + } + } + } + } + function getPropertiesOfUnionType(type) { + var result = []; + ts.forEach(getPropertiesOfType(type.types[0]), function (prop) { + var unionProp = getPropertyOfUnionType(type, prop.name); + if (unionProp) { + result.push(unionProp); + } + }); + return result; + } + function getPropertiesOfType(type) { + if (type.flags & 16384) { + return getPropertiesOfUnionType(type); + } + return getPropertiesOfObjectType(getApparentType(type)); + } + function getApparentType(type) { + if (type.flags & 512) { + do { + type = getConstraintOfTypeParameter(type); + } while (type && type.flags & 512); + if (!type) { + type = emptyObjectType; + } + } + if (type.flags & 258) { + type = globalStringType; + } + else if (type.flags & 132) { + type = globalNumberType; + } + else if (type.flags & 8) { + type = globalBooleanType; + } + else if (type.flags & 1048576) { + type = globalESSymbolType; + } + return type; + } + function createUnionProperty(unionType, name) { + var types = unionType.types; + var props; + for (var i = 0; i < types.length; i++) { + var type = getApparentType(types[i]); + if (type !== unknownType) { + var prop = getPropertyOfType(type, name); + if (!prop) { + return undefined; + } + if (!props) { + props = [prop]; + } + else { + props.push(prop); + } + } + } + var propTypes = []; + var declarations = []; + for (var i = 0; i < props.length; i++) { + var prop = props[i]; + if (prop.declarations) { + declarations.push.apply(declarations, prop.declarations); + } + propTypes.push(getTypeOfSymbol(prop)); + } + var result = createSymbol(4 | 67108864 | 268435456, name); + result.unionType = unionType; + result.declarations = declarations; + result.type = getUnionType(propTypes); + return result; + } + function getPropertyOfUnionType(type, name) { + var properties = type.resolvedProperties || (type.resolvedProperties = {}); + if (ts.hasProperty(properties, name)) { + return properties[name]; + } + var property = createUnionProperty(type, name); + if (property) { + properties[name] = property; + } + return property; + } + function getPropertyOfType(type, name) { + if (type.flags & 16384) { + return getPropertyOfUnionType(type, name); + } + if (!(type.flags & 48128)) { + type = getApparentType(type); + if (!(type.flags & 48128)) { + return undefined; + } + } + var resolved = resolveObjectOrUnionTypeMembers(type); + if (ts.hasProperty(resolved.members, name)) { + var symbol = resolved.members[name]; + if (symbolIsValue(symbol)) { + return symbol; + } + } + if (resolved === anyFunctionType || resolved.callSignatures.length || resolved.constructSignatures.length) { + var symbol = getPropertyOfObjectType(globalFunctionType, name); + if (symbol) + return symbol; + } + return getPropertyOfObjectType(globalObjectType, name); + } + function getSignaturesOfObjectOrUnionType(type, kind) { + if (type.flags & (48128 | 16384)) { + var resolved = resolveObjectOrUnionTypeMembers(type); + return kind === 0 ? resolved.callSignatures : resolved.constructSignatures; + } + return emptyArray; + } + function getSignaturesOfType(type, kind) { + return getSignaturesOfObjectOrUnionType(getApparentType(type), kind); + } + function getIndexTypeOfObjectOrUnionType(type, kind) { + if (type.flags & (48128 | 16384)) { + var resolved = resolveObjectOrUnionTypeMembers(type); + return kind === 0 ? resolved.stringIndexType : resolved.numberIndexType; + } + } + function getIndexTypeOfType(type, kind) { + return getIndexTypeOfObjectOrUnionType(getApparentType(type), kind); + } + function getTypeParametersFromDeclaration(typeParameterDeclarations) { + var result = []; + ts.forEach(typeParameterDeclarations, function (node) { + var tp = getDeclaredTypeOfTypeParameter(node.symbol); + if (!ts.contains(result, tp)) { + result.push(tp); + } + }); + return result; + } + function getSignatureFromDeclaration(declaration) { + var links = getNodeLinks(declaration); + if (!links.resolvedSignature) { + var classType = declaration.kind === 133 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; + var typeParameters = classType ? classType.typeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; + var parameters = []; + var hasStringLiterals = false; + var minArgumentCount = -1; + for (var i = 0, n = declaration.parameters.length; i < n; i++) { + var param = declaration.parameters[i]; + parameters.push(param.symbol); + if (param.type && param.type.kind === 8) { + hasStringLiterals = true; + } + if (minArgumentCount < 0) { + if (param.initializer || param.questionToken || param.dotDotDotToken) { + minArgumentCount = i; + } + } + } + if (minArgumentCount < 0) { + minArgumentCount = declaration.parameters.length; + } + var returnType; + if (classType) { + returnType = classType; + } + else if (declaration.type) { + returnType = getTypeFromTypeNode(declaration.type); + } + else { + if (declaration.kind === 134 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 135); + returnType = getAnnotatedAccessorType(setter); + } + if (!returnType && ts.nodeIsMissing(declaration.body)) { + returnType = anyType; + } + } + links.resolvedSignature = createSignature(declaration, typeParameters, parameters, returnType, minArgumentCount, ts.hasRestParameters(declaration), hasStringLiterals); + } + return links.resolvedSignature; + } + function getSignaturesOfSymbol(symbol) { + if (!symbol) + return emptyArray; + var result = []; + for (var i = 0, len = symbol.declarations.length; i < len; i++) { + var node = symbol.declarations[i]; + switch (node.kind) { + case 140: + case 141: + case 195: + case 132: + case 131: + case 133: + case 136: + case 137: + case 138: + case 134: + case 135: + case 160: + case 161: + if (i > 0 && node.body) { + var previous = symbol.declarations[i - 1]; + if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { + break; + } + } + result.push(getSignatureFromDeclaration(node)); + } + } + return result; + } + function getReturnTypeOfSignature(signature) { + if (!signature.resolvedReturnType) { + signature.resolvedReturnType = resolvingType; + if (signature.target) { + var type = instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper); + } + else if (signature.unionSignatures) { + var type = getUnionType(ts.map(signature.unionSignatures, getReturnTypeOfSignature)); + } + else { + var type = getReturnTypeFromBody(signature.declaration); + } + if (signature.resolvedReturnType === resolvingType) { + signature.resolvedReturnType = type; + } + } + else if (signature.resolvedReturnType === resolvingType) { + signature.resolvedReturnType = anyType; + if (compilerOptions.noImplicitAny) { + var declaration = signature.declaration; + if (declaration.name) { + error(declaration.name, 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, ts.declarationNameToString(declaration.name)); + } + else { + error(declaration, ts.Diagnostics.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); + } + } + } + return signature.resolvedReturnType; + } + function getRestTypeOfSignature(signature) { + if (signature.hasRestParameter) { + var type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + if (type.flags & 4096 && type.target === globalArrayType) { + return type.typeArguments[0]; + } + } + return anyType; + } + function getSignatureInstantiation(signature, typeArguments) { + return instantiateSignature(signature, createTypeMapper(signature.typeParameters, typeArguments), true); + } + function getErasedSignature(signature) { + if (!signature.typeParameters) + return signature; + if (!signature.erasedSignatureCache) { + if (signature.target) { + signature.erasedSignatureCache = instantiateSignature(getErasedSignature(signature.target), signature.mapper); + } + else { + signature.erasedSignatureCache = instantiateSignature(signature, createTypeEraser(signature.typeParameters), true); + } + } + return signature.erasedSignatureCache; + } + function getOrCreateTypeFromSignature(signature) { + if (!signature.isolatedSignatureType) { + var isConstructor = signature.declaration.kind === 133 || signature.declaration.kind === 137; + var type = createObjectType(32768 | 65536); + type.members = emptySymbols; + type.properties = emptyArray; + type.callSignatures = !isConstructor ? [signature] : emptyArray; + type.constructSignatures = isConstructor ? [signature] : emptyArray; + signature.isolatedSignatureType = type; + } + return signature.isolatedSignatureType; + } + function getIndexSymbol(symbol) { + return symbol.members["__index"]; + } + function getIndexDeclarationOfSymbol(symbol, kind) { + var syntaxKind = kind === 1 ? 119 : 121; + var indexSymbol = getIndexSymbol(symbol); + if (indexSymbol) { + var len = indexSymbol.declarations.length; + for (var i = 0; i < len; i++) { + var node = indexSymbol.declarations[i]; + if (node.parameters.length === 1) { + var parameter = node.parameters[0]; + if (parameter && parameter.type && parameter.type.kind === syntaxKind) { + return node; + } + } + } + } + return undefined; + } + function getIndexTypeOfSymbol(symbol, kind) { + var declaration = getIndexDeclarationOfSymbol(symbol, kind); + return declaration ? declaration.type ? getTypeFromTypeNode(declaration.type) : anyType : undefined; + } + function getConstraintOfTypeParameter(type) { + if (!type.constraint) { + if (type.target) { + var targetConstraint = getConstraintOfTypeParameter(type.target); + type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; + } + else { + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 127).constraint); + } + } + return type.constraint === noConstraintType ? undefined : type.constraint; + } + function getTypeListId(types) { + switch (types.length) { + case 1: + return "" + types[0].id; + case 2: + return types[0].id + "," + types[1].id; + default: + var result = ""; + for (var i = 0; i < types.length; i++) { + if (i > 0) + result += ","; + result += types[i].id; + } + return result; + } + } + function getWideningFlagsOfTypes(types) { + var result = 0; + for (var i = 0; i < types.length; i++) { + result |= types[i].flags; + } + return result & 786432; + } + function createTypeReference(target, typeArguments) { + var id = getTypeListId(typeArguments); + var type = target.instantiations[id]; + if (!type) { + var flags = 4096 | getWideningFlagsOfTypes(typeArguments); + type = target.instantiations[id] = createObjectType(flags, target.symbol); + type.target = target; + type.typeArguments = typeArguments; + } + return type; + } + function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode, typeParameterSymbol) { + var links = getNodeLinks(typeReferenceNode); + if (links.isIllegalTypeReferenceInConstraint !== undefined) { + return links.isIllegalTypeReferenceInConstraint; + } + var currentNode = typeReferenceNode; + while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { + currentNode = currentNode.parent; + } + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 127; + return links.isIllegalTypeReferenceInConstraint; + } + function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { + var typeParameterSymbol; + function check(n) { + if (n.kind === 139 && n.typeName.kind === 64) { + 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; }); + } + } + if (links.isIllegalTypeReferenceInConstraint) { + error(typeParameter, ts.Diagnostics.Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list); + } + } + ts.forEachChild(n, check); + } + if (typeParameter.constraint) { + typeParameterSymbol = getSymbolOfNode(typeParameter); + check(typeParameter.constraint); + } + } + function getTypeFromTypeReferenceNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var symbol = resolveEntityName(node, node.typeName, 793056); + if (symbol) { + var type; + if ((symbol.flags & 262144) && isTypeParameterReferenceIllegalInConstraint(node, symbol)) { + type = unknownType; + } + else { + type = getDeclaredTypeOfSymbol(symbol); + if (type.flags & (1024 | 2048) && type.flags & 4096) { + var typeParameters = type.typeParameters; + if (node.typeArguments && node.typeArguments.length === typeParameters.length) { + type = createTypeReference(type, ts.map(node.typeArguments, getTypeFromTypeNode)); + } + else { + error(node, ts.Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, undefined, 1), typeParameters.length); + type = undefined; + } + } + else { + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, typeToString(type)); + type = undefined; + } + } + } + } + links.resolvedType = type || unknownType; + } + return links.resolvedType; + } + function getTypeFromTypeQueryNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getWidenedType(checkExpressionOrQualifiedName(node.exprName)); + } + return links.resolvedType; + } + function getTypeOfGlobalSymbol(symbol, arity) { + function getTypeDeclaration(symbol) { + var declarations = symbol.declarations; + for (var i = 0; i < declarations.length; i++) { + var declaration = declarations[i]; + switch (declaration.kind) { + case 196: + case 197: + case 199: + return declaration; + } + } + } + if (!symbol) { + return emptyObjectType; + } + var type = getDeclaredTypeOfSymbol(symbol); + if (!(type.flags & 48128)) { + error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name); + return emptyObjectType; + } + if ((type.typeParameters ? type.typeParameters.length : 0) !== arity) { + error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbol.name, arity); + return emptyObjectType; + } + return type; + } + function getGlobalValueSymbol(name) { + return getGlobalSymbol(name, 107455, ts.Diagnostics.Cannot_find_global_value_0); + } + function getGlobalTypeSymbol(name) { + return getGlobalSymbol(name, 793056, ts.Diagnostics.Cannot_find_global_type_0); + } + function getGlobalSymbol(name, meaning, diagnostic) { + return resolveName(undefined, name, meaning, diagnostic, name); + } + function getGlobalType(name) { + return getTypeOfGlobalSymbol(getGlobalTypeSymbol(name), 0); + } + function getGlobalESSymbolConstructorSymbol() { + return globalESSymbolConstructorSymbol || (globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol")); + } + function createArrayType(elementType) { + var arrayType = globalArrayType || getDeclaredTypeOfSymbol(globalArraySymbol); + return arrayType !== emptyObjectType ? createTypeReference(arrayType, [elementType]) : emptyObjectType; + } + function getTypeFromArrayTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType)); + } + return links.resolvedType; + } + function createTupleType(elementTypes) { + var id = getTypeListId(elementTypes); + var type = tupleTypes[id]; + if (!type) { + type = tupleTypes[id] = createObjectType(8192); + type.elementTypes = elementTypes; + } + return type; + } + function getTypeFromTupleTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = createTupleType(ts.map(node.elementTypes, getTypeFromTypeNode)); + } + return links.resolvedType; + } + function addTypeToSortedSet(sortedSet, type) { + if (type.flags & 16384) { + addTypesToSortedSet(sortedSet, type.types); + } + else { + var i = 0; + var 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); + } + } + } + function addTypesToSortedSet(sortedTypes, types) { + for (var i = 0, len = types.length; i < len; i++) { + addTypeToSortedSet(sortedTypes, types[i]); + } + } + function isSubtypeOfAny(candidate, types) { + for (var i = 0, len = types.length; i < len; i++) { + if (candidate !== types[i] && isTypeSubtypeOf(candidate, types[i])) { + return true; + } + } + return false; + } + function removeSubtypes(types) { + var i = types.length; + while (i > 0) { + i--; + if (isSubtypeOfAny(types[i], types)) { + types.splice(i, 1); + } + } + } + function containsAnyType(types) { + for (var i = 0; i < types.length; i++) { + if (types[i].flags & 1) { + return true; + } + } + return false; + } + function removeAllButLast(types, typeToRemove) { + var i = types.length; + while (i > 0 && types.length > 1) { + i--; + if (types[i] === typeToRemove) { + types.splice(i, 1); + } + } + } + function getUnionType(types, noSubtypeReduction) { + if (types.length === 0) { + return emptyObjectType; + } + var sortedTypes = []; + addTypesToSortedSet(sortedTypes, types); + if (noSubtypeReduction) { + if (containsAnyType(sortedTypes)) { + return anyType; + } + removeAllButLast(sortedTypes, undefinedType); + removeAllButLast(sortedTypes, nullType); + } + else { + removeSubtypes(sortedTypes); + } + if (sortedTypes.length === 1) { + return sortedTypes[0]; + } + var id = getTypeListId(sortedTypes); + var type = unionTypes[id]; + if (!type) { + type = unionTypes[id] = createObjectType(16384 | getWideningFlagsOfTypes(sortedTypes)); + type.types = sortedTypes; + } + return type; + } + function getTypeFromUnionTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), true); + } + return links.resolvedType; + } + function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = createObjectType(32768, node.symbol); + } + return links.resolvedType; + } + function getStringLiteralType(node) { + if (ts.hasProperty(stringLiteralTypes, node.text)) { + return stringLiteralTypes[node.text]; + } + var type = stringLiteralTypes[node.text] = createType(256); + type.text = ts.getTextOfNode(node); + return type; + } + function getTypeFromStringLiteral(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getStringLiteralType(node); + } + return links.resolvedType; + } + function getTypeFromTypeNode(node) { + switch (node.kind) { + case 112: + return anyType; + case 121: + return stringType; + case 119: + return numberType; + case 113: + return booleanType; + case 122: + return esSymbolType; + case 98: + return voidType; + case 8: + return getTypeFromStringLiteral(node); + case 139: + return getTypeFromTypeReferenceNode(node); + case 142: + return getTypeFromTypeQueryNode(node); + case 144: + return getTypeFromArrayTypeNode(node); + case 145: + return getTypeFromTupleTypeNode(node); + case 146: + return getTypeFromUnionTypeNode(node); + case 147: + return getTypeFromTypeNode(node.type); + case 140: + case 141: + case 143: + return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); + case 64: + case 125: + var symbol = getSymbolInfo(node); + return symbol && getDeclaredTypeOfSymbol(symbol); + default: + return unknownType; + } + } + function instantiateList(items, mapper, instantiator) { + if (items && items.length) { + var result = []; + for (var i = 0; i < items.length; i++) { + result.push(instantiator(items[i], mapper)); + } + return result; + } + return items; + } + function createUnaryTypeMapper(source, target) { + return function (t) { return t === source ? target : t; }; + } + function createBinaryTypeMapper(source1, target1, source2, target2) { + return function (t) { return t === source1 ? target1 : t === source2 ? target2 : t; }; + } + function createTypeMapper(sources, targets) { + switch (sources.length) { + case 1: return createUnaryTypeMapper(sources[0], targets[0]); + case 2: return createBinaryTypeMapper(sources[0], targets[0], sources[1], targets[1]); + } + return function (t) { + for (var i = 0; i < sources.length; i++) { + if (t === sources[i]) + return targets[i]; + } + return t; + }; + } + function createUnaryTypeEraser(source) { + return function (t) { return t === source ? anyType : t; }; + } + function createBinaryTypeEraser(source1, source2) { + return function (t) { return t === source1 || t === source2 ? anyType : t; }; + } + function createTypeEraser(sources) { + switch (sources.length) { + case 1: return createUnaryTypeEraser(sources[0]); + case 2: return createBinaryTypeEraser(sources[0], sources[1]); + } + return function (t) { + for (var i = 0; i < sources.length; i++) { + if (t === sources[i]) + return anyType; + } + return t; + }; + } + function createInferenceMapper(context) { + return function (t) { + for (var i = 0; i < context.typeParameters.length; i++) { + if (t === context.typeParameters[i]) { + return getInferredType(context, i); + } + } + return t; + }; + } + function identityMapper(type) { + return type; + } + function combineTypeMappers(mapper1, mapper2) { + return function (t) { return mapper2(mapper1(t)); }; + } + function instantiateTypeParameter(typeParameter, mapper) { + var result = createType(512); + result.symbol = typeParameter.symbol; + if (typeParameter.constraint) { + result.constraint = instantiateType(typeParameter.constraint, mapper); + } + else { + result.target = typeParameter; + result.mapper = mapper; + } + return result; + } + function instantiateSignature(signature, mapper, eraseTypeParameters) { + if (signature.typeParameters && !eraseTypeParameters) { + var 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); + result.target = signature; + result.mapper = mapper; + return result; + } + function instantiateSymbol(symbol, mapper) { + if (symbol.flags & 16777216) { + var links = getSymbolLinks(symbol); + symbol = links.target; + mapper = combineTypeMappers(links.mapper, mapper); + } + var result = createSymbol(16777216 | 67108864 | symbol.flags, symbol.name); + result.declarations = symbol.declarations; + result.parent = symbol.parent; + result.target = symbol; + result.mapper = mapper; + if (symbol.valueDeclaration) { + result.valueDeclaration = symbol.valueDeclaration; + } + return result; + } + function instantiateAnonymousType(type, mapper) { + var result = createObjectType(32768, type.symbol); + result.properties = instantiateList(getPropertiesOfObjectType(type), mapper, instantiateSymbol); + result.members = createSymbolTable(result.properties); + result.callSignatures = instantiateList(getSignaturesOfType(type, 0), mapper, instantiateSignature); + result.constructSignatures = instantiateList(getSignaturesOfType(type, 1), mapper, instantiateSignature); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); + if (stringIndexType) + result.stringIndexType = instantiateType(stringIndexType, mapper); + if (numberIndexType) + result.numberIndexType = instantiateType(numberIndexType, mapper); + return result; + } + function instantiateType(type, mapper) { + if (mapper !== identityMapper) { + if (type.flags & 512) { + return mapper(type); + } + if (type.flags & 32768) { + return type.symbol && type.symbol.flags & (16 | 8192 | 2048 | 4096) ? instantiateAnonymousType(type, mapper) : type; + } + if (type.flags & 4096) { + return createTypeReference(type.target, instantiateList(type.typeArguments, mapper, instantiateType)); + } + if (type.flags & 8192) { + return createTupleType(instantiateList(type.elementTypes, mapper, instantiateType)); + } + if (type.flags & 16384) { + return getUnionType(instantiateList(type.types, mapper, instantiateType), true); + } + } + return type; + } + function isContextSensitive(node) { + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); + switch (node.kind) { + case 160: + case 161: + return isContextSensitiveFunctionLikeDeclaration(node); + case 152: + return ts.forEach(node.properties, isContextSensitive); + case 151: + return ts.forEach(node.elements, isContextSensitive); + case 168: + return isContextSensitive(node.whenTrue) || + isContextSensitive(node.whenFalse); + case 167: + return node.operatorToken.kind === 49 && + (isContextSensitive(node.left) || isContextSensitive(node.right)); + case 217: + return isContextSensitive(node.initializer); + case 132: + case 131: + return isContextSensitiveFunctionLikeDeclaration(node); + case 159: + return isContextSensitive(node.expression); + } + return false; + } + function isContextSensitiveFunctionLikeDeclaration(node) { + return !node.typeParameters && node.parameters.length && !ts.forEach(node.parameters, function (p) { return p.type; }); + } + function getTypeWithoutConstructors(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.constructSignatures = emptyArray; + type = result; + } + } + return type; + } + var subtypeRelation = {}; + var assignableRelation = {}; + var identityRelation = {}; + function isTypeIdenticalTo(source, target) { + return checkTypeRelatedTo(source, target, identityRelation, undefined); + } + function compareTypes(source, target) { + return checkTypeRelatedTo(source, target, identityRelation, undefined) ? -1 : 0; + } + function isTypeSubtypeOf(source, target) { + return checkTypeSubtypeOf(source, target, undefined); + } + function isTypeAssignableTo(source, target) { + return checkTypeAssignableTo(source, target, undefined); + } + 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 isSignatureAssignableTo(source, target) { + var sourceType = getOrCreateTypeFromSignature(source); + var targetType = getOrCreateTypeFromSignature(target); + return checkTypeRelatedTo(sourceType, targetType, assignableRelation, undefined); + } + function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain) { + var errorInfo; + var sourceStack; + var targetStack; + var maybeStack; + var expandingFlags; + var depth = 0; + var overflow = false; + ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking"); + var result = isRelatedTo(source, target, errorNode !== undefined, headMessage); + if (overflow) { + error(errorNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target)); + } + else if (errorInfo) { + if (errorInfo.next === undefined) { + errorInfo = undefined; + isRelatedTo(source, target, errorNode !== undefined, headMessage, true); + } + if (containingMessageChain) { + errorInfo = ts.concatenateDiagnosticMessageChains(containingMessageChain, errorInfo); + } + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo)); + } + return result !== 0; + function reportError(message, arg0, arg1, arg2) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2); + } + function isRelatedTo(source, target, reportErrors, headMessage, elaborateErrors) { + if (elaborateErrors === void 0) { elaborateErrors = false; } + var result; + if (source === target) + return -1; + if (relation !== identityRelation) { + if (target.flags & 1) + return -1; + if (source === undefinedType) + return -1; + if (source === nullType && target !== undefinedType) + return -1; + if (source.flags & 128 && target === numberType) + return -1; + if (source.flags & 256 && target === stringType) + return -1; + if (relation === assignableRelation) { + if (source.flags & 1) + return -1; + if (source === numberType && target.flags & 128) + return -1; + } + } + if (source.flags & 16384 || target.flags & 16384) { + if (relation === identityRelation) { + if (source.flags & 16384 && target.flags & 16384) { + if (result = unionTypeRelatedToUnionType(source, target)) { + if (result &= unionTypeRelatedToUnionType(target, source)) { + return result; + } + } + } + else if (source.flags & 16384) { + if (result = unionTypeRelatedToType(source, target, reportErrors)) { + return result; + } + } + else { + if (result = unionTypeRelatedToType(target, source, reportErrors)) { + return result; + } + } + } + else { + if (source.flags & 16384) { + if (result = unionTypeRelatedToType(source, target, reportErrors)) { + return result; + } + } + else { + if (result = typeRelatedToUnionType(source, target, reportErrors)) { + return result; + } + } + } + } + else if (source.flags & 512 && target.flags & 512) { + if (result = typeParameterRelatedTo(source, target, reportErrors)) { + return result; + } + } + else { + var saveErrorInfo = errorInfo; + if (source.flags & 4096 && target.flags & 4096 && source.target === target.target) { + if (result = typesRelatedTo(source.typeArguments, target.typeArguments, reportErrors)) { + return result; + } + } + var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo; + var sourceOrApparentType = relation === identityRelation ? source : getApparentType(source); + if (sourceOrApparentType.flags & 48128 && target.flags & 48128 && + (result = objectTypeRelatedTo(sourceOrApparentType, target, reportStructuralErrors, elaborateErrors))) { + errorInfo = saveErrorInfo; + return result; + } + } + if (reportErrors) { + headMessage = headMessage || ts.Diagnostics.Type_0_is_not_assignable_to_type_1; + var sourceType = typeToString(source); + var targetType = typeToString(target); + if (sourceType === targetType) { + sourceType = typeToString(source, undefined, 128); + targetType = typeToString(target, undefined, 128); + } + reportError(headMessage, sourceType, targetType); + } + return 0; + } + function unionTypeRelatedToUnionType(source, target) { + var result = -1; + var sourceTypes = source.types; + for (var i = 0, len = sourceTypes.length; i < len; i++) { + var related = typeRelatedToUnionType(sourceTypes[i], target, false); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function typeRelatedToUnionType(source, target, reportErrors) { + var targetTypes = target.types; + for (var i = 0, len = targetTypes.length; i < len; i++) { + var related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1); + if (related) { + return related; + } + } + return 0; + } + function unionTypeRelatedToType(source, target, reportErrors) { + var result = -1; + var sourceTypes = source.types; + for (var i = 0, len = sourceTypes.length; i < len; i++) { + var related = isRelatedTo(sourceTypes[i], target, reportErrors); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function typesRelatedTo(sources, targets, reportErrors) { + var result = -1; + for (var i = 0, len = sources.length; i < len; i++) { + var related = isRelatedTo(sources[i], targets[i], reportErrors); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function typeParameterRelatedTo(source, target, reportErrors) { + if (relation === identityRelation) { + if (source.symbol.name !== target.symbol.name) { + return 0; + } + if (source.constraint === target.constraint) { + return -1; + } + if (source.constraint === noConstraintType || target.constraint === noConstraintType) { + return 0; + } + return isRelatedTo(source.constraint, target.constraint, reportErrors); + } + else { + while (true) { + var constraint = getConstraintOfTypeParameter(source); + if (constraint === target) + return -1; + if (!(constraint && constraint.flags & 512)) + break; + source = constraint; + } + return 0; + } + } + function objectTypeRelatedTo(source, target, reportErrors, elaborateErrors) { + if (elaborateErrors === void 0) { elaborateErrors = false; } + if (overflow) { + return 0; + } + var id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id; + var related = relation[id]; + if (related !== undefined) { + if (!elaborateErrors || (related === 3)) { + return related === 1 ? -1 : 0; + } + } + if (depth > 0) { + for (var i = 0; i < depth; i++) { + if (maybeStack[i][id]) { + return 1; + } + } + if (depth === 100) { + overflow = true; + return 0; + } + } + else { + sourceStack = []; + targetStack = []; + maybeStack = []; + expandingFlags = 0; + } + sourceStack[depth] = source; + targetStack[depth] = target; + maybeStack[depth] = {}; + maybeStack[depth][id] = 1; + depth++; + var saveExpandingFlags = expandingFlags; + if (!(expandingFlags & 1) && isDeeplyNestedGeneric(source, sourceStack)) + expandingFlags |= 1; + if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack)) + expandingFlags |= 2; + if (expandingFlags === 3) { + var result = 1; + } + else { + var result = propertiesRelatedTo(source, target, reportErrors); + if (result) { + result &= signaturesRelatedTo(source, target, 0, reportErrors); + if (result) { + result &= signaturesRelatedTo(source, target, 1, reportErrors); + if (result) { + result &= stringIndexTypesRelatedTo(source, target, reportErrors); + if (result) { + result &= numberIndexTypesRelatedTo(source, target, reportErrors); + } + } + } + } + } + expandingFlags = saveExpandingFlags; + depth--; + if (result) { + var maybeCache = maybeStack[depth]; + var destinationCache = (result === -1 || depth === 0) ? relation : maybeStack[depth - 1]; + ts.copyMap(maybeCache, destinationCache); + } + else { + relation[id] = reportErrors ? 3 : 2; + } + return result; + } + function isDeeplyNestedGeneric(type, stack) { + if (type.flags & 4096 && depth >= 10) { + var target = type.target; + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & 4096 && t.target === target) { + count++; + if (count >= 10) + return true; + } + } + } + return false; + } + function propertiesRelatedTo(source, target, reportErrors) { + if (relation === identityRelation) { + return propertiesIdenticalTo(source, target); + } + var result = -1; + var properties = getPropertiesOfObjectType(target); + var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 131072); + for (var i = 0; i < properties.length; i++) { + var targetProp = properties[i]; + var sourceProp = getPropertyOfType(source, targetProp.name); + if (sourceProp !== targetProp) { + if (!sourceProp) { + if (!(targetProp.flags & 536870912) || requireOptionalProperties) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source)); + } + return 0; + } + } + else if (!(targetProp.flags & 134217728)) { + var sourceFlags = getDeclarationFlagsFromSymbol(sourceProp); + var targetFlags = getDeclarationFlagsFromSymbol(targetProp); + if (sourceFlags & 32 || targetFlags & 32) { + if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) { + if (reportErrors) { + if (sourceFlags & 32 && targetFlags & 32) { + reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp)); + } + else { + reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourceFlags & 32 ? source : target), typeToString(sourceFlags & 32 ? target : source)); + } + } + return 0; + } + } + else if (targetFlags & 64) { + var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32; + var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined; + var targetClass = getDeclaredTypeOfSymbol(targetProp.parent); + if (!sourceClass || !hasBaseType(sourceClass, targetClass)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(sourceClass || source), typeToString(targetClass)); + } + return 0; + } + } + else if (sourceFlags & 64) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); + } + return 0; + } + var related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors); + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp)); + } + return 0; + } + result &= related; + if (sourceProp.flags & 536870912 && !(targetProp.flags & 536870912)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); + } + return 0; + } + } + } + } + return result; + } + function propertiesIdenticalTo(source, target) { + var sourceProperties = getPropertiesOfObjectType(source); + var targetProperties = getPropertiesOfObjectType(target); + if (sourceProperties.length !== targetProperties.length) { + return 0; + } + var result = -1; + for (var i = 0, len = sourceProperties.length; i < len; ++i) { + var sourceProp = sourceProperties[i]; + var targetProp = getPropertyOfObjectType(target, sourceProp.name); + if (!targetProp) { + return 0; + } + var related = compareProperties(sourceProp, targetProp, isRelatedTo); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function signaturesRelatedTo(source, target, kind, reportErrors) { + if (relation === identityRelation) { + return signaturesIdenticalTo(source, target, kind); + } + if (target === anyFunctionType || source === anyFunctionType) { + return -1; + } + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + var result = -1; + var saveErrorInfo = errorInfo; + outer: for (var i = 0; i < targetSignatures.length; i++) { + var t = targetSignatures[i]; + if (!t.hasStringLiterals || target.flags & 65536) { + var localErrors = reportErrors; + for (var j = 0; j < sourceSignatures.length; j++) { + var s = sourceSignatures[j]; + if (!s.hasStringLiterals || source.flags & 65536) { + var related = signatureRelatedTo(s, t, localErrors); + if (related) { + result &= related; + errorInfo = saveErrorInfo; + continue outer; + } + localErrors = false; + } + } + return 0; + } + } + return result; + } + function signatureRelatedTo(source, target, reportErrors) { + if (source === target) { + return -1; + } + if (!target.hasRestParameter && source.minArgumentCount > target.parameters.length) { + return 0; + } + var sourceMax = source.parameters.length; + var targetMax = target.parameters.length; + var checkCount; + if (source.hasRestParameter && target.hasRestParameter) { + checkCount = sourceMax > targetMax ? sourceMax : targetMax; + sourceMax--; + targetMax--; + } + else if (source.hasRestParameter) { + sourceMax--; + checkCount = targetMax; + } + else if (target.hasRestParameter) { + targetMax--; + checkCount = sourceMax; + } + else { + checkCount = sourceMax < targetMax ? sourceMax : targetMax; + } + source = getErasedSignature(source); + target = getErasedSignature(target); + var result = -1; + for (var i = 0; i < checkCount; i++) { + var s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source); + var t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target); + var saveErrorInfo = errorInfo; + var related = isRelatedTo(s, t, reportErrors); + if (!related) { + related = isRelatedTo(t, s, false); + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, source.parameters[i < sourceMax ? i : sourceMax].name, target.parameters[i < targetMax ? i : targetMax].name); + } + return 0; + } + errorInfo = saveErrorInfo; + } + result &= related; + } + var t = getReturnTypeOfSignature(target); + if (t === voidType) + return result; + var s = getReturnTypeOfSignature(source); + return result & isRelatedTo(s, t, reportErrors); + } + function signaturesIdenticalTo(source, target, kind) { + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + if (sourceSignatures.length !== targetSignatures.length) { + return 0; + } + var result = -1; + for (var i = 0, len = sourceSignatures.length; i < len; ++i) { + var related = compareSignatures(sourceSignatures[i], targetSignatures[i], true, isRelatedTo); + if (!related) { + return 0; + } + result &= related; + } + return result; + } + function stringIndexTypesRelatedTo(source, target, reportErrors) { + if (relation === identityRelation) { + return indexTypesIdenticalTo(0, source, target); + } + var targetType = getIndexTypeOfType(target, 0); + if (targetType) { + var sourceType = getIndexTypeOfType(source, 0); + if (!sourceType) { + if (reportErrors) { + reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source)); + } + return 0; + } + var related = isRelatedTo(sourceType, targetType, reportErrors); + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Index_signatures_are_incompatible); + } + return 0; + } + return related; + } + return -1; + } + function numberIndexTypesRelatedTo(source, target, reportErrors) { + if (relation === identityRelation) { + return indexTypesIdenticalTo(1, source, target); + } + var targetType = getIndexTypeOfType(target, 1); + if (targetType) { + var sourceStringType = getIndexTypeOfType(source, 0); + var sourceNumberType = getIndexTypeOfType(source, 1); + if (!(sourceStringType || sourceNumberType)) { + if (reportErrors) { + reportError(ts.Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source)); + } + return 0; + } + if (sourceStringType && sourceNumberType) { + var related = isRelatedTo(sourceStringType, targetType, false) || isRelatedTo(sourceNumberType, targetType, reportErrors); + } + else { + var related = isRelatedTo(sourceStringType || sourceNumberType, targetType, reportErrors); + } + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Index_signatures_are_incompatible); + } + return 0; + } + return related; + } + return -1; + } + function indexTypesIdenticalTo(indexKind, source, target) { + var targetType = getIndexTypeOfType(target, indexKind); + var sourceType = getIndexTypeOfType(source, indexKind); + if (!sourceType && !targetType) { + return -1; + } + if (sourceType && targetType) { + return isRelatedTo(sourceType, targetType); + } + return 0; + } + } + function isPropertyIdenticalTo(sourceProp, targetProp) { + return compareProperties(sourceProp, targetProp, compareTypes) !== 0; + } + function compareProperties(sourceProp, targetProp, compareTypes) { + if (sourceProp === targetProp) { + return -1; + } + var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 | 64); + var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 | 64); + if (sourcePropAccessibility !== targetPropAccessibility) { + return 0; + } + if (sourcePropAccessibility) { + if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) { + return 0; + } + } + else { + if ((sourceProp.flags & 536870912) !== (targetProp.flags & 536870912)) { + return 0; + } + } + return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); + } + function compareSignatures(source, target, compareReturnTypes, compareTypes) { + if (source === target) { + return -1; + } + if (source.parameters.length !== target.parameters.length || + source.minArgumentCount !== target.minArgumentCount || + source.hasRestParameter !== target.hasRestParameter) { + return 0; + } + var result = -1; + if (source.typeParameters && target.typeParameters) { + if (source.typeParameters.length !== target.typeParameters.length) { + return 0; + } + for (var i = 0, len = source.typeParameters.length; i < len; ++i) { + var related = compareTypes(source.typeParameters[i], target.typeParameters[i]); + if (!related) { + return 0; + } + result &= related; + } + } + else if (source.typeParameters || target.typeParameters) { + return 0; + } + source = getErasedSignature(source); + target = getErasedSignature(target); + for (var i = 0, len = source.parameters.length; i < len; i++) { + var s = source.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]); + var t = target.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]); + var related = compareTypes(s, t); + if (!related) { + return 0; + } + result &= related; + } + if (compareReturnTypes) { + result &= compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } + return result; + } + function isSupertypeOfEach(candidate, types) { + for (var i = 0, len = types.length; i < len; i++) { + if (candidate !== types[i] && !isTypeSubtypeOf(types[i], candidate)) + return false; + } + return true; + } + function getCommonSupertype(types) { + return ts.forEach(types, function (t) { return isSupertypeOfEach(t, types) ? t : undefined; }); + } + function reportNoCommonSupertypeError(types, errorLocation, errorMessageChainHead) { + var bestSupertype; + var bestSupertypeDownfallType; + var bestSupertypeScore = 0; + for (var i = 0; i < types.length; i++) { + var score = 0; + var downfallType = undefined; + for (var j = 0; j < types.length; j++) { + if (isTypeSubtypeOf(types[j], types[i])) { + score++; + } + else if (!downfallType) { + downfallType = types[j]; + } + } + if (score > bestSupertypeScore) { + bestSupertype = types[i]; + bestSupertypeDownfallType = downfallType; + bestSupertypeScore = score; + } + if (bestSupertypeScore === types.length - 1) { + break; + } + } + checkTypeSubtypeOf(bestSupertypeDownfallType, bestSupertype, errorLocation, ts.Diagnostics.Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0, errorMessageChainHead); + } + function isArrayType(type) { + return type.flags & 4096 && type.target === globalArrayType; + } + function isArrayLikeType(type) { + return !(type.flags & (32 | 64)) && isTypeAssignableTo(type, anyArrayType); + } + function isTupleLikeType(type) { + return !!getPropertyOfType(type, "0"); + } + function getWidenedTypeOfObjectLiteral(type) { + var properties = getPropertiesOfObjectType(type); + var members = {}; + ts.forEach(properties, function (p) { + var propType = getTypeOfSymbol(p); + var widenedType = getWidenedType(propType); + if (propType !== widenedType) { + var symbol = createSymbol(p.flags | 67108864, p.name); + symbol.declarations = p.declarations; + symbol.parent = p.parent; + symbol.type = widenedType; + symbol.target = p; + if (p.valueDeclaration) + symbol.valueDeclaration = p.valueDeclaration; + p = symbol; + } + members[p.name] = p; + }); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); + if (stringIndexType) + stringIndexType = getWidenedType(stringIndexType); + if (numberIndexType) + numberIndexType = getWidenedType(numberIndexType); + return createAnonymousType(type.symbol, members, emptyArray, emptyArray, stringIndexType, numberIndexType); + } + function getWidenedType(type) { + if (type.flags & 786432) { + if (type.flags & (32 | 64)) { + return anyType; + } + if (type.flags & 131072) { + return getWidenedTypeOfObjectLiteral(type); + } + if (type.flags & 16384) { + return getUnionType(ts.map(type.types, getWidenedType)); + } + if (isArrayType(type)) { + return createArrayType(getWidenedType(type.typeArguments[0])); + } + } + return type; + } + function reportWideningErrorsInType(type) { + if (type.flags & 16384) { + var errorReported = false; + ts.forEach(type.types, function (t) { + if (reportWideningErrorsInType(t)) { + errorReported = true; + } + }); + return errorReported; + } + if (isArrayType(type)) { + return reportWideningErrorsInType(type.typeArguments[0]); + } + if (type.flags & 131072) { + var errorReported = false; + ts.forEach(getPropertiesOfObjectType(type), function (p) { + var t = getTypeOfSymbol(p); + if (t.flags & 262144) { + if (!reportWideningErrorsInType(t)) { + error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t))); + } + errorReported = true; + } + }); + return errorReported; + } + return false; + } + function reportImplicitAnyError(declaration, type) { + var typeAsString = typeToString(getWidenedType(type)); + switch (declaration.kind) { + case 130: + case 129: + var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; + break; + case 128: + var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; + break; + case 195: + case 132: + case 131: + case 134: + case 135: + case 160: + case 161: + if (!declaration.name) { + error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); + return; + } + var diagnostic = ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type; + break; + default: + var diagnostic = ts.Diagnostics.Variable_0_implicitly_has_an_1_type; + } + error(declaration, diagnostic, ts.declarationNameToString(declaration.name), typeAsString); + } + function reportErrorsFromWidening(declaration, type) { + if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & 262144) { + if (!reportWideningErrorsInType(type)) { + reportImplicitAnyError(declaration, type); + } + } + } + function forEachMatchingParameterType(source, target, callback) { + var sourceMax = source.parameters.length; + var targetMax = target.parameters.length; + var count; + if (source.hasRestParameter && target.hasRestParameter) { + count = sourceMax > targetMax ? sourceMax : targetMax; + sourceMax--; + targetMax--; + } + else if (source.hasRestParameter) { + sourceMax--; + count = targetMax; + } + else if (target.hasRestParameter) { + targetMax--; + count = sourceMax; + } + else { + count = sourceMax < targetMax ? sourceMax : targetMax; + } + for (var i = 0; i < count; i++) { + var s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source); + var t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target); + callback(s, t); + } + } + function createInferenceContext(typeParameters, inferUnionTypes) { + var inferences = []; + for (var i = 0; i < typeParameters.length; i++) { + inferences.push({ primary: undefined, secondary: undefined }); + } + return { + typeParameters: typeParameters, + inferUnionTypes: inferUnionTypes, + inferenceCount: 0, + inferences: inferences, + inferredTypes: new Array(typeParameters.length) + }; + } + function inferTypes(context, source, target) { + var sourceStack; + var targetStack; + var depth = 0; + var inferiority = 0; + inferFromTypes(source, target); + function isInProcess(source, target) { + for (var i = 0; i < depth; i++) { + if (source === sourceStack[i] && target === targetStack[i]) + return true; + } + return false; + } + function isWithinDepthLimit(type, stack) { + if (depth >= 5) { + var target = type.target; + var count = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (t.flags & 4096 && t.target === target) + count++; + } + return count < 5; + } + return true; + } + function inferFromTypes(source, target) { + if (source === anyFunctionType) { + return; + } + if (target.flags & 512) { + var typeParameters = context.typeParameters; + for (var i = 0; i < typeParameters.length; i++) { + if (target === typeParameters[i]) { + var inferences = context.inferences[i]; + var candidates = inferiority ? inferences.secondary || (inferences.secondary = []) : inferences.primary || (inferences.primary = []); + if (!ts.contains(candidates, source)) + candidates.push(source); + break; + } + } + } + else if (source.flags & 4096 && target.flags & 4096 && source.target === target.target) { + var sourceTypes = source.typeArguments; + var targetTypes = target.typeArguments; + for (var i = 0; i < sourceTypes.length; i++) { + inferFromTypes(sourceTypes[i], targetTypes[i]); + } + } + else if (target.flags & 16384) { + var targetTypes = target.types; + var typeParameterCount = 0; + var typeParameter; + for (var i = 0; i < targetTypes.length; i++) { + var t = targetTypes[i]; + if (t.flags & 512 && ts.contains(context.typeParameters, t)) { + typeParameter = t; + typeParameterCount++; + } + else { + inferFromTypes(source, t); + } + } + if (typeParameterCount === 1) { + inferiority++; + inferFromTypes(source, typeParameter); + inferiority--; + } + } + else if (source.flags & 16384) { + var sourceTypes = source.types; + for (var i = 0; i < sourceTypes.length; i++) { + inferFromTypes(sourceTypes[i], target); + } + } + 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--; + } + } + } + function inferFromProperties(source, target) { + var properties = getPropertiesOfObjectType(target); + for (var i = 0; i < properties.length; i++) { + var targetProp = properties[i]; + var sourceProp = getPropertyOfObjectType(source, targetProp.name); + if (sourceProp) { + inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); + } + } + } + function inferFromSignatures(source, target, kind) { + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + var sourceLen = sourceSignatures.length; + var targetLen = targetSignatures.length; + var len = sourceLen < targetLen ? sourceLen : targetLen; + for (var i = 0; i < len; i++) { + inferFromSignature(getErasedSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i])); + } + } + function inferFromSignature(source, target) { + forEachMatchingParameterType(source, target, inferFromTypes); + inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } + function inferFromIndexTypes(source, target, sourceKind, targetKind) { + var targetIndexType = getIndexTypeOfType(target, targetKind); + if (targetIndexType) { + var sourceIndexType = getIndexTypeOfType(source, sourceKind); + if (sourceIndexType) { + inferFromTypes(sourceIndexType, targetIndexType); + } + } + } + } + function getInferenceCandidates(context, index) { + var inferences = context.inferences[index]; + return inferences.primary || inferences.secondary || emptyArray; + } + function getInferredType(context, index) { + var inferredType = context.inferredTypes[index]; + if (!inferredType) { + var inferences = getInferenceCandidates(context, index); + if (inferences.length) { + var unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences); + inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : inferenceFailureType; + } + else { + inferredType = emptyObjectType; + } + if (inferredType !== inferenceFailureType) { + var constraint = getConstraintOfTypeParameter(context.typeParameters[index]); + inferredType = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType; + } + context.inferredTypes[index] = inferredType; + } + return inferredType; + } + function getInferredTypes(context) { + for (var i = 0; i < context.inferredTypes.length; i++) { + getInferredType(context, i); + } + return context.inferredTypes; + } + function hasAncestor(node, kind) { + return ts.getAncestor(node, kind) !== undefined; + } + function getResolvedSymbol(node) { + var links = getNodeLinks(node); + if (!links.resolvedSymbol) { + links.resolvedSymbol = (ts.getFullWidth(node) > 0 && resolveName(node, node.text, 107455 | 1048576, ts.Diagnostics.Cannot_find_name_0, node)) || unknownSymbol; + } + return links.resolvedSymbol; + } + function isInTypeQuery(node) { + while (node) { + switch (node.kind) { + case 142: + return true; + case 64: + case 125: + node = node.parent; + continue; + default: + return false; + } + } + ts.Debug.fail("should not get here"); + } + function removeTypesFromUnionType(type, typeKind, isOfTypeKind) { + if (type.flags & 16384) { + var types = type.types; + if (ts.forEach(types, function (t) { return !!(t.flags & typeKind) === isOfTypeKind; })) { + var narrowedType = getUnionType(ts.filter(types, function (t) { return !(t.flags & typeKind) === isOfTypeKind; })); + if (narrowedType !== emptyObjectType) { + return narrowedType; + } + } + } + return type; + } + function hasInitializer(node) { + return !!(node.initializer || ts.isBindingPattern(node.parent) && hasInitializer(node.parent.parent)); + } + function isVariableAssignedWithin(symbol, node) { + var links = getNodeLinks(node); + if (links.assignmentChecks) { + var cachedResult = links.assignmentChecks[symbol.id]; + if (cachedResult !== undefined) { + return cachedResult; + } + } + else { + links.assignmentChecks = {}; + } + return links.assignmentChecks[symbol.id] = isAssignedIn(node); + function isAssignedInBinaryExpression(node) { + if (node.operatorToken.kind >= 52 && node.operatorToken.kind <= 63) { + var n = node.left; + while (n.kind === 159) { + n = n.expression; + } + if (n.kind === 64 && getResolvedSymbol(n) === symbol) { + return true; + } + } + return ts.forEachChild(node, isAssignedIn); + } + function isAssignedInVariableDeclaration(node) { + if (!ts.isBindingPattern(node.name) && getSymbolOfNode(node) === symbol && hasInitializer(node)) { + return true; + } + return ts.forEachChild(node, isAssignedIn); + } + function isAssignedIn(node) { + switch (node.kind) { + case 167: + return isAssignedInBinaryExpression(node); + case 193: + case 150: + return isAssignedInVariableDeclaration(node); + case 148: + case 149: + case 151: + case 152: + case 153: + case 154: + case 155: + case 156: + case 158: + case 159: + case 165: + case 162: + case 163: + case 164: + case 166: + case 168: + case 171: + case 174: + case 175: + case 177: + case 178: + case 179: + case 180: + case 181: + case 182: + case 183: + case 186: + case 187: + case 188: + case 213: + case 214: + case 189: + case 190: + case 191: + case 216: + return ts.forEachChild(node, isAssignedIn); + } + return false; + } + } + function resolveLocation(node) { + var containerNodes = []; + for (var parent = node.parent; parent; parent = parent.parent) { + if ((ts.isExpression(parent) || ts.isObjectLiteralMethod(node)) && + isContextSensitive(parent)) { + containerNodes.unshift(parent); + } + } + ts.forEach(containerNodes, function (node) { getTypeOfNode(node); }); + } + function getSymbolAtLocation(node) { + resolveLocation(node); + return getSymbolInfo(node); + } + function getTypeAtLocation(node) { + resolveLocation(node); + return getTypeOfNode(node); + } + function getTypeOfSymbolAtLocation(symbol, node) { + resolveLocation(node); + return getNarrowedTypeOfSymbol(symbol, node); + } + function getNarrowedTypeOfSymbol(symbol, node) { + var type = getTypeOfSymbol(symbol); + if (node && symbol.flags & 3 && type.flags & (1 | 48128 | 16384 | 512)) { + loop: while (node.parent) { + var child = node; + node = node.parent; + var narrowedType = type; + switch (node.kind) { + case 178: + if (child !== node.expression) { + narrowedType = narrowType(type, node.expression, child === node.thenStatement); + } + break; + case 168: + if (child !== node.condition) { + narrowedType = narrowType(type, node.condition, child === node.whenTrue); + } + break; + case 167: + if (child === node.right) { + if (node.operatorToken.kind === 48) { + narrowedType = narrowType(type, node.left, true); + } + else if (node.operatorToken.kind === 49) { + narrowedType = narrowType(type, node.left, false); + } + } + break; + case 220: + case 200: + case 195: + case 132: + case 131: + case 134: + case 135: + case 133: + break loop; + } + if (narrowedType !== type) { + if (isVariableAssignedWithin(symbol, node)) { + break; + } + type = narrowedType; + } + } + } + return type; + function narrowTypeByEquality(type, expr, assumeTrue) { + if (expr.left.kind !== 163 || expr.right.kind !== 8) { + return type; + } + var left = expr.left; + var right = expr.right; + if (left.expression.kind !== 64 || getResolvedSymbol(left.expression) !== symbol) { + return type; + } + var typeInfo = primitiveTypeInfo[right.text]; + if (expr.operatorToken.kind === 31) { + assumeTrue = !assumeTrue; + } + if (assumeTrue) { + if (!typeInfo) { + return removeTypesFromUnionType(type, 258 | 132 | 8 | 1048576, true); + } + if (isTypeSubtypeOf(typeInfo.type, type)) { + return typeInfo.type; + } + return removeTypesFromUnionType(type, typeInfo.flags, false); + } + else { + if (typeInfo) { + return removeTypesFromUnionType(type, typeInfo.flags, true); + } + return type; + } + } + function narrowTypeByAnd(type, expr, assumeTrue) { + if (assumeTrue) { + return narrowType(narrowType(type, expr.left, true), expr.right, true); + } + else { + return getUnionType([ + narrowType(type, expr.left, false), + narrowType(narrowType(type, expr.left, true), expr.right, false) + ]); + } + } + function narrowTypeByOr(type, expr, assumeTrue) { + if (assumeTrue) { + return getUnionType([ + narrowType(type, expr.left, true), + narrowType(narrowType(type, expr.left, false), expr.right, true) + ]); + } + else { + return narrowType(narrowType(type, expr.left, false), expr.right, false); + } + } + function narrowTypeByInstanceof(type, expr, assumeTrue) { + if (type.flags & 1 || !assumeTrue || expr.left.kind !== 64 || getResolvedSymbol(expr.left) !== symbol) { + return type; + } + var rightType = checkExpression(expr.right); + if (!isTypeSubtypeOf(rightType, globalFunctionType)) { + return type; + } + var prototypeProperty = getPropertyOfType(rightType, "prototype"); + if (!prototypeProperty) { + return type; + } + var targetType = getTypeOfSymbol(prototypeProperty); + if (isTypeSubtypeOf(targetType, type)) { + return targetType; + } + if (type.flags & 16384) { + return getUnionType(ts.filter(type.types, function (t) { return isTypeSubtypeOf(t, targetType); })); + } + return type; + } + function narrowType(type, expr, assumeTrue) { + switch (expr.kind) { + case 159: + return narrowType(type, expr.expression, assumeTrue); + case 167: + var operator = expr.operatorToken.kind; + if (operator === 30 || operator === 31) { + return narrowTypeByEquality(type, expr, assumeTrue); + } + else if (operator === 48) { + return narrowTypeByAnd(type, expr, assumeTrue); + } + else if (operator === 49) { + return narrowTypeByOr(type, expr, assumeTrue); + } + else if (operator === 86) { + return narrowTypeByInstanceof(type, expr, assumeTrue); + } + break; + case 165: + if (expr.operator === 46) { + return narrowType(type, expr.operand, !assumeTrue); + } + break; + } + return type; + } + } + function markLinkedImportsAsReferenced(node) { + if (node) { + var nodeLinks = getNodeLinks(node); + while (nodeLinks.importOnRightSide) { + var rightSide = nodeLinks.importOnRightSide; + nodeLinks.importOnRightSide = undefined; + getSymbolLinks(rightSide).referenced = true; + ts.Debug.assert((rightSide.flags & 8388608) !== 0); + nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 202)); + } + } + } + function checkIdentifier(node) { + var symbol = getResolvedSymbol(node); + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 161) { + error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression); + } + if (symbol.flags & 8388608) { + var symbolLinks = getSymbolLinks(symbol); + if (!symbolLinks.referenced) { + var importOrExportAssignment = getLeftSideOfImportEqualsOrExportAssignment(node); + if (!importOrExportAssignment || + (importOrExportAssignment.flags & 1) || + (importOrExportAssignment.kind === 208)) { + symbolLinks.referenced = !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveImport(symbol)); + } + else { + var nodeLinks = getNodeLinks(importOrExportAssignment); + ts.Debug.assert(!nodeLinks.importOnRightSide); + nodeLinks.importOnRightSide = symbol; + } + } + if (symbolLinks.referenced) { + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); + } + } + checkCollisionWithCapturedSuperVariable(node, node); + checkCollisionWithCapturedThisVariable(node, node); + return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); + } + function captureLexicalThis(node, container) { + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; + getNodeLinks(node).flags |= 2; + if (container.kind === 130 || container.kind === 133) { + getNodeLinks(classNode).flags |= 4; + } + else { + getNodeLinks(container).flags |= 4; + } + } + function checkThisExpression(node) { + var container = ts.getThisContainer(node, true); + var needToCaptureLexicalThis = false; + if (container.kind === 161) { + container = ts.getThisContainer(container, false); + needToCaptureLexicalThis = (languageVersion < 2); + } + switch (container.kind) { + case 200: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_body); + break; + case 199: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); + break; + case 133: + if (isInConstructorArgumentInitializer(node, container)) { + error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); + } + break; + case 130: + case 129: + if (container.flags & 128) { + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); + } + break; + case 126: + 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 === 196 ? container.parent : undefined; + if (classNode) { + var symbol = getSymbolOfNode(classNode); + return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); + } + return anyType; + } + function isInConstructorArgumentInitializer(node, constructorDecl) { + for (var n = node; n && n !== constructorDecl; n = n.parent) { + if (n.kind === 128) { + return true; + } + } + return false; + } + function checkSuperExpression(node) { + var isCallExpression = node.parent.kind === 155 && node.parent.expression === node; + var enclosingClass = ts.getAncestor(node, 196); + var baseClass; + if (enclosingClass && ts.getClassBaseTypeNode(enclosingClass)) { + var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); + baseClass = classType.baseTypes.length && classType.baseTypes[0]; + } + if (!baseClass) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + return unknownType; + } + var container = ts.getSuperContainer(node, true); + if (container) { + var canUseSuperExpression = false; + if (isCallExpression) { + canUseSuperExpression = container.kind === 133; + } + else { + var needToCaptureLexicalThis = false; + while (container && container.kind === 161) { + container = ts.getSuperContainer(container, true); + needToCaptureLexicalThis = true; + } + if (container && container.parent && container.parent.kind === 196) { + if (container.flags & 128) { + canUseSuperExpression = + container.kind === 132 || + container.kind === 131 || + container.kind === 134 || + container.kind === 135; + } + else { + canUseSuperExpression = + container.kind === 132 || + container.kind === 131 || + container.kind === 134 || + container.kind === 135 || + container.kind === 130 || + container.kind === 129 || + container.kind === 133; + } + } + } + if (canUseSuperExpression) { + var returnType; + if ((container.flags & 128) || isCallExpression) { + getNodeLinks(node).flags |= 32; + returnType = getTypeOfSymbol(baseClass.symbol); + } + else { + getNodeLinks(node).flags |= 16; + returnType = baseClass; + } + if (container.kind === 133 && isInConstructorArgumentInitializer(node, container)) { + error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); + returnType = unknownType; + } + if (!isCallExpression && needToCaptureLexicalThis) { + captureLexicalThis(node.parent, container); + } + return returnType; + } + } + if (container.kind === 126) { + error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); + } + else if (isCallExpression) { + error(node, ts.Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors); + } + else { + error(node, ts.Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class); + } + return unknownType; + } + function getContextuallyTypedParameterType(parameter) { + if (isFunctionExpressionOrArrowFunction(parameter.parent)) { + var func = parameter.parent; + if (isContextSensitive(func)) { + var contextualSignature = getContextualSignature(func); + if (contextualSignature) { + var funcHasRestParameters = ts.hasRestParameters(func); + var len = func.parameters.length - (funcHasRestParameters ? 1 : 0); + var indexOfParameter = ts.indexOf(func.parameters, parameter); + if (indexOfParameter < len) { + return getTypeAtPosition(contextualSignature, indexOfParameter); + } + if (indexOfParameter === (func.parameters.length - 1) && + funcHasRestParameters && contextualSignature.hasRestParameter && func.parameters.length >= contextualSignature.parameters.length) { + return getTypeOfSymbol(contextualSignature.parameters[contextualSignature.parameters.length - 1]); + } + } + } + } + return undefined; + } + function getContextualTypeForInitializerExpression(node) { + var declaration = node.parent; + if (node === declaration.initializer) { + if (declaration.type) { + return getTypeFromTypeNode(declaration.type); + } + if (declaration.kind === 128) { + var type = getContextuallyTypedParameterType(declaration); + if (type) { + return type; + } + } + if (ts.isBindingPattern(declaration.name)) { + return getTypeFromBindingPattern(declaration.name); + } + } + return undefined; + } + function getContextualTypeForReturnExpression(node) { + var func = ts.getContainingFunction(node); + if (func) { + if (func.type || func.kind === 133 || func.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 135))) { + return getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + } + var signature = getContextualSignatureForFunctionLikeDeclaration(func); + if (signature) { + return getReturnTypeOfSignature(signature); + } + } + return undefined; + } + function getContextualTypeForArgument(callTarget, arg) { + var args = getEffectiveCallArguments(callTarget); + var argIndex = ts.indexOf(args, arg); + if (argIndex >= 0) { + var signature = getResolvedSignature(callTarget); + return getTypeAtPosition(signature, argIndex); + } + return undefined; + } + function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { + if (template.parent.kind === 157) { + return getContextualTypeForArgument(template.parent, substitutionExpression); + } + return undefined; + } + function getContextualTypeForBinaryOperand(node) { + var binaryExpression = node.parent; + var operator = binaryExpression.operatorToken.kind; + if (operator >= 52 && operator <= 63) { + if (node === binaryExpression.right) { + return checkExpression(binaryExpression.left); + } + } + else if (operator === 49) { + var type = getContextualType(binaryExpression); + if (!type && node === binaryExpression.right) { + type = checkExpression(binaryExpression.left); + } + return type; + } + return undefined; + } + function applyToContextualType(type, mapper) { + if (!(type.flags & 16384)) { + return mapper(type); + } + var types = type.types; + var mappedType; + var mappedTypes; + for (var i = 0; i < types.length; i++) { + var t = mapper(types[i]); + if (t) { + if (!mappedType) { + mappedType = t; + } + else if (!mappedTypes) { + mappedTypes = [mappedType, t]; + } + else { + mappedTypes.push(t); + } + } + } + return mappedTypes ? getUnionType(mappedTypes) : mappedType; + } + function getTypeOfPropertyOfContextualType(type, name) { + return applyToContextualType(type, function (t) { + var prop = getPropertyOfObjectType(t, name); + return prop ? getTypeOfSymbol(prop) : undefined; + }); + } + function getIndexTypeOfContextualType(type, kind) { + return applyToContextualType(type, function (t) { return getIndexTypeOfObjectOrUnionType(t, kind); }); + } + function contextualTypeIsTupleLikeType(type) { + return !!(type.flags & 16384 ? ts.forEach(type.types, isTupleLikeType) : isTupleLikeType(type)); + } + function contextualTypeHasIndexSignature(type, kind) { + return !!(type.flags & 16384 ? ts.forEach(type.types, function (t) { return getIndexTypeOfObjectOrUnionType(t, kind); }) : getIndexTypeOfObjectOrUnionType(type, kind)); + } + function getContextualTypeForObjectLiteralMethod(node) { + ts.Debug.assert(ts.isObjectLiteralMethod(node)); + if (isInsideWithStatementBody(node)) { + return undefined; + } + return getContextualTypeForObjectLiteralElement(node); + } + function getContextualTypeForObjectLiteralElement(element) { + var objectLiteral = element.parent; + var type = getContextualType(objectLiteral); + if (type) { + if (!ts.hasDynamicName(element)) { + var symbolName = getSymbolOfNode(element).name; + var propertyType = getTypeOfPropertyOfContextualType(type, symbolName); + if (propertyType) { + return propertyType; + } + } + return isNumericName(element.name) && getIndexTypeOfContextualType(type, 1) || + getIndexTypeOfContextualType(type, 0); + } + return undefined; + } + function getContextualTypeForElementExpression(node) { + var arrayLiteral = node.parent; + var type = getContextualType(arrayLiteral); + if (type) { + var index = ts.indexOf(arrayLiteral.elements, node); + return getTypeOfPropertyOfContextualType(type, "" + index) || getIndexTypeOfContextualType(type, 1); + } + return undefined; + } + function getContextualTypeForConditionalOperand(node) { + var conditional = node.parent; + return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined; + } + function getContextualType(node) { + if (isInsideWithStatementBody(node)) { + return undefined; + } + if (node.contextualType) { + return node.contextualType; + } + var parent = node.parent; + switch (parent.kind) { + case 193: + case 128: + case 130: + case 129: + case 150: + return getContextualTypeForInitializerExpression(node); + case 161: + case 186: + return getContextualTypeForReturnExpression(node); + case 155: + case 156: + return getContextualTypeForArgument(parent, node); + case 158: + return getTypeFromTypeNode(parent.type); + case 167: + return getContextualTypeForBinaryOperand(node); + case 217: + return getContextualTypeForObjectLiteralElement(parent); + case 151: + return getContextualTypeForElementExpression(node); + case 168: + return getContextualTypeForConditionalOperand(node); + case 173: + ts.Debug.assert(parent.parent.kind === 169); + return getContextualTypeForSubstitutionExpression(parent.parent, node); + case 159: + return getContextualType(parent); + } + return undefined; + } + function getNonGenericSignature(type) { + var signatures = getSignaturesOfObjectOrUnionType(type, 0); + if (signatures.length === 1) { + var signature = signatures[0]; + if (!signature.typeParameters) { + return signature; + } + } + } + function isFunctionExpressionOrArrowFunction(node) { + return node.kind === 160 || node.kind === 161; + } + function getContextualSignatureForFunctionLikeDeclaration(node) { + return isFunctionExpressionOrArrowFunction(node) ? getContextualSignature(node) : undefined; + } + function getContextualSignature(node) { + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); + var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); + if (!type) { + return undefined; + } + if (!(type.flags & 16384)) { + return getNonGenericSignature(type); + } + var signatureList; + var types = type.types; + for (var i = 0; i < types.length; i++) { + if (signatureList && + getSignaturesOfObjectOrUnionType(types[i], 0).length > 1) { + return undefined; + } + var signature = getNonGenericSignature(types[i]); + if (signature) { + if (!signatureList) { + signatureList = [signature]; + } + else if (!compareSignatures(signatureList[0], signature, false, compareTypes)) { + return undefined; + } + else { + signatureList.push(signature); + } + } + } + var result; + if (signatureList) { + result = cloneSignature(signatureList[0]); + result.resolvedReturnType = undefined; + result.unionSignatures = signatureList; + } + return result; + } + function isInferentialContext(mapper) { + return mapper && mapper !== identityMapper; + } + function isAssignmentTarget(node) { + var parent = node.parent; + if (parent.kind === 167 && parent.operatorToken.kind === 52 && parent.left === node) { + return true; + } + if (parent.kind === 217) { + return isAssignmentTarget(parent.parent); + } + if (parent.kind === 151) { + return isAssignmentTarget(parent); + } + return false; + } + function checkSpreadElementExpression(node, contextualMapper) { + var type = checkExpressionCached(node.expression, contextualMapper); + if (!isArrayLikeType(type)) { + error(node.expression, ts.Diagnostics.Type_0_is_not_an_array_type, typeToString(type)); + return unknownType; + } + return type; + } + function checkArrayLiteral(node, contextualMapper) { + var elements = node.elements; + if (!elements.length) { + return createArrayType(undefinedType); + } + var hasSpreadElement = false; + var elementTypes = []; + ts.forEach(elements, function (e) { + var type = checkExpression(e, contextualMapper); + if (e.kind === 171) { + elementTypes.push(getIndexTypeOfType(type, 1) || anyType); + hasSpreadElement = true; + } + else { + elementTypes.push(type); + } + }); + if (!hasSpreadElement) { + var contextualType = getContextualType(node); + if (contextualType && contextualTypeIsTupleLikeType(contextualType) || isAssignmentTarget(node)) { + return createTupleType(elementTypes); + } + } + return createArrayType(getUnionType(elementTypes)); + } + function isNumericName(name) { + return name.kind === 126 ? isNumericComputedName(name) : isNumericLiteralName(name.text); + } + function isNumericComputedName(name) { + return allConstituentTypesHaveKind(checkComputedPropertyName(name), 1 | 132); + } + function isNumericLiteralName(name) { + return (+name).toString() === name; + } + function checkComputedPropertyName(node) { + var links = getNodeLinks(node.expression); + if (!links.resolvedType) { + links.resolvedType = checkExpression(node.expression); + if (!allConstituentTypesHaveKind(links.resolvedType, 1 | 132 | 258 | 1048576)) { + error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any); + } + else { + checkThatExpressionIsProperSymbolReference(node.expression, links.resolvedType, true); + } + } + return links.resolvedType; + } + function checkObjectLiteral(node, contextualMapper) { + checkGrammarObjectLiteralExpression(node); + var propertiesTable = {}; + var propertiesArray = []; + var contextualType = getContextualType(node); + var typeFlags; + for (var i = 0; i < node.properties.length; i++) { + var memberDecl = node.properties[i]; + var member = memberDecl.symbol; + if (memberDecl.kind === 217 || + memberDecl.kind === 218 || + ts.isObjectLiteralMethod(memberDecl)) { + if (memberDecl.kind === 217) { + var type = checkPropertyAssignment(memberDecl, contextualMapper); + } + else if (memberDecl.kind === 132) { + var type = checkObjectLiteralMethod(memberDecl, contextualMapper); + } + else { + ts.Debug.assert(memberDecl.kind === 218); + var type = memberDecl.name.kind === 126 ? unknownType : checkExpression(memberDecl.name, contextualMapper); + } + typeFlags |= type.flags; + var prop = createSymbol(4 | 67108864 | member.flags, member.name); + prop.declarations = member.declarations; + prop.parent = member.parent; + if (member.valueDeclaration) { + prop.valueDeclaration = member.valueDeclaration; + } + prop.type = type; + prop.target = member; + member = prop; + } + else { + ts.Debug.assert(memberDecl.kind === 134 || memberDecl.kind === 135); + checkAccessorDeclaration(memberDecl); + } + if (!ts.hasDynamicName(memberDecl)) { + propertiesTable[member.name] = member; + } + propertiesArray.push(member); + } + var stringIndexType = getIndexType(0); + var numberIndexType = getIndexType(1); + var result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType); + result.flags |= 131072 | 524288 | (typeFlags & 262144); + return result; + function getIndexType(kind) { + if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) { + var propTypes = []; + for (var i = 0; i < propertiesArray.length; i++) { + var propertyDecl = node.properties[i]; + if (kind === 0 || isNumericName(propertyDecl.name)) { + var type = getTypeOfSymbol(propertiesArray[i]); + if (!ts.contains(propTypes, type)) { + propTypes.push(type); + } + } + } + var result = propTypes.length ? getUnionType(propTypes) : undefinedType; + typeFlags |= result.flags; + return result; + } + return undefined; + } + } + function getDeclarationKindFromSymbol(s) { + return s.valueDeclaration ? s.valueDeclaration.kind : 130; + } + function getDeclarationFlagsFromSymbol(s) { + return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; + } + function checkClassPropertyAccess(node, left, type, prop) { + var flags = getDeclarationFlagsFromSymbol(prop); + if (!(flags & (32 | 64))) { + return; + } + var enclosingClassDeclaration = ts.getAncestor(node, 196); + var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; + var declaringClass = getDeclaredTypeOfSymbol(prop.parent); + if (flags & 32) { + if (declaringClass !== enclosingClass) { + error(node, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass)); + } + return; + } + if (left.kind === 90) { + return; + } + if (!enclosingClass || !hasBaseType(enclosingClass, declaringClass)) { + error(node, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(declaringClass)); + return; + } + if (flags & 128) { + return; + } + if (!(getTargetType(type).flags & (1024 | 2048) && hasBaseType(type, enclosingClass))) { + error(node, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1, symbolToString(prop), typeToString(enclosingClass)); + } + } + function checkPropertyAccessExpression(node) { + return checkPropertyAccessExpressionOrQualifiedName(node, node.expression, node.name); + } + function checkQualifiedName(node) { + return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right); + } + function checkPropertyAccessExpressionOrQualifiedName(node, left, right) { + var type = checkExpressionOrQualifiedName(left); + if (type === unknownType) + return type; + if (type !== anyType) { + var apparentType = getApparentType(getWidenedType(type)); + if (apparentType === unknownType) { + return unknownType; + } + var prop = getPropertyOfType(apparentType, right.text); + if (!prop) { + if (right.text) { + error(right, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(right), typeToString(type)); + } + return unknownType; + } + getNodeLinks(node).resolvedSymbol = prop; + if (prop.parent && prop.parent.flags & 32) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { + error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); + } + else { + checkClassPropertyAccess(node, left, type, prop); + } + } + return getTypeOfSymbol(prop); + } + return anyType; + } + function isValidPropertyAccess(node, propertyName) { + var left = node.kind === 153 ? node.expression : node.left; + var type = checkExpressionOrQualifiedName(left); + if (type !== unknownType && type !== anyType) { + var prop = getPropertyOfType(getWidenedType(type), propertyName); + if (prop && prop.parent && prop.parent.flags & 32) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { + return false; + } + else { + var modificationCount = diagnostics.getModificationCount(); + checkClassPropertyAccess(node, left, type, prop); + return diagnostics.getModificationCount() === modificationCount; + } + } + } + return true; + } + function checkIndexedAccess(node) { + if (!node.argumentExpression) { + var sourceFile = getSourceFile(node); + if (node.parent.kind === 156 && 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); + } + else { + var start = node.end - "]".length; + var end = node.end; + grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Expression_expected); + } + } + var objectType = getApparentType(checkExpression(node.expression)); + var indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType; + if (objectType === unknownType) { + return unknownType; + } + var isConstEnum = isConstEnumObjectType(objectType); + if (isConstEnum && + (!node.argumentExpression || node.argumentExpression.kind !== 8)) { + error(node.argumentExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal); + return unknownType; + } + if (node.argumentExpression) { + var name = getPropertyNameForIndexedAccess(node.argumentExpression, indexType); + if (name !== undefined) { + var prop = getPropertyOfType(objectType, name); + if (prop) { + getNodeLinks(node).resolvedSymbol = prop; + return getTypeOfSymbol(prop); + } + else if (isConstEnum) { + error(node.argumentExpression, ts.Diagnostics.Property_0_does_not_exist_on_const_enum_1, name, symbolToString(objectType.symbol)); + return unknownType; + } + } + } + if (allConstituentTypesHaveKind(indexType, 1 | 258 | 132 | 1048576)) { + if (allConstituentTypesHaveKind(indexType, 1 | 132)) { + var numberIndexType = getIndexTypeOfType(objectType, 1); + if (numberIndexType) { + return numberIndexType; + } + } + var stringIndexType = getIndexTypeOfType(objectType, 0); + if (stringIndexType) { + return stringIndexType; + } + if (compilerOptions.noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && objectType !== anyType) { + error(node, ts.Diagnostics.Index_signature_of_object_type_implicitly_has_an_any_type); + } + return anyType; + } + error(node, ts.Diagnostics.An_index_expression_argument_must_be_of_type_string_number_symbol_or_any); + return unknownType; + } + function getPropertyNameForIndexedAccess(indexArgumentExpression, indexArgumentType) { + if (indexArgumentExpression.kind === 8 || indexArgumentExpression.kind === 7) { + return indexArgumentExpression.text; + } + if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, false)) { + var rightHandSideName = indexArgumentExpression.name.text; + return ts.getPropertyNameForKnownSymbolName(rightHandSideName); + } + return undefined; + } + function checkThatExpressionIsProperSymbolReference(expression, expressionType, reportError) { + if (expressionType === unknownType) { + return false; + } + if (!ts.isWellKnownSymbolSyntactically(expression)) { + return false; + } + if ((expressionType.flags & 1048576) === 0) { + if (reportError) { + error(expression, ts.Diagnostics.A_computed_property_name_of_the_form_0_must_be_of_type_symbol, ts.getTextOfNode(expression)); + } + return false; + } + var leftHandSide = expression.expression; + var leftHandSideSymbol = getResolvedSymbol(leftHandSide); + if (!leftHandSideSymbol) { + return false; + } + var globalESSymbol = getGlobalESSymbolConstructorSymbol(); + if (!globalESSymbol) { + return false; + } + if (leftHandSideSymbol !== globalESSymbol) { + if (reportError) { + error(leftHandSide, ts.Diagnostics.Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object); + } + return false; + } + return true; + } + function resolveUntypedCall(node) { + if (node.kind === 157) { + checkExpression(node.template); + } + else { + ts.forEach(node.arguments, function (argument) { + checkExpression(argument); + }); + } + return anySignature; + } + function resolveErrorCall(node) { + resolveUntypedCall(node); + return unknownSignature; + } + function reorderCandidates(signatures, result) { + var lastParent; + var lastSymbol; + var cutoffIndex = 0; + var index; + var specializedIndex = -1; + var spliceIndex; + ts.Debug.assert(!result.length); + for (var i = 0; i < signatures.length; i++) { + var signature = signatures[i]; + var symbol = signature.declaration && getSymbolOfNode(signature.declaration); + var parent = signature.declaration && signature.declaration.parent; + if (!lastSymbol || symbol === lastSymbol) { + if (lastParent && parent === lastParent) { + index++; + } + else { + lastParent = parent; + index = cutoffIndex; + } + } + else { + index = cutoffIndex = result.length; + lastParent = parent; + } + lastSymbol = symbol; + if (signature.hasStringLiterals) { + specializedIndex++; + spliceIndex = specializedIndex; + cutoffIndex++; + } + else { + spliceIndex = index; + } + result.splice(spliceIndex, 0, signature); + } + } + function getSpreadArgumentIndex(args) { + for (var i = 0; i < args.length; i++) { + if (args[i].kind === 171) { + return i; + } + } + return -1; + } + function hasCorrectArity(node, args, signature) { + var adjustedArgCount; + var typeArguments; + var callIsIncomplete; + if (node.kind === 157) { + var tagExpression = node; + adjustedArgCount = args.length; + typeArguments = undefined; + if (tagExpression.template.kind === 169) { + var templateExpression = tagExpression.template; + var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); + ts.Debug.assert(lastSpan !== undefined); + callIsIncomplete = ts.getFullWidth(lastSpan.literal) === 0 || !!lastSpan.literal.isUnterminated; + } + else { + var templateLiteral = tagExpression.template; + ts.Debug.assert(templateLiteral.kind === 10); + callIsIncomplete = !!templateLiteral.isUnterminated; + } + } + else { + var callExpression = node; + if (!callExpression.arguments) { + ts.Debug.assert(callExpression.kind === 156); + return signature.minArgumentCount === 0; + } + adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; + callIsIncomplete = callExpression.arguments.end === callExpression.end; + typeArguments = callExpression.typeArguments; + } + 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; + } + if (!signature.hasRestParameter && adjustedArgCount > signature.parameters.length) { + return false; + } + var hasEnoughArguments = adjustedArgCount >= signature.minArgumentCount; + return callIsIncomplete || hasEnoughArguments; + } + function getSingleCallSignature(type) { + if (type.flags & 48128) { + var resolved = resolveObjectOrUnionTypeMembers(type); + if (resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0 && + resolved.properties.length === 0 && !resolved.stringIndexType && !resolved.numberIndexType) { + return resolved.callSignatures[0]; + } + } + return undefined; + } + function instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper) { + var context = createInferenceContext(signature.typeParameters, true); + forEachMatchingParameterType(contextualSignature, signature, function (source, target) { + inferTypes(context, instantiateType(source, contextualMapper), target); + }); + return getSignatureInstantiation(signature, getInferredTypes(context)); + } + function inferTypeArguments(signature, args, excludeArgument) { + var typeParameters = signature.typeParameters; + var context = createInferenceContext(typeParameters, false); + var inferenceMapper = createInferenceMapper(context); + for (var i = 0; i < args.length; i++) { + var arg = args[i]; + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + if (i === 0 && args[i].parent.kind === 157) { + var argType = globalTemplateStringsArrayType; + } + else { + var mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper; + var argType = checkExpressionWithContextualType(arg, paramType, mapper); + } + inferTypes(context, argType, paramType); + } + } + if (excludeArgument) { + for (var i = 0; i < args.length; i++) { + if (excludeArgument[i] === false) { + var arg = args[i]; + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType); + } + } + } + var inferredTypes = getInferredTypes(context); + context.failedTypeParameterIndex = ts.indexOf(inferredTypes, inferenceFailureType); + for (var i = 0; i < inferredTypes.length; i++) { + if (inferredTypes[i] === inferenceFailureType) { + inferredTypes[i] = unknownType; + } + } + return context; + } + function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors) { + var typeParameters = signature.typeParameters; + var typeArgumentsAreAssignable = true; + for (var i = 0; i < typeParameters.length; i++) { + var typeArgNode = typeArguments[i]; + var typeArgument = getTypeFromTypeNode(typeArgNode); + typeArgumentResultTypes[i] = typeArgument; + 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); + } + } + } + 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 !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + var argType = i === 0 && node.kind === 157 ? globalTemplateStringsArrayType : 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)) { + return false; + } + } + } + return true; + } + function getEffectiveCallArguments(node) { + var args; + if (node.kind === 157) { + var template = node.template; + args = [template]; + if (template.kind === 169) { + ts.forEach(template.templateSpans, function (span) { + args.push(span.expression); + }); + } + } + else { + args = node.arguments || emptyArray; + } + return args; + } + function getEffectiveTypeArguments(callExpression) { + if (callExpression.expression.kind === 90) { + var containingClass = ts.getAncestor(callExpression, 196); + var baseClassTypeNode = containingClass && ts.getClassBaseTypeNode(containingClass); + return baseClassTypeNode && baseClassTypeNode.typeArguments; + } + else { + return callExpression.typeArguments; + } + } + function resolveCall(node, signatures, candidatesOutArray) { + var isTaggedTemplate = node.kind === 157; + var typeArguments; + if (!isTaggedTemplate) { + typeArguments = getEffectiveTypeArguments(node); + if (node.expression.kind !== 90) { + ts.forEach(typeArguments, checkSourceElement); + } + } + var candidates = candidatesOutArray || []; + reorderCandidates(signatures, candidates); + if (!candidates.length) { + error(node, 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); + } + excludeArgument[i] = true; + } + } + var candidateForArgumentError; + var candidateForTypeArgumentError; + var resultOfFailedInference; + var result; + if (candidates.length > 1) { + result = chooseOverload(candidates, subtypeRelation); + } + if (!result) { + candidateForArgumentError = undefined; + candidateForTypeArgumentError = undefined; + resultOfFailedInference = undefined; + result = chooseOverload(candidates, assignableRelation); + } + if (result) { + return result; + } + if (candidateForArgumentError) { + checkApplicableSignature(node, args, candidateForArgumentError, assignableRelation, undefined, true); + } + else if (candidateForTypeArgumentError) { + if (!isTaggedTemplate && node.typeArguments) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true); + } + 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)); + reportNoCommonSupertypeError(inferenceCandidates, node.expression || node.tag, diagnosticChainHead); + } + } + else { + error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target); + } + if (!produceDiagnostics) { + for (var i = 0, n = candidates.length; i < n; i++) { + if (hasCorrectArity(node, args, candidates[i])) { + return candidates[i]; + } + } + } + return resolveErrorCall(node); + function chooseOverload(candidates, relation) { + for (var i = 0; i < candidates.length; i++) { + if (!hasCorrectArity(node, args, candidates[i])) { + continue; + } + var originalCandidate = candidates[i]; + var inferenceResult; + while (true) { + var candidate = originalCandidate; + if (candidate.typeParameters) { + var typeArgumentTypes; + var typeArgumentsAreValid; + if (typeArguments) { + typeArgumentTypes = new Array(candidate.typeParameters.length); + typeArgumentsAreValid = checkTypeArguments(candidate, typeArguments, typeArgumentTypes, false); + } + else { + inferenceResult = inferTypeArguments(candidate, args, excludeArgument); + typeArgumentsAreValid = inferenceResult.failedTypeParameterIndex < 0; + typeArgumentTypes = inferenceResult.inferredTypes; + } + if (!typeArgumentsAreValid) { + break; + } + candidate = getSignatureInstantiation(candidate, typeArgumentTypes); + } + if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, false)) { + break; + } + var index = excludeArgument ? ts.indexOf(excludeArgument, true) : -1; + if (index < 0) { + return candidate; + } + excludeArgument[index] = false; + } + if (originalCandidate.typeParameters) { + var instantiatedCandidate = candidate; + if (typeArgumentsAreValid) { + candidateForArgumentError = instantiatedCandidate; + } + else { + candidateForTypeArgumentError = originalCandidate; + if (!typeArguments) { + resultOfFailedInference = inferenceResult; + } + } + } + else { + ts.Debug.assert(originalCandidate === candidate); + candidateForArgumentError = originalCandidate; + } + } + return undefined; + } + } + function resolveCallExpression(node, candidatesOutArray) { + if (node.expression.kind === 90) { + var superType = checkSuperExpression(node.expression); + if (superType !== unknownType) { + return resolveCall(node, getSignaturesOfType(superType, 1), candidatesOutArray); + } + return resolveUntypedCall(node); + } + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + var constructSignatures = getSignaturesOfType(apparentType, 1); + if (funcType === anyType || (!callSignatures.length && !constructSignatures.length && !(funcType.flags & 16384) && isTypeAssignableTo(funcType, globalFunctionType))) { + if (node.typeArguments) { + error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); + } + return resolveUntypedCall(node); + } + if (!callSignatures.length) { + if (constructSignatures.length) { + error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType)); + } + else { + error(node, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + } + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray); + } + function resolveNewExpression(node, candidatesOutArray) { + if (node.arguments && languageVersion < 2) { + var spreadIndex = getSpreadArgumentIndex(node.arguments); + if (spreadIndex >= 0) { + error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_6_and_higher); + } + } + var expressionType = checkExpression(node.expression); + if (expressionType === anyType) { + if (node.typeArguments) { + error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); + } + return resolveUntypedCall(node); + } + expressionType = getApparentType(expressionType); + if (expressionType === unknownType) { + return resolveErrorCall(node); + } + var constructSignatures = getSignaturesOfType(expressionType, 1); + if (constructSignatures.length) { + return resolveCall(node, constructSignatures, candidatesOutArray); + } + var callSignatures = getSignaturesOfType(expressionType, 0); + if (callSignatures.length) { + var signature = resolveCall(node, callSignatures, candidatesOutArray); + if (getReturnTypeOfSignature(signature) !== voidType) { + error(node, ts.Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword); + } + return signature; + } + error(node, ts.Diagnostics.Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature); + return resolveErrorCall(node); + } + function resolveTaggedTemplateExpression(node, candidatesOutArray) { + var tagType = checkExpression(node.tag); + var apparentType = getApparentType(tagType); + if (apparentType === unknownType) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0); + if (tagType === anyType || (!callSignatures.length && !(tagType.flags & 16384) && isTypeAssignableTo(tagType, globalFunctionType))) { + return resolveUntypedCall(node); + } + if (!callSignatures.length) { + error(node, ts.Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray); + } + function getResolvedSignature(node, candidatesOutArray) { + var links = getNodeLinks(node); + if (!links.resolvedSignature || candidatesOutArray) { + links.resolvedSignature = anySignature; + if (node.kind === 155) { + links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); + } + else if (node.kind === 156) { + links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); + } + else if (node.kind === 157) { + links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); + } + else { + ts.Debug.fail("Branch in 'getResolvedSignature' should be unreachable."); + } + } + return links.resolvedSignature; + } + function checkCallExpression(node) { + checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments); + var signature = getResolvedSignature(node); + if (node.expression.kind === 90) { + return voidType; + } + if (node.kind === 156) { + var declaration = signature.declaration; + if (declaration && + declaration.kind !== 133 && + declaration.kind !== 137 && + declaration.kind !== 141) { + if (compilerOptions.noImplicitAny) { + error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); + } + return anyType; + } + } + return getReturnTypeOfSignature(signature); + } + function checkTaggedTemplateExpression(node) { + if (languageVersion < 2) { + grammarErrorOnFirstToken(node.template, ts.Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher); + } + return getReturnTypeOfSignature(getResolvedSignature(node)); + } + function checkTypeAssertion(node) { + var exprType = checkExpression(node.expression); + var targetType = getTypeFromTypeNode(node.type); + if (produceDiagnostics && targetType !== unknownType) { + var widenedType = getWidenedType(exprType); + if (!(isTypeAssignableTo(targetType, widenedType))) { + checkTypeAssignableTo(exprType, targetType, node, ts.Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other); + } + } + return targetType; + } + function getTypeAtPosition(signature, pos) { + if (pos >= 0) { + return signature.hasRestParameter ? pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) : pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[pos]) : anyType; + } + return signature.hasRestParameter ? getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]) : anyArrayType; + } + function assignContextualParameterTypes(signature, context, mapper) { + var len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0); + for (var i = 0; i < len; i++) { + var parameter = signature.parameters[i]; + var links = getSymbolLinks(parameter); + links.type = instantiateType(getTypeAtPosition(context, i), mapper); + } + if (signature.hasRestParameter && context.hasRestParameter && signature.parameters.length >= context.parameters.length) { + var parameter = signature.parameters[signature.parameters.length - 1]; + var links = getSymbolLinks(parameter); + links.type = instantiateType(getTypeOfSymbol(context.parameters[context.parameters.length - 1]), mapper); + } + } + function getReturnTypeFromBody(func, contextualMapper) { + var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func); + if (!func.body) { + return unknownType; + } + if (func.body.kind !== 174) { + var type = checkExpressionCached(func.body, contextualMapper); + } + else { + var types = checkAndAggregateReturnExpressionTypes(func.body, contextualMapper); + if (types.length === 0) { + return voidType; + } + var type = contextualSignature ? getUnionType(types) : getCommonSupertype(types); + if (!type) { + error(func, ts.Diagnostics.No_best_common_type_exists_among_return_expressions); + return unknownType; + } + } + if (!contextualSignature) { + reportErrorsFromWidening(func, type); + } + return getWidenedType(type); + } + function checkAndAggregateReturnExpressionTypes(body, contextualMapper) { + var aggregatedTypes = []; + ts.forEachReturnStatement(body, function (returnStatement) { + var expr = returnStatement.expression; + if (expr) { + var type = checkExpressionCached(expr, contextualMapper); + if (!ts.contains(aggregatedTypes, type)) { + aggregatedTypes.push(type); + } + } + }); + return aggregatedTypes; + } + function bodyContainsAReturnStatement(funcBody) { + return ts.forEachReturnStatement(funcBody, function (returnStatement) { + return true; + }); + } + function bodyContainsSingleThrowStatement(body) { + return (body.statements.length === 1) && (body.statements[0].kind === 190); + } + function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { + if (!produceDiagnostics) { + return; + } + if (returnType === voidType || returnType === anyType) { + return; + } + if (ts.nodeIsMissing(func.body) || func.body.kind !== 174) { + return; + } + var bodyBlock = func.body; + if (bodyContainsAReturnStatement(bodyBlock)) { + return; + } + if (bodyContainsSingleThrowStatement(bodyBlock)) { + return; + } + 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 !== 132 || ts.isObjectLiteralMethod(node)); + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 160) { + checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); + } + if (contextualMapper === identityMapper && isContextSensitive(node)) { + return anyFunctionType; + } + var links = getNodeLinks(node); + var type = getTypeOfSymbol(node.symbol); + if (!(links.flags & 64)) { + var contextualSignature = getContextualSignature(node); + if (!(links.flags & 64)) { + links.flags |= 64; + if (contextualSignature) { + var signature = getSignaturesOfType(type, 0)[0]; + if (isContextSensitive(node)) { + assignContextualParameterTypes(signature, contextualSignature, contextualMapper || identityMapper); + } + if (!node.type) { + signature.resolvedReturnType = resolvingType; + var returnType = getReturnTypeFromBody(node, contextualMapper); + if (signature.resolvedReturnType === resolvingType) { + signature.resolvedReturnType = returnType; + } + } + } + checkSignatureDeclaration(node); + } + } + if (produceDiagnostics && node.kind !== 132 && node.kind !== 131) { + checkCollisionWithCapturedSuperVariable(node, node.name); + checkCollisionWithCapturedThisVariable(node, node.name); + } + return type; + } + function checkFunctionExpressionOrObjectLiteralMethodBody(node) { + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); + if (node.type) { + checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); + } + if (node.body) { + if (node.body.kind === 174) { + checkSourceElement(node.body); + } + else { + var exprType = checkExpression(node.body); + if (node.type) { + checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined); + } + checkFunctionExpressionBodies(node.body); + } + } + } + function checkArithmeticOperandType(operand, type, diagnostic) { + if (!allConstituentTypesHaveKind(type, 1 | 132)) { + error(operand, diagnostic); + return false; + } + return true; + } + function checkReferenceExpression(n, invalidReferenceMessage, constantVarianleMessage) { + function findSymbol(n) { + var symbol = getNodeLinks(n).resolvedSymbol; + return symbol && getExportSymbolOfValueSymbolIfExported(symbol); + } + function isReferenceOrErrorExpression(n) { + switch (n.kind) { + case 64: + var symbol = findSymbol(n); + return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; + case 153: + var symbol = findSymbol(n); + return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; + case 154: + return true; + case 159: + return isReferenceOrErrorExpression(n.expression); + default: + return false; + } + } + function isConstVariableReference(n) { + switch (n.kind) { + case 64: + case 153: + var symbol = findSymbol(n); + return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 4096) !== 0; + case 154: + var index = n.argumentExpression; + var symbol = findSymbol(n.expression); + if (symbol && index && index.kind === 8) { + var name = index.text; + var prop = getPropertyOfType(getTypeOfSymbol(symbol), name); + return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 4096) !== 0; + } + return false; + case 159: + return isConstVariableReference(n.expression); + default: + return false; + } + } + if (!isReferenceOrErrorExpression(n)) { + error(n, invalidReferenceMessage); + return false; + } + if (isConstVariableReference(n)) { + error(n, constantVarianleMessage); + return false; + } + return true; + } + function checkDeleteExpression(node) { + if (node.parserContextFlags & 1 && node.expression.kind === 64) { + grammarErrorOnNode(node.expression, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode); + } + var operandType = checkExpression(node.expression); + return booleanType; + } + function checkTypeOfExpression(node) { + var operandType = checkExpression(node.expression); + return stringType; + } + function checkVoidExpression(node) { + var operandType = checkExpression(node.expression); + 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: + case 34: + case 47: + if (someConstituentTypeHasKind(operandType, 1048576)) { + error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator)); + } + return numberType; + case 46: + return booleanType; + case 38: + case 39: + var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type); + if (ok) { + checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant); + } + return numberType; + } + 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) { + checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant); + } + return numberType; + } + function someConstituentTypeHasKind(type, kind) { + if (type.flags & kind) { + return true; + } + if (type.flags & 16384) { + var types = type.types; + for (var i = 0; i < types.length; i++) { + if (types[i].flags & kind) { + return true; + } + } + return false; + } + return false; + } + function allConstituentTypesHaveKind(type, kind) { + if (type.flags & kind) { + return true; + } + if (type.flags & 16384) { + var types = type.types; + for (var i = 0; i < types.length; i++) { + if (!(types[i].flags & kind)) { + return false; + } + } + return true; + } + return false; + } + function isConstEnumObjectType(type) { + return type.flags & (48128 | 32768) && type.symbol && isConstEnumSymbol(type.symbol); + } + function isConstEnumSymbol(symbol) { + return (symbol.flags & 128) !== 0; + } + function checkInstanceOfExpression(node, leftType, rightType) { + if (allConstituentTypesHaveKind(leftType, 1049086)) { + error(node.left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + } + if (!(rightType.flags & 1 || isTypeSubtypeOf(rightType, globalFunctionType))) { + error(node.right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type); + } + return booleanType; + } + function checkInExpression(node, leftType, rightType) { + if (!allConstituentTypesHaveKind(leftType, 1 | 258 | 132 | 1048576)) { + error(node.left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); + } + if (!allConstituentTypesHaveKind(rightType, 1 | 48128 | 512)) { + error(node.right, ts.Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + } + return booleanType; + } + function checkObjectLiteralAssignment(node, sourceType, contextualMapper) { + var properties = node.properties; + for (var i = 0; i < properties.length; i++) { + var p = properties[i]; + if (p.kind === 217 || p.kind === 218) { + var name = p.name; + var type = sourceType.flags & 1 ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || + isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, 1) || + getIndexTypeOfType(sourceType, 0); + if (type) { + checkDestructuringAssignment(p.initializer || name, type); + } + else { + error(name, ts.Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(sourceType), ts.declarationNameToString(name)); + } + } + else { + error(p, ts.Diagnostics.Property_assignment_expected); + } + } + return sourceType; + } + function checkArrayLiteralAssignment(node, sourceType, contextualMapper) { + if (!isArrayLikeType(sourceType)) { + error(node, ts.Diagnostics.Type_0_is_not_an_array_type, typeToString(sourceType)); + return sourceType; + } + var elements = node.elements; + for (var i = 0; i < elements.length; i++) { + var e = elements[i]; + if (e.kind !== 172) { + if (e.kind !== 171) { + var propName = "" + i; + var type = sourceType.flags & 1 ? sourceType : isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) : getIndexTypeOfType(sourceType, 1); + if (type) { + checkDestructuringAssignment(e, type, contextualMapper); + } + else { + error(e, ts.Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName); + } + } + else { + if (i === elements.length - 1) { + checkReferenceAssignment(e.expression, sourceType, contextualMapper); + } + else { + error(e, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern); + } + } + } + } + return sourceType; + } + function checkDestructuringAssignment(target, sourceType, contextualMapper) { + if (target.kind === 167 && target.operatorToken.kind === 52) { + checkBinaryExpression(target, contextualMapper); + target = target.left; + } + if (target.kind === 152) { + return checkObjectLiteralAssignment(target, sourceType, contextualMapper); + } + if (target.kind === 151) { + return checkArrayLiteralAssignment(target, sourceType, contextualMapper); + } + return checkReferenceAssignment(target, sourceType, contextualMapper); + } + function checkReferenceAssignment(target, sourceType, contextualMapper) { + var targetType = checkExpression(target, contextualMapper); + if (checkReferenceExpression(target, ts.Diagnostics.Invalid_left_hand_side_of_assignment_expression, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant)) { + checkTypeAssignableTo(sourceType, targetType, target, undefined); + } + 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 === 52 && (node.left.kind === 152 || node.left.kind === 151)) { + return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); + } + var leftType = checkExpression(node.left, contextualMapper); + var rightType = checkExpression(node.right, contextualMapper); + switch (operator) { + case 35: + case 55: + case 36: + case 56: + case 37: + case 57: + case 34: + case 54: + case 40: + case 58: + case 41: + case 59: + case 42: + case 60: + case 44: + case 62: + case 45: + case 63: + case 43: + case 61: + if (leftType.flags & (32 | 64)) + leftType = rightType; + if (rightType.flags & (32 | 64)) + rightType = leftType; + var suggestedOperator; + if ((leftType.flags & 8) && + (rightType.flags & 8) && + (suggestedOperator = getSuggestedBooleanOperator(node.operatorToken.kind)) !== undefined) { + error(node, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(node.operatorToken.kind), ts.tokenToString(suggestedOperator)); + } + else { + var leftOk = checkArithmeticOperandType(node.left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); + var rightOk = checkArithmeticOperandType(node.right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); + if (leftOk && rightOk) { + checkAssignmentOperator(numberType); + } + } + return numberType; + case 33: + case 53: + if (leftType.flags & (32 | 64)) + leftType = rightType; + if (rightType.flags & (32 | 64)) + rightType = leftType; + var resultType; + if (allConstituentTypesHaveKind(leftType, 132) && allConstituentTypesHaveKind(rightType, 132)) { + resultType = numberType; + } + else { + if (allConstituentTypesHaveKind(leftType, 258) || allConstituentTypesHaveKind(rightType, 258)) { + resultType = stringType; + } + else if (leftType.flags & 1 || rightType.flags & 1) { + resultType = anyType; + } + if (resultType && !checkForDisallowedESSymbolOperand(operator)) { + return resultType; + } + } + if (!resultType) { + reportOperatorError(); + return anyType; + } + if (operator === 53) { + checkAssignmentOperator(resultType); + } + return resultType; + case 24: + case 25: + case 26: + case 27: + if (!checkForDisallowedESSymbolOperand(operator)) { + return booleanType; + } + case 28: + case 29: + case 30: + case 31: + if (!isTypeAssignableTo(leftType, rightType) && !isTypeAssignableTo(rightType, leftType)) { + reportOperatorError(); + } + return booleanType; + case 86: + return checkInstanceOfExpression(node, leftType, rightType); + case 85: + return checkInExpression(node, leftType, rightType); + case 48: + return rightType; + case 49: + return getUnionType([leftType, rightType]); + case 52: + checkAssignmentOperator(rightType); + return rightType; + case 23: + return rightType; + } + function checkForDisallowedESSymbolOperand(operator) { + var offendingSymbolOperand = someConstituentTypeHasKind(leftType, 1048576) ? node.left : someConstituentTypeHasKind(rightType, 1048576) ? node.right : undefined; + if (offendingSymbolOperand) { + error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator)); + return false; + } + return true; + } + function getSuggestedBooleanOperator(operator) { + switch (operator) { + case 44: + case 62: + return 49; + case 45: + case 63: + return 31; + case 43: + case 61: + return 48; + default: + return undefined; + } + } + function checkAssignmentOperator(valueType) { + if (produceDiagnostics && operator >= 52 && operator <= 63) { + var ok = checkReferenceExpression(node.left, ts.Diagnostics.Invalid_left_hand_side_of_assignment_expression, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant); + if (ok) { + checkTypeAssignableTo(valueType, leftType, node.left, undefined); + } + } + } + function reportOperatorError() { + error(node, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(node.operatorToken.kind), typeToString(leftType), typeToString(rightType)); + } + } + function checkYieldExpression(node) { + if (!(node.parserContextFlags & 4)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.yield_expression_must_be_contained_within_a_generator_declaration); + } + else { + grammarErrorOnFirstToken(node, ts.Diagnostics.yield_expressions_are_not_currently_supported); + } + } + function checkConditionalExpression(node, contextualMapper) { + checkExpression(node.condition); + var type1 = checkExpression(node.whenTrue, contextualMapper); + var type2 = checkExpression(node.whenFalse, contextualMapper); + return getUnionType([type1, type2]); + } + function checkTemplateExpression(node) { + ts.forEach(node.templateSpans, function (templateSpan) { + checkExpression(templateSpan.expression); + }); + return stringType; + } + function checkExpressionWithContextualType(node, contextualType, contextualMapper) { + var saveContextualType = node.contextualType; + node.contextualType = contextualType; + var result = checkExpression(node, contextualMapper); + node.contextualType = saveContextualType; + return result; + } + function checkExpressionCached(node, contextualMapper) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = checkExpression(node, contextualMapper); + } + return links.resolvedType; + } + function checkPropertyAssignment(node, contextualMapper) { + if (node.name.kind === 126) { + checkComputedPropertyName(node.name); + } + return checkExpression(node.initializer, contextualMapper); + } + function checkObjectLiteralMethod(node, contextualMapper) { + checkGrammarMethod(node); + if (node.name.kind === 126) { + checkComputedPropertyName(node.name); + } + var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); + return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); + } + function instantiateTypeWithSingleGenericCallSignature(node, type, contextualMapper) { + if (contextualMapper && contextualMapper !== identityMapper) { + var signature = getSingleCallSignature(type); + if (signature && signature.typeParameters) { + var contextualType = getContextualType(node); + if (contextualType) { + var contextualSignature = getSingleCallSignature(contextualType); + if (contextualSignature && !contextualSignature.typeParameters) { + return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper)); + } + } + } + } + return type; + } + function checkExpression(node, contextualMapper) { + return checkExpressionOrQualifiedName(node, contextualMapper); + } + function checkExpressionOrQualifiedName(node, contextualMapper) { + var type; + if (node.kind == 125) { + type = checkQualifiedName(node); + } + else { + var uninstantiatedType = checkExpressionWorker(node, contextualMapper); + type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); + } + if (isConstEnumObjectType(type)) { + var ok = (node.parent.kind === 153 && node.parent.expression === node) || + (node.parent.kind === 154 && node.parent.expression === node) || + ((node.kind === 64 || node.kind === 125) && 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); + } + } + return type; + } + function checkNumericLiteral(node) { + checkGrammarNumbericLiteral(node); + return numberType; + } + function checkExpressionWorker(node, contextualMapper) { + switch (node.kind) { + case 64: + return checkIdentifier(node); + case 92: + return checkThisExpression(node); + case 90: + return checkSuperExpression(node); + case 88: + return nullType; + case 94: + case 79: + return booleanType; + case 7: + return checkNumericLiteral(node); + case 169: + return checkTemplateExpression(node); + case 8: + case 10: + return stringType; + case 9: + return globalRegExpType; + case 151: + return checkArrayLiteral(node, contextualMapper); + case 152: + return checkObjectLiteral(node, contextualMapper); + case 153: + return checkPropertyAccessExpression(node); + case 154: + return checkIndexedAccess(node); + case 155: + case 156: + return checkCallExpression(node); + case 157: + return checkTaggedTemplateExpression(node); + case 158: + return checkTypeAssertion(node); + case 159: + return checkExpression(node.expression, contextualMapper); + case 160: + case 161: + return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); + case 163: + return checkTypeOfExpression(node); + case 162: + return checkDeleteExpression(node); + case 164: + return checkVoidExpression(node); + case 165: + return checkPrefixUnaryExpression(node); + case 166: + return checkPostfixUnaryExpression(node); + case 167: + return checkBinaryExpression(node, contextualMapper); + case 168: + return checkConditionalExpression(node, contextualMapper); + case 171: + return checkSpreadElementExpression(node, contextualMapper); + case 172: + return undefinedType; + case 170: + checkYieldExpression(node); + return unknownType; + } + return unknownType; + } + function checkTypeParameter(node) { + if (node.expression) { + grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); + } + checkSourceElement(node.constraint); + if (produceDiagnostics) { + checkTypeParameterHasIllegalReferencesInConstraint(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); + } + } + function checkParameter(node) { + checkGrammarModifiers(node) || checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + checkVariableLikeDeclaration(node); + var func = ts.getContainingFunction(node); + if (node.flags & 112) { + func = ts.getContainingFunction(node); + if (!(func.kind === 133 && ts.nodeIsPresent(func.body))) { + error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); + } + } + if (node.questionToken && ts.isBindingPattern(node.name) && func.body) { + error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); + } + if (node.dotDotDotToken) { + if (!isArrayType(getTypeOfSymbol(node.symbol))) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type); + } + } + } + function checkSignatureDeclaration(node) { + if (node.kind === 138) { + checkGrammarIndexSignature(node); + } + else if (node.kind === 140 || node.kind === 195 || node.kind === 141 || + node.kind === 136 || node.kind === 133 || + node.kind === 137) { + checkGrammarFunctionLikeDeclaration(node); + } + checkTypeParameters(node.typeParameters); + ts.forEach(node.parameters, checkParameter); + if (node.type) { + checkSourceElement(node.type); + } + if (produceDiagnostics) { + checkCollisionWithArgumentsInGeneratedCode(node); + if (compilerOptions.noImplicitAny && !node.type) { + switch (node.kind) { + case 137: + error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + case 136: + error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + } + } + } + checkSpecializedSignatureDeclaration(node); + } + function checkTypeForDuplicateIndexSignatures(node) { + if (node.kind === 197) { + var nodeSymbol = getSymbolOfNode(node); + if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { + return; + } + } + var indexSymbol = getIndexSymbol(getSymbolOfNode(node)); + if (indexSymbol) { + var seenNumericIndexer = false; + var seenStringIndexer = false; + for (var i = 0, len = indexSymbol.declarations.length; i < len; ++i) { + var declaration = indexSymbol.declarations[i]; + if (declaration.parameters.length === 1 && declaration.parameters[0].type) { + switch (declaration.parameters[0].type.kind) { + case 121: + if (!seenStringIndexer) { + seenStringIndexer = true; + } + else { + error(declaration, ts.Diagnostics.Duplicate_string_index_signature); + } + break; + case 119: + if (!seenNumericIndexer) { + seenNumericIndexer = true; + } + else { + error(declaration, ts.Diagnostics.Duplicate_number_index_signature); + } + break; + } + } + } + } + } + function checkPropertyDeclaration(node) { + checkGrammarModifiers(node) || checkGrammarProperty(node) || checkGrammarComputedPropertyName(node.name); + checkVariableLikeDeclaration(node); + } + function checkMethodDeclaration(node) { + checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name); + checkFunctionLikeDeclaration(node); + } + function checkConstructorDeclaration(node) { + checkSignatureDeclaration(node); + checkGrammarConstructorTypeParameters(node) || checkGrammarConstructorTypeAnnotation(node); + checkSourceElement(node.body); + var symbol = getSymbolOfNode(node); + var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind); + if (node === firstDeclaration) { + checkFunctionOrConstructorSymbol(symbol); + } + if (ts.nodeIsMissing(node.body)) { + return; + } + if (!produceDiagnostics) { + return; + } + function isSuperCallExpression(n) { + return n.kind === 155 && n.expression.kind === 90; + } + function containsSuperCall(n) { + if (isSuperCallExpression(n)) { + return true; + } + switch (n.kind) { + case 160: + case 195: + case 161: + case 152: return false; + default: return ts.forEachChild(n, containsSuperCall); + } + } + function markThisReferencesAsErrors(n) { + if (n.kind === 92) { + error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); + } + else if (n.kind !== 160 && n.kind !== 195) { + ts.forEachChild(n, markThisReferencesAsErrors); + } + } + function isInstancePropertyWithInitializer(n) { + return n.kind === 130 && + !(n.flags & 128) && + !!n.initializer; + } + if (ts.getClassBaseTypeNode(node.parent)) { + if (containsSuperCall(node.body)) { + var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) || + 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 !== 177 || !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 { + markThisReferencesAsErrors(statements[0].expression); + } + } + } + else { + error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call); + } + } + } + function checkAccessorDeclaration(node) { + if (produceDiagnostics) { + checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); + if (node.kind === 134) { + 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 === 134 ? 135 : 134; + var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); + if (otherAccessor) { + if (((node.flags & 112) !== (otherAccessor.flags & 112))) { + error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility); + } + var currentAccessorType = getAnnotatedAccessorType(node); + var otherAccessorType = getAnnotatedAccessorType(otherAccessor); + if (currentAccessorType && otherAccessorType) { + if (!isTypeIdenticalTo(currentAccessorType, otherAccessorType)) { + error(node, ts.Diagnostics.get_and_set_accessor_must_have_the_same_type); + } + } + } + } + checkAndStoreTypeOfAccessors(getSymbolOfNode(node)); + } + checkFunctionLikeDeclaration(node); + } + function checkTypeReference(node) { + checkGrammarTypeArguments(node, node.typeArguments); + var type = getTypeFromTypeReferenceNode(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); + } + } + } + } + function checkTypeQuery(node) { + getTypeFromTypeQueryNode(node); + } + function checkTypeLiteral(node) { + ts.forEach(node.members, checkSourceElement); + if (produceDiagnostics) { + var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); + checkIndexConstraints(type); + checkTypeForDuplicateIndexSignatures(node); + } + } + function checkArrayType(node) { + checkSourceElement(node.elementType); + } + function checkTupleType(node) { + var hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes); + if (!hasErrorFromDisallowedTrailingComma && node.elementTypes.length === 0) { + grammarErrorOnNode(node, ts.Diagnostics.A_tuple_type_element_list_cannot_be_empty); + } + ts.forEach(node.elementTypes, checkSourceElement); + } + function checkUnionType(node) { + ts.forEach(node.types, checkSourceElement); + } + function isPrivateWithinAmbient(node) { + return (node.flags & 32) && ts.isInAmbientContext(node); + } + function checkSpecializedSignatureDeclaration(signatureDeclarationNode) { + if (!produceDiagnostics) { + return; + } + var signature = getSignatureFromDeclaration(signatureDeclarationNode); + if (!signature.hasStringLiterals) { + return; + } + if (ts.nodeIsPresent(signatureDeclarationNode.body)) { + error(signatureDeclarationNode, ts.Diagnostics.A_signature_with_an_implementation_cannot_use_a_string_literal_type); + return; + } + var signaturesToCheck; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 197) { + ts.Debug.assert(signatureDeclarationNode.kind === 136 || signatureDeclarationNode.kind === 137); + var signatureKind = signatureDeclarationNode.kind === 136 ? 0 : 1; + var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); + var containingType = getDeclaredTypeOfSymbol(containingSymbol); + signaturesToCheck = getSignaturesOfType(containingType, signatureKind); + } + else { + signaturesToCheck = getSignaturesOfSymbol(getSymbolOfNode(signatureDeclarationNode)); + } + for (var i = 0; i < signaturesToCheck.length; i++) { + var otherSignature = signaturesToCheck[i]; + if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) { + return; + } + } + error(signatureDeclarationNode, ts.Diagnostics.Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature); + } + function getEffectiveDeclarationFlags(n, flagsToCheck) { + var flags = ts.getCombinedNodeFlags(n); + if (n.parent.kind !== 197 && ts.isInAmbientContext(n)) { + if (!(flags & 2)) { + flags |= 1; + } + flags |= 2; + } + return flags & flagsToCheck; + } + function checkFunctionOrConstructorSymbol(symbol) { + if (!produceDiagnostics) { + return; + } + function getCanonicalOverload(overloads, implementation) { + var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent; + return implementationSharesContainerWithFirstOverload ? implementation : overloads[0]; + } + function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) { + var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags; + if (someButNotAllOverloadFlags !== 0) { + var canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck); + ts.forEach(overloads, function (o) { + var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags; + if (deviation & 1) { + error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported); + } + else if (deviation & 2) { + error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient); + } + else if (deviation & (32 | 64)) { + error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); + } + }); + } + } + function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken, allHaveQuestionToken) { + if (someHaveQuestionToken !== allHaveQuestionToken) { + var canonicalHasQuestionToken = ts.hasQuestionToken(getCanonicalOverload(overloads, implementation)); + ts.forEach(overloads, function (o) { + var deviation = ts.hasQuestionToken(o) !== canonicalHasQuestionToken; + if (deviation) { + error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_optional_or_required); + } + }); + } + } + var flagsToCheck = 1 | 2 | 32 | 64; + var someNodeFlags = 0; + var allNodeFlags = flagsToCheck; + var someHaveQuestionToken = false; + var allHaveQuestionToken = true; + var hasOverloads = false; + var bodyDeclaration; + var lastSeenNonAmbientDeclaration; + var previousDeclaration; + var declarations = symbol.declarations; + var isConstructor = (symbol.flags & 16384) !== 0; + function reportImplementationExpectedError(node) { + if (node.name && ts.getFullWidth(node.name) === 0) { + return; + } + var seen = false; + var subsequentNode = ts.forEachChild(node.parent, function (c) { + if (seen) { + return c; + } + else { + seen = c === node; + } + }); + if (subsequentNode) { + if (subsequentNode.kind === node.kind) { + var errorNode = subsequentNode.name || subsequentNode; + if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { + ts.Debug.assert(node.kind === 132 || node.kind === 131); + 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, diagnostic); + return; + } + else if (ts.nodeIsPresent(subsequentNode.body)) { + error(errorNode, ts.Diagnostics.Function_implementation_name_must_be_0, ts.declarationNameToString(node.name)); + return; + } + } + } + var errorNode = node.name || node; + if (isConstructor) { + error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing); + } + else { + error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); + } + } + var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536; + var duplicateFunctionDeclaration = false; + var multipleConstructorImplementation = false; + for (var i = 0; i < declarations.length; i++) { + var node = declarations[i]; + var inAmbientContext = ts.isInAmbientContext(node); + var inAmbientContextOrInterface = node.parent.kind === 197 || node.parent.kind === 143 || inAmbientContext; + if (inAmbientContextOrInterface) { + previousDeclaration = undefined; + } + if (node.kind === 195 || node.kind === 132 || node.kind === 131 || node.kind === 133) { + var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); + someNodeFlags |= currentNodeFlags; + allNodeFlags &= currentNodeFlags; + someHaveQuestionToken = someHaveQuestionToken || ts.hasQuestionToken(node); + allHaveQuestionToken = allHaveQuestionToken && ts.hasQuestionToken(node); + if (ts.nodeIsPresent(node.body) && bodyDeclaration) { + if (isConstructor) { + multipleConstructorImplementation = true; + } + else { + duplicateFunctionDeclaration = true; + } + } + else if (!isExportSymbolInsideModule && previousDeclaration && previousDeclaration.parent === node.parent && previousDeclaration.end !== node.pos) { + reportImplementationExpectedError(previousDeclaration); + } + if (ts.nodeIsPresent(node.body)) { + if (!bodyDeclaration) { + bodyDeclaration = node; + } + } + else { + hasOverloads = true; + } + previousDeclaration = node; + if (!inAmbientContextOrInterface) { + lastSeenNonAmbientDeclaration = node; + } + } + } + if (multipleConstructorImplementation) { + ts.forEach(declarations, function (declaration) { + error(declaration, ts.Diagnostics.Multiple_constructor_implementations_are_not_allowed); + }); + } + if (duplicateFunctionDeclaration) { + ts.forEach(declarations, function (declaration) { + error(declaration.name, ts.Diagnostics.Duplicate_function_implementation); + }); + } + if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body) { + reportImplementationExpectedError(lastSeenNonAmbientDeclaration); + } + if (hasOverloads) { + checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags); + checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken); + if (bodyDeclaration) { + var signatures = getSignaturesOfSymbol(symbol); + var bodySignature = getSignatureFromDeclaration(bodyDeclaration); + if (!bodySignature.hasStringLiterals) { + for (var i = 0, len = signatures.length; i < len; ++i) { + if (!signatures[i].hasStringLiterals && !isSignatureAssignableTo(bodySignature, signatures[i])) { + error(signatures[i].declaration, ts.Diagnostics.Overload_signature_is_not_compatible_with_function_implementation); + break; + } + } + } + } + } + } + function checkExportsOnMergedDeclarations(node) { + if (!produceDiagnostics) { + return; + } + var symbol; + var symbol = node.localSymbol; + if (!symbol) { + symbol = getSymbolOfNode(node); + if (!(symbol.flags & 7340032)) { + return; + } + } + if (ts.getDeclarationOfKind(symbol, node.kind) !== node) { + return; + } + var exportedDeclarationSpaces = 0; + var nonExportedDeclarationSpaces = 0; + ts.forEach(symbol.declarations, function (d) { + var declarationSpaces = getDeclarationSpaces(d); + if (getEffectiveDeclarationFlags(d, 1)) { + exportedDeclarationSpaces |= declarationSpaces; + } + else { + nonExportedDeclarationSpaces |= declarationSpaces; + } + }); + var commonDeclarationSpace = exportedDeclarationSpaces & nonExportedDeclarationSpaces; + if (commonDeclarationSpace) { + ts.forEach(symbol.declarations, function (d) { + if (getDeclarationSpaces(d) & commonDeclarationSpace) { + error(d.name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(d.name)); + } + }); + } + function getDeclarationSpaces(d) { + switch (d.kind) { + case 197: + return 2097152; + case 200: + return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; + case 196: + case 199: + return 2097152 | 1048576; + case 202: + var result = 0; + var target = resolveImport(getSymbolOfNode(d)); + ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); + return result; + default: + return 1048576; + } + } + } + function checkFunctionDeclaration(node) { + if (produceDiagnostics) { + checkFunctionLikeDeclaration(node) || + checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) || + checkGrammarFunctionName(node.name) || + checkGrammarForGenerator(node); + checkCollisionWithCapturedSuperVariable(node, node.name); + checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + } + } + function checkFunctionLikeDeclaration(node) { + checkSignatureDeclaration(node); + if (node.name.kind === 126) { + checkComputedPropertyName(node.name); + } + if (!ts.hasDynamicName(node)) { + var symbol = getSymbolOfNode(node); + var localSymbol = node.localSymbol || symbol; + var firstDeclaration = ts.getDeclarationOfKind(localSymbol, node.kind); + if (node === firstDeclaration) { + checkFunctionOrConstructorSymbol(localSymbol); + } + if (symbol.parent) { + if (ts.getDeclarationOfKind(symbol, node.kind) === node) { + checkFunctionOrConstructorSymbol(symbol); + } + } + } + checkSourceElement(node.body); + if (node.type && !isAccessor(node.kind)) { + checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); + } + if (compilerOptions.noImplicitAny && ts.nodeIsMissing(node.body) && !node.type && !isPrivateWithinAmbient(node)) { + reportImplicitAnyError(node, anyType); + } + } + function checkBlock(node) { + if (node.kind === 174) { + checkGrammarStatementInAmbientContext(node); + } + ts.forEach(node.statements, checkSourceElement); + if (ts.isFunctionBlock(node) || node.kind === 201) { + checkFunctionExpressionBodies(node); + } + } + function checkCollisionWithArgumentsInGeneratedCode(node) { + if (!ts.hasRestParameters(node) || ts.isInAmbientContext(node) || ts.nodeIsMissing(node.body)) { + return; + } + ts.forEach(node.parameters, function (p) { + if (p.name && !ts.isBindingPattern(p.name) && p.name.text === argumentsSymbol.name) { + error(p, ts.Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters); + } + }); + } + function needCollisionCheckForIdentifier(node, identifier, name) { + if (!(identifier && identifier.text === name)) { + return false; + } + if (node.kind === 130 || + node.kind === 129 || + node.kind === 132 || + node.kind === 131 || + node.kind === 134 || + node.kind === 135) { + return false; + } + if (ts.isInAmbientContext(node)) { + return false; + } + var root = getRootDeclaration(node); + if (root.kind === 128 && ts.nodeIsMissing(root.parent.body)) { + return false; + } + return true; + } + function checkCollisionWithCapturedThisVariable(node, name) { + if (needCollisionCheckForIdentifier(node, name, "_this")) { + potentialThisCollisions.push(node); + } + } + function checkIfThisIsCapturedInEnclosingScope(node) { + var current = node; + while (current) { + if (getNodeCheckFlags(current) & 4) { + var isDeclaration = node.kind !== 64; + if (isDeclaration) { + error(node.name, ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference); + } + else { + error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference); + } + return; + } + current = current.parent; + } + } + function checkCollisionWithCapturedSuperVariable(node, name) { + if (!needCollisionCheckForIdentifier(node, name, "_super")) { + return; + } + var enclosingClass = ts.getAncestor(node, 196); + if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { + return; + } + if (ts.getClassBaseTypeNode(enclosingClass)) { + var isDeclaration = node.kind !== 64; + if (isDeclaration) { + error(node, ts.Diagnostics.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference); + } + else { + error(node, ts.Diagnostics.Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference); + } + } + } + function checkCollisionWithRequireExportsInGeneratedCode(node, name) { + if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { + return; + } + if (node.kind === 200 && ts.getModuleInstanceState(node) !== 1) { + return; + } + var parent = getDeclarationContainer(node); + if (parent.kind === 220 && ts.isExternalModule(parent)) { + error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); + } + } + function checkVarDeclaredNamesNotShadowed(node) { + if (node.initializer && (ts.getCombinedNodeFlags(node) & 6144) === 0) { + var symbol = getSymbolOfNode(node); + if (symbol.flags & 1) { + var localDeclarationSymbol = resolveName(node, node.name.text, 3, undefined, undefined); + if (localDeclarationSymbol && + localDeclarationSymbol !== symbol && + localDeclarationSymbol.flags & 2) { + if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 6144) { + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 194); + var container = varDeclList.parent.kind === 175 && + varDeclList.parent.parent; + var namesShareScope = container && + (container.kind === 174 && ts.isAnyFunction(container.parent) || + (container.kind === 201 && container.kind === 200) || + container.kind === 220); + if (!namesShareScope) { + var name = symbolToString(localDeclarationSymbol); + error(ts.getErrorSpanForNode(node), ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name); + } + } + } + } + } + } + function isParameterDeclaration(node) { + while (node.kind === 150) { + node = node.parent.parent; + } + return node.kind === 128; + } + function checkParameterInitializer(node) { + if (getRootDeclaration(node).kind === 128) { + var func = ts.getContainingFunction(node); + visit(node.initializer); + } + function visit(n) { + if (n.kind === 64) { + var referencedSymbol = getNodeLinks(n).resolvedSymbol; + if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { + if (referencedSymbol.valueDeclaration.kind === 128) { + if (referencedSymbol.valueDeclaration === node) { + error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); + return; + } + if (referencedSymbol.valueDeclaration.pos < node.pos) { + return; + } + } + error(n, ts.Diagnostics.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(node.name), ts.declarationNameToString(n)); + } + } + else { + ts.forEachChild(n, visit); + } + } + } + function checkVariableLikeDeclaration(node) { + checkSourceElement(node.type); + if (node.name.kind === 126) { + checkComputedPropertyName(node.name); + if (node.initializer) { + checkExpressionCached(node.initializer); + } + } + if (ts.isBindingPattern(node.name)) { + ts.forEach(node.name.elements, checkSourceElement); + } + if (node.initializer && getRootDeclaration(node).kind === 128 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); + return; + } + if (ts.isBindingPattern(node.name)) { + if (node.initializer) { + checkTypeAssignableTo(checkExpressionCached(node.initializer), getWidenedTypeForVariableLikeDeclaration(node), node, undefined); + checkParameterInitializer(node); + } + return; + } + var symbol = getSymbolOfNode(node); + var type = getTypeOfVariableOrParameterOrProperty(symbol); + if (node === symbol.valueDeclaration) { + if (node.initializer) { + checkTypeAssignableTo(checkExpressionCached(node.initializer), type, node, undefined); + checkParameterInitializer(node); + } + } + else { + var declarationType = getWidenedTypeForVariableLikeDeclaration(node); + if (type !== unknownType && declarationType !== unknownType && !isTypeIdenticalTo(type, declarationType)) { + error(node.name, ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, ts.declarationNameToString(node.name), typeToString(type), typeToString(declarationType)); + } + if (node.initializer) { + checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); + } + } + if (node.kind !== 130 && node.kind !== 129) { + checkExportsOnMergedDeclarations(node); + if (node.kind === 193 || node.kind === 150) { + checkVarDeclaredNamesNotShadowed(node); + } + checkCollisionWithCapturedSuperVariable(node, node.name); + checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + } + } + function checkVariableDeclaration(node) { + checkGrammarVariableDeclaration(node); + return checkVariableLikeDeclaration(node); + } + function checkBindingElement(node) { + checkGrammarBindingElement(node); + return checkVariableLikeDeclaration(node); + } + function checkVariableStatement(node) { + checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) || checkGrammarModifiers(node) || checkGrammarVariableDeclarationList(node.declarationList) || checkGrammarForDisallowedLetOrConstStatement(node); + ts.forEach(node.declarationList.declarations, checkSourceElement); + } + function checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) { + if (node.modifiers) { + if (inBlockOrObjectLiteralExpression(node)) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); + } + } + } + function inBlockOrObjectLiteralExpression(node) { + while (node) { + if (node.kind === 174 || node.kind === 152) { + return true; + } + node = node.parent; + } + } + function checkExpressionStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkExpression(node.expression); + } + function checkIfStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkExpression(node.expression); + checkSourceElement(node.thenStatement); + checkSourceElement(node.elseStatement); + } + function checkDoStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkSourceElement(node.statement); + checkExpression(node.expression); + } + function checkWhileStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkExpression(node.expression); + checkSourceElement(node.statement); + } + function checkForStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.initializer && node.initializer.kind == 194) { + checkGrammarVariableDeclarationList(node.initializer); + } + } + if (node.initializer) { + if (node.initializer.kind === 194) { + ts.forEach(node.initializer.declarations, checkVariableDeclaration); + } + else { + checkExpression(node.initializer); + } + } + if (node.condition) + checkExpression(node.condition); + if (node.iterator) + checkExpression(node.iterator); + checkSourceElement(node.statement); + } + function checkForOfStatement(node) { + checkGrammarForOfStatement(node); + } + function checkForInStatement(node) { + checkGrammarForInOrForOfStatement(node); + if (node.initializer.kind === 194) { + var variableDeclarationList = node.initializer; + if (variableDeclarationList.declarations.length >= 1) { + var decl = variableDeclarationList.declarations[0]; + checkVariableDeclaration(decl); + } + } + else { + var varExpr = node.initializer; + var exprType = checkExpression(varExpr); + if (!allConstituentTypesHaveKind(exprType, 1 | 258)) { + error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any); + } + else { + checkReferenceExpression(varExpr, ts.Diagnostics.Invalid_left_hand_side_in_for_in_statement, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant); + } + } + var exprType = checkExpression(node.expression); + if (!allConstituentTypesHaveKind(exprType, 1 | 48128 | 512)) { + error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter); + } + checkSourceElement(node.statement); + } + function checkBreakOrContinueStatement(node) { + checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); + } + function isGetAccessorWithAnnotatatedSetAccessor(node) { + return !!(node.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 135))); + } + function checkReturnStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + var functionBlock = ts.getContainingFunction(node); + if (!functionBlock) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body); + } + } + if (node.expression) { + var func = ts.getContainingFunction(node); + if (func) { + var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + var exprType = checkExpressionCached(node.expression); + if (func.kind === 135) { + error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); + } + else { + if (func.kind === 133) { + 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)) { + 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); + } + } + checkExpression(node.expression); + error(node.expression, ts.Diagnostics.All_symbols_within_a_with_block_will_be_resolved_to_any); + } + function checkSwitchStatement(node) { + checkGrammarStatementInAmbientContext(node); + var firstDefaultClause; + var hasDuplicateDefaultClause = false; + var expressionType = checkExpression(node.expression); + ts.forEach(node.clauses, function (clause) { + if (clause.kind === 214 && !hasDuplicateDefaultClause) { + if (firstDefaultClause === undefined) { + firstDefaultClause = clause; + } + else { + var sourceFile = ts.getSourceFileOfNode(node); + var start = ts.skipTrivia(sourceFile.text, clause.pos); + var end = clause.statements.length > 0 ? clause.statements[0].pos : clause.end; + grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement); + hasDuplicateDefaultClause = true; + } + } + if (produceDiagnostics && clause.kind === 213) { + var caseClause = clause; + var caseType = checkExpression(caseClause.expression); + if (!isTypeAssignableTo(expressionType, caseType)) { + checkTypeAssignableTo(caseType, expressionType, caseClause.expression, undefined); + } + } + ts.forEach(clause.statements, checkSourceElement); + }); + } + function checkLabeledStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + var current = node.parent; + while (current) { + if (ts.isAnyFunction(current)) { + break; + } + if (current.kind === 189 && 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; + } + current = current.parent; + } + } + checkSourceElement(node.statement); + } + function checkThrowStatement(node) { + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.expression === undefined) { + grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here); + } + } + if (node.expression) { + checkExpression(node.expression); + } + } + function checkTryStatement(node) { + checkGrammarStatementInAmbientContext(node); + checkBlock(node.tryBlock); + var catchClause = node.catchClause; + if (catchClause) { + if (catchClause.type) { + var sourceFile = ts.getSourceFileOfNode(node); + var colonStart = ts.skipTrivia(sourceFile.text, catchClause.name.end); + grammarErrorAtPos(sourceFile, colonStart, ":".length, ts.Diagnostics.Catch_clause_parameter_cannot_have_a_type_annotation); + } + checkGrammarEvalOrArgumentsInStrictMode(node, catchClause.name); + checkBlock(catchClause.block); + } + if (node.finallyBlock) + checkBlock(node.finallyBlock); + } + function checkIndexConstraints(type) { + var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1); + var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0); + var stringIndexType = getIndexTypeOfType(type, 0); + var numberIndexType = getIndexTypeOfType(type, 1); + if (stringIndexType || numberIndexType) { + ts.forEach(getPropertiesOfObjectType(type), function (prop) { + var propType = getTypeOfSymbol(prop); + checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0); + checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1); + }); + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 196) { + var classDeclaration = type.symbol.valueDeclaration; + for (var i = 0; i < classDeclaration.members.length; i++) { + var member = classDeclaration.members[i]; + if (!(member.flags & 128) && ts.hasDynamicName(member)) { + var propType = getTypeOfSymbol(member.symbol); + checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0); + checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1); + } + } + } + } + var errorNode; + if (stringIndexType && numberIndexType) { + errorNode = declaredNumberIndexer || declaredStringIndexer; + if (!errorNode && (type.flags & 2048)) { + var someBaseTypeHasBothIndexers = ts.forEach(type.baseTypes, function (base) { return getIndexTypeOfType(base, 0) && getIndexTypeOfType(base, 1); }); + errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0]; + } + } + if (errorNode && !isTypeAssignableTo(numberIndexType, stringIndexType)) { + error(errorNode, ts.Diagnostics.Numeric_index_type_0_is_not_assignable_to_string_index_type_1, typeToString(numberIndexType), typeToString(stringIndexType)); + } + function checkIndexConstraintForProperty(prop, propertyType, containingType, indexDeclaration, indexType, indexKind) { + if (!indexType) { + return; + } + if (indexKind === 1 && !isNumericName(prop.valueDeclaration.name)) { + return; + } + var errorNode; + if (prop.valueDeclaration.name.kind === 126 || prop.parent === containingType.symbol) { + errorNode = prop.valueDeclaration; + } + else if (indexDeclaration) { + errorNode = indexDeclaration; + } + else if (containingType.flags & 2048) { + var someBaseClassHasBothPropertyAndIndexer = ts.forEach(containingType.baseTypes, function (base) { return getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind); }); + errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0]; + } + if (errorNode && !isTypeAssignableTo(propertyType, indexType)) { + var errorMessage = indexKind === 0 ? ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2 : ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2; + error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType)); + } + } + } + function checkTypeNameIsReserved(name, message) { + switch (name.text) { + case "any": + case "number": + case "boolean": + case "string": + case "symbol": + case "void": + error(name, message, name.text); + } + } + function checkTypeParameters(typeParameterDeclarations) { + if (typeParameterDeclarations) { + for (var i = 0; i < typeParameterDeclarations.length; i++) { + var node = typeParameterDeclarations[i]; + checkTypeParameter(node); + if (produceDiagnostics) { + for (var j = 0; j < i; j++) { + if (typeParameterDeclarations[j].symbol === node.symbol) { + error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name)); + } + } + } + } + } + } + function checkClassDeclaration(node) { + checkGrammarClassDeclarationHeritageClauses(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Class_name_cannot_be_0); + checkTypeParameters(node.typeParameters); + checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + var type = getDeclaredTypeOfSymbol(symbol); + var staticType = getTypeOfSymbol(symbol); + var baseTypeNode = ts.getClassBaseTypeNode(node); + if (baseTypeNode) { + emitExtends = emitExtends || !ts.isInAmbientContext(node); + checkTypeReference(baseTypeNode); + } + if (type.baseTypes.length) { + if (produceDiagnostics) { + var baseType = type.baseTypes[0]; + checkTypeAssignableTo(type, baseType, node.name, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); + var staticBaseType = getTypeOfSymbol(baseType.symbol); + checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + if (baseType.symbol !== resolveEntityName(node, baseTypeNode.typeName, 107455)) { + error(baseTypeNode, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType)); + } + checkKindsOfPropertyMemberOverrides(type, baseType); + } + checkExpressionOrQualifiedName(baseTypeNode.typeName); + } + var implementedTypeNodes = ts.getClassImplementedTypeNodes(node); + if (implementedTypeNodes) { + ts.forEach(implementedTypeNodes, function (typeRefNode) { + checkTypeReference(typeRefNode); + if (produceDiagnostics) { + var t = getTypeFromTypeReferenceNode(typeRefNode); + if (t !== unknownType) { + var declaredType = (t.flags & 4096) ? t.target : t; + if (declaredType.flags & (1024 | 2048)) { + checkTypeAssignableTo(type, t, node.name, ts.Diagnostics.Class_0_incorrectly_implements_interface_1); + } + else { + error(typeRefNode, ts.Diagnostics.A_class_may_only_implement_another_class_or_interface); + } + } + } + }); + } + ts.forEach(node.members, checkSourceElement); + if (produceDiagnostics) { + checkIndexConstraints(type); + checkTypeForDuplicateIndexSignatures(node); + } + } + function getTargetSymbol(s) { + return s.flags & 16777216 ? getSymbolLinks(s).target : s; + } + function checkKindsOfPropertyMemberOverrides(type, baseType) { + var baseProperties = getPropertiesOfObjectType(baseType); + for (var i = 0, len = baseProperties.length; i < len; ++i) { + var base = getTargetSymbol(baseProperties[i]); + if (base.flags & 134217728) { + continue; + } + var derived = getTargetSymbol(getPropertyOfObjectType(type, base.name)); + if (derived) { + var baseDeclarationFlags = getDeclarationFlagsFromSymbol(base); + var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived); + if ((baseDeclarationFlags & 32) || (derivedDeclarationFlags & 32)) { + continue; + } + if ((baseDeclarationFlags & 128) !== (derivedDeclarationFlags & 128)) { + continue; + } + if ((base.flags & derived.flags & 8192) || ((base.flags & 98308) && (derived.flags & 98308))) { + continue; + } + var errorMessage; + if (base.flags & 8192) { + if (derived.flags & 98304) { + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } + else { + ts.Debug.assert((derived.flags & 4) !== 0); + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property; + } + } + else if (base.flags & 4) { + ts.Debug.assert((derived.flags & 8192) !== 0); + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; + } + else { + ts.Debug.assert((base.flags & 98304) !== 0); + ts.Debug.assert((derived.flags & 8192) !== 0); + errorMessage = ts.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)); + } + } + } + function isAccessor(kind) { + return kind === 134 || kind === 135; + } + function areTypeParametersIdentical(list1, list2) { + if (!list1 && !list2) { + return true; + } + if (!list1 || !list2 || list1.length !== list2.length) { + return false; + } + for (var i = 0, len = list1.length; i < len; i++) { + var tp1 = list1[i]; + var tp2 = list2[i]; + if (tp1.name.text !== tp2.name.text) { + return false; + } + if (!tp1.constraint && !tp2.constraint) { + continue; + } + if (!tp1.constraint || !tp2.constraint) { + return false; + } + if (!isTypeIdenticalTo(getTypeFromTypeNode(tp1.constraint), getTypeFromTypeNode(tp2.constraint))) { + return false; + } + } + return true; + } + function checkInheritedPropertiesAreIdentical(type, typeNode) { + if (!type.baseTypes.length || type.baseTypes.length === 1) { + return true; + } + var seen = {}; + ts.forEach(type.declaredProperties, function (p) { seen[p.name] = { prop: p, containingType: type }; }); + var ok = true; + for (var i = 0, len = type.baseTypes.length; i < len; ++i) { + var base = type.baseTypes[i]; + var properties = getPropertiesOfObjectType(base); + for (var j = 0, proplen = properties.length; j < proplen; ++j) { + var prop = properties[j]; + if (!ts.hasProperty(seen, prop.name)) { + seen[prop.name] = { prop: prop, containingType: base }; + } + else { + var existing = seen[prop.name]; + var isInheritedProperty = existing.containingType !== type; + if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) { + ok = false; + var typeName1 = typeToString(existing.containingType); + var typeName2 = typeToString(base); + var errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2); + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo)); + } + } + } + } + return ok; + } + function checkInterfaceDeclaration(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, 197); + 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); + } + } + if (node === firstInterfaceDecl) { + var type = getDeclaredTypeOfSymbol(symbol); + if (checkInheritedPropertiesAreIdentical(type, node.name)) { + ts.forEach(type.baseTypes, function (baseType) { + checkTypeAssignableTo(type, baseType, node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1); + }); + checkIndexConstraints(type); + } + } + } + ts.forEach(ts.getInterfaceBaseTypeNodes(node), checkTypeReference); + ts.forEach(node.members, checkSourceElement); + if (produceDiagnostics) { + checkTypeForDuplicateIndexSignatures(node); + } + } + function checkTypeAliasDeclaration(node) { + checkGrammarModifiers(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0); + checkSourceElement(node.type); + } + function computeEnumMemberValues(node) { + var nodeLinks = getNodeLinks(node); + if (!(nodeLinks.flags & 128)) { + var enumSymbol = getSymbolOfNode(node); + var enumType = getDeclaredTypeOfSymbol(enumSymbol); + var autoValue = 0; + var ambient = ts.isInAmbientContext(node); + var enumIsConst = ts.isConst(node); + ts.forEach(node.members, function (member) { + if (member.name.kind !== 126 && isNumericLiteralName(member.name.text)) { + error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); + } + var initializer = member.initializer; + if (initializer) { + autoValue = getConstantValueForEnumMemberInitializer(initializer, enumIsConst); + if (autoValue === undefined) { + if (enumIsConst) { + error(initializer, ts.Diagnostics.In_const_enum_declarations_member_initializer_must_be_constant_expression); + } + else if (!ambient) { + checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, undefined); + } + } + else if (enumIsConst) { + if (isNaN(autoValue)) { + error(initializer, ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN); + } + else if (!isFinite(autoValue)) { + error(initializer, ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value); + } + } + } + else if (ambient && !enumIsConst) { + autoValue = undefined; + } + if (autoValue !== undefined) { + getNodeLinks(member).enumMemberValue = autoValue++; + } + }); + nodeLinks.flags |= 128; + } + function getConstantValueForEnumMemberInitializer(initializer, enumIsConst) { + return evalConstant(initializer); + function evalConstant(e) { + switch (e.kind) { + case 165: + var value = evalConstant(e.operand); + if (value === undefined) { + return undefined; + } + switch (e.operator) { + case 33: return value; + case 34: return -value; + case 47: return enumIsConst ? ~value : undefined; + } + return undefined; + case 167: + if (!enumIsConst) { + return undefined; + } + var left = evalConstant(e.left); + if (left === undefined) { + return undefined; + } + var right = evalConstant(e.right); + if (right === undefined) { + return undefined; + } + switch (e.operatorToken.kind) { + case 44: return left | right; + case 43: return left & right; + case 41: return left >> right; + case 42: return left >>> right; + case 40: return left << right; + case 45: return left ^ right; + case 35: return left * right; + case 36: return left / right; + case 33: return left + right; + case 34: return left - right; + case 37: return left % right; + } + return undefined; + case 7: + return +e.text; + case 159: + return enumIsConst ? evalConstant(e.expression) : undefined; + case 64: + case 154: + case 153: + if (!enumIsConst) { + return undefined; + } + var member = initializer.parent; + var currentType = getTypeOfSymbol(getSymbolOfNode(member.parent)); + var enumType; + var propertyName; + if (e.kind === 64) { + enumType = currentType; + propertyName = e.text; + } + else { + if (e.kind === 154) { + if (e.argumentExpression === undefined || + e.argumentExpression.kind !== 8) { + return undefined; + } + var enumType = getTypeOfNode(e.expression); + propertyName = e.argumentExpression.text; + } + else { + var enumType = getTypeOfNode(e.expression); + propertyName = e.name.text; + } + if (enumType !== currentType) { + return undefined; + } + } + if (propertyName === undefined) { + return undefined; + } + var property = getPropertyOfObjectType(enumType, propertyName); + if (!property || !(property.flags & 8)) { + return undefined; + } + var propertyDecl = property.valueDeclaration; + if (member === propertyDecl) { + return undefined; + } + if (!isDefinedBefore(propertyDecl, member)) { + return undefined; + } + return getNodeLinks(propertyDecl).enumMemberValue; + } + } + } + } + function checkEnumDeclaration(node) { + if (!produceDiagnostics) { + return; + } + checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Enum_name_cannot_be_0); + checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkExportsOnMergedDeclarations(node); + computeEnumMemberValues(node); + var enumSymbol = getSymbolOfNode(node); + var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind); + if (node === firstDeclaration) { + if (enumSymbol.declarations.length > 1) { + var enumIsConst = ts.isConst(node); + ts.forEach(enumSymbol.declarations, function (decl) { + if (ts.isConstEnumDeclaration(decl) !== enumIsConst) { + error(decl.name, ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const); + } + }); + } + var seenEnumMissingInitialInitializer = false; + ts.forEach(enumSymbol.declarations, function (declaration) { + if (declaration.kind !== 199) { + return false; + } + var enumDeclaration = declaration; + if (!enumDeclaration.members.length) { + return false; + } + var firstEnumMember = enumDeclaration.members[0]; + if (!firstEnumMember.initializer) { + if (seenEnumMissingInitialInitializer) { + error(firstEnumMember.name, ts.Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element); + } + else { + seenEnumMissingInitialInitializer = true; + } + } + }); + } + } + function getFirstNonAmbientClassOrFunctionDeclaration(symbol) { + var declarations = symbol.declarations; + for (var i = 0; i < declarations.length; i++) { + var declaration = declarations[i]; + if ((declaration.kind === 196 || (declaration.kind === 195 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { + return declaration; + } + } + return undefined; + } + function checkModuleDeclaration(node) { + if (produceDiagnostics) { + if (!checkGrammarModifiers(node)) { + if (!ts.isInAmbientContext(node) && node.name.kind === 8) { + grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); + } + else if (node.name.kind === 64 && node.body.kind === 201) { + var statements = node.body.statements; + for (var i = 0, n = statements.length; i < n; i++) { + var statement = statements[i]; + if (statement.kind === 208) { + grammarErrorOnNode(statement, ts.Diagnostics.An_export_assignment_cannot_be_used_in_an_internal_module); + } + } + } + } + checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + if (symbol.flags & 512 && symbol.declarations.length > 1 && !ts.isInAmbientContext(node) && ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums)) { + var classOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol); + if (classOrFunc) { + if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(classOrFunc)) { + error(node.name, ts.Diagnostics.A_module_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged); + } + else if (node.pos < classOrFunc.pos) { + error(node.name, ts.Diagnostics.A_module_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged); + } + } + } + if (node.name.kind === 8) { + if (!isGlobalSourceFile(node.parent)) { + error(node.name, ts.Diagnostics.Ambient_external_modules_cannot_be_nested_in_other_modules); + } + if (isExternalModuleNameRelative(node.name.text)) { + error(node.name, ts.Diagnostics.Ambient_external_module_declaration_cannot_specify_relative_module_name); + } + } + } + checkSourceElement(node.body); + } + function getFirstIdentifier(node) { + while (node.kind === 125) { + node = node.left; + } + return node; + } + function checkExternalImportOrExportDeclaration(node) { + var moduleName = ts.getExternalModuleName(node); + if (ts.getFullWidth(moduleName) !== 0 && moduleName.kind !== 8) { + error(moduleName, ts.Diagnostics.String_literal_expected); + return false; + } + var inAmbientExternalModule = node.parent.kind === 201 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 220 && !inAmbientExternalModule) { + error(moduleName, node.kind === 209 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_an_internal_module : ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); + return false; + } + if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) { + error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); + return false; + } + return true; + } + function checkImportSymbol(node) { + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); + if (target !== unknownSymbol) { + var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | + (symbol.flags & 793056 ? 793056 : 0) | + (symbol.flags & 1536 ? 1536 : 0); + if (target.flags & excludedMeanings) { + var message = node.kind === 211 ? 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)); + } + } + } + function checkImportBinding(node) { + checkCollisionWithCapturedThisVariable(node, node.name); + checkCollisionWithRequireExportsInGeneratedCode(node, node.name); + checkImportSymbol(node); + } + function checkImportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); + } + if (checkExternalImportOrExportDeclaration(node)) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + checkImportBinding(importClause); + } + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 205) { + checkImportBinding(importClause.namedBindings); + } + else { + ts.forEach(importClause.namedBindings.elements, checkImportBinding); + } + } + } + } + } + function checkImportEqualsDeclaration(node) { + checkGrammarModifiers(node); + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + checkImportBinding(node); + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); + if (target !== unknownSymbol) { + if (target.flags & 107455) { + var moduleName = getFirstIdentifier(node.moduleReference); + if (resolveEntityName(node, moduleName, 107455 | 1536).flags & 1536) { + checkExpressionOrQualifiedName(node.moduleReference); + } + else { + error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName)); + } + } + if (target.flags & 793056) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0); + } + } + } + else { + if (checkExternalImportOrExportDeclaration(node)) { + checkImportBinding(node); + } + } + } + function checkExportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); + } + if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { + if (node.exportClause) { + ts.forEach(node.exportClause.elements, checkImportSymbol); + } + } + } + function checkExportAssignment(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); + } + var container = node.parent; + if (container.kind !== 220) { + container = container.parent; + } + checkTypeOfExportAssignmentSymbol(getSymbolOfNode(container)); + } + function checkSourceElement(node) { + if (!node) + return; + switch (node.kind) { + case 127: + return checkTypeParameter(node); + case 128: + return checkParameter(node); + case 130: + case 129: + return checkPropertyDeclaration(node); + case 140: + case 141: + case 136: + case 137: + return checkSignatureDeclaration(node); + case 138: + return checkSignatureDeclaration(node); + case 132: + case 131: + return checkMethodDeclaration(node); + case 133: + return checkConstructorDeclaration(node); + case 134: + case 135: + return checkAccessorDeclaration(node); + case 139: + return checkTypeReference(node); + case 142: + return checkTypeQuery(node); + case 143: + return checkTypeLiteral(node); + case 144: + return checkArrayType(node); + case 145: + return checkTupleType(node); + case 146: + return checkUnionType(node); + case 147: + return checkSourceElement(node.type); + case 195: + return checkFunctionDeclaration(node); + case 174: + case 201: + return checkBlock(node); + case 175: + return checkVariableStatement(node); + case 177: + return checkExpressionStatement(node); + case 178: + return checkIfStatement(node); + case 179: + return checkDoStatement(node); + case 180: + return checkWhileStatement(node); + case 181: + return checkForStatement(node); + case 182: + return checkForInStatement(node); + case 183: + return checkForOfStatement(node); + case 184: + case 185: + return checkBreakOrContinueStatement(node); + case 186: + return checkReturnStatement(node); + case 187: + return checkWithStatement(node); + case 188: + return checkSwitchStatement(node); + case 189: + return checkLabeledStatement(node); + case 190: + return checkThrowStatement(node); + case 191: + return checkTryStatement(node); + case 193: + return checkVariableDeclaration(node); + case 150: + return checkBindingElement(node); + case 196: + return checkClassDeclaration(node); + case 197: + return checkInterfaceDeclaration(node); + case 198: + return checkTypeAliasDeclaration(node); + case 199: + return checkEnumDeclaration(node); + case 200: + return checkModuleDeclaration(node); + case 203: + return checkImportDeclaration(node); + case 202: + return checkImportEqualsDeclaration(node); + case 209: + return checkExportDeclaration(node); + case 208: + return checkExportAssignment(node); + case 176: + checkGrammarStatementInAmbientContext(node); + return; + case 192: + checkGrammarStatementInAmbientContext(node); + return; + } + } + function checkFunctionExpressionBodies(node) { + switch (node.kind) { + case 160: + case 161: + ts.forEach(node.parameters, checkFunctionExpressionBodies); + checkFunctionExpressionOrObjectLiteralMethodBody(node); + break; + case 132: + case 131: + ts.forEach(node.parameters, checkFunctionExpressionBodies); + if (ts.isObjectLiteralMethod(node)) { + checkFunctionExpressionOrObjectLiteralMethodBody(node); + } + break; + case 133: + case 134: + case 135: + case 195: + ts.forEach(node.parameters, checkFunctionExpressionBodies); + break; + case 187: + checkFunctionExpressionBodies(node.expression); + break; + case 128: + case 130: + case 129: + case 148: + case 149: + case 150: + case 151: + case 152: + case 217: + case 153: + case 154: + case 155: + case 156: + case 157: + case 169: + case 173: + case 158: + case 159: + case 163: + case 164: + case 162: + case 165: + case 166: + case 167: + case 168: + case 171: + case 174: + case 201: + case 175: + case 177: + case 178: + case 179: + case 180: + case 181: + case 182: + case 183: + case 184: + case 185: + case 186: + case 188: + case 213: + case 214: + case 189: + case 190: + case 191: + case 216: + case 193: + case 194: + case 196: + case 199: + case 219: + case 220: + ts.forEachChild(node, checkFunctionExpressionBodies); + break; + } + } + function checkSourceFile(node) { + var start = new Date().getTime(); + checkSourceFileWorker(node); + ts.checkTime += new Date().getTime() - start; + } + function checkSourceFileWorker(node) { + var links = getNodeLinks(node); + if (!(links.flags & 1)) { + checkGrammarSourceFile(node); + emitExtends = false; + potentialThisCollisions.length = 0; + ts.forEach(node.statements, checkSourceElement); + checkFunctionExpressionBodies(node); + if (ts.isExternalModule(node)) { + var symbol = getExportAssignmentSymbol(node.symbol); + if (symbol && symbol.flags & 8388608) { + getSymbolLinks(symbol).referenced = true; + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); + } + } + if (potentialThisCollisions.length) { + ts.forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope); + potentialThisCollisions.length = 0; + } + if (emitExtends) { + links.flags |= 8; + } + links.flags |= 1; + } + } + function getDiagnostics(sourceFile) { + throwIfNonDiagnosticsProducing(); + if (sourceFile) { + checkSourceFile(sourceFile); + return diagnostics.getDiagnostics(sourceFile.fileName); + } + ts.forEach(host.getSourceFiles(), checkSourceFile); + return diagnostics.getDiagnostics(); + } + function getGlobalDiagnostics() { + throwIfNonDiagnosticsProducing(); + return diagnostics.getGlobalDiagnostics(); + } + function throwIfNonDiagnosticsProducing() { + if (!produceDiagnostics) { + throw new Error("Trying to get diagnostics from a type checker that does not produce them."); + } + } + function isInsideWithStatementBody(node) { + if (node) { + while (node.parent) { + if (node.parent.kind === 187 && node.parent.statement === node) { + return true; + } + node = node.parent; + } + } + return false; + } + function getSymbolsInScope(location, meaning) { + var symbols = {}; + var memberFlags = 0; + function copySymbol(symbol, meaning) { + if (symbol.flags & meaning) { + var id = symbol.name; + if (!isReservedMemberName(id) && !ts.hasProperty(symbols, id)) { + symbols[id] = symbol; + } + } + } + function copySymbols(source, meaning) { + if (meaning) { + for (var id in source) { + if (ts.hasProperty(source, id)) { + copySymbol(source[id], meaning); + } + } + } + } + if (isInsideWithStatementBody(location)) { + return []; + } + while (location) { + if (location.locals && !isGlobalSourceFile(location)) { + copySymbols(location.locals, meaning); + } + switch (location.kind) { + case 220: + if (!ts.isExternalModule(location)) + break; + case 200: + copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); + break; + case 199: + copySymbols(getSymbolOfNode(location).exports, meaning & 8); + break; + case 196: + case 197: + if (!(memberFlags & 128)) { + copySymbols(getSymbolOfNode(location).members, meaning & 793056); + } + break; + case 160: + if (location.name) { + copySymbol(location.symbol, meaning); + } + break; + case 216: + if (location.name.text) { + copySymbol(location.symbol, meaning); + } + break; + } + memberFlags = location.flags; + location = location.parent; + } + copySymbols(globals, meaning); + return ts.mapToArray(symbols); + } + function isTypeDeclarationName(name) { + return name.kind == 64 && + isTypeDeclaration(name.parent) && + name.parent.name === name; + } + function isTypeDeclaration(node) { + switch (node.kind) { + case 127: + case 196: + case 197: + case 198: + case 199: + return true; + } + } + function isTypeReferenceIdentifier(entityName) { + var node = entityName; + while (node.parent && node.parent.kind === 125) + node = node.parent; + return node.parent && node.parent.kind === 139; + } + function isTypeNode(node) { + if (139 <= node.kind && node.kind <= 147) { + return true; + } + switch (node.kind) { + case 112: + case 119: + case 121: + case 113: + case 122: + return true; + case 98: + return node.parent.kind !== 164; + case 8: + return node.parent.kind === 128; + case 64: + if (node.parent.kind === 125 && node.parent.right === node) { + node = node.parent; + } + case 125: + ts.Debug.assert(node.kind === 64 || node.kind === 125, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); + var parent = node.parent; + if (parent.kind === 142) { + return false; + } + if (139 <= parent.kind && parent.kind <= 147) { + return true; + } + switch (parent.kind) { + case 127: + return node === parent.constraint; + case 130: + case 129: + case 128: + case 193: + return node === parent.type; + case 195: + case 160: + case 161: + case 133: + case 132: + case 131: + case 134: + case 135: + return node === parent.type; + case 136: + case 137: + case 138: + return node === parent.type; + case 158: + return node === parent.type; + case 155: + case 156: + return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; + case 157: + return false; + } + } + return false; + } + function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { + while (nodeOnRightSide.parent.kind === 125) { + nodeOnRightSide = nodeOnRightSide.parent; + } + if (nodeOnRightSide.parent.kind === 202) { + return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; + } + if (nodeOnRightSide.parent.kind === 208) { + return nodeOnRightSide.parent.exportName === nodeOnRightSide && nodeOnRightSide.parent; + } + return undefined; + } + function isInRightSideOfImportOrExportAssignment(node) { + return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; + } + function isRightSideOfQualifiedNameOrPropertyAccess(node) { + return (node.parent.kind === 125 && node.parent.right === node) || + (node.parent.kind === 153 && node.parent.name === node); + } + function getSymbolOfEntityNameOrPropertyAccessExpression(entityName) { + if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) { + return getSymbolOfNode(entityName.parent); + } + if (entityName.parent.kind === 208) { + return resolveEntityName(entityName.parent.parent, entityName, 107455 | 793056 | 1536 | 8388608); + } + if (entityName.kind !== 153) { + if (isInRightSideOfImportOrExportAssignment(entityName)) { + return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); + } + } + if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { + entityName = entityName.parent; + } + if (ts.isExpression(entityName)) { + if (ts.getFullWidth(entityName) === 0) { + return undefined; + } + if (entityName.kind === 64) { + var meaning = 107455 | 8388608; + return resolveEntityName(entityName, entityName, meaning); + } + else if (entityName.kind === 153) { + var symbol = getNodeLinks(entityName).resolvedSymbol; + if (!symbol) { + checkPropertyAccessExpression(entityName); + } + return getNodeLinks(entityName).resolvedSymbol; + } + else if (entityName.kind === 125) { + var symbol = getNodeLinks(entityName).resolvedSymbol; + if (!symbol) { + checkQualifiedName(entityName); + } + return getNodeLinks(entityName).resolvedSymbol; + } + } + else if (isTypeReferenceIdentifier(entityName)) { + var meaning = entityName.parent.kind === 139 ? 793056 : 1536; + meaning |= 8388608; + return resolveEntityName(entityName, entityName, meaning); + } + return undefined; + } + function getSymbolInfo(node) { + if (isInsideWithStatementBody(node)) { + return undefined; + } + if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(node)) { + return getSymbolOfNode(node.parent); + } + if (node.kind === 64 && isInRightSideOfImportOrExportAssignment(node)) { + return node.parent.kind === 208 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); + } + switch (node.kind) { + case 64: + case 153: + case 125: + return getSymbolOfEntityNameOrPropertyAccessExpression(node); + case 92: + case 90: + var type = checkExpression(node); + return type.symbol; + case 114: + var constructorDeclaration = node.parent; + if (constructorDeclaration && constructorDeclaration.kind === 133) { + return constructorDeclaration.parent.symbol; + } + return undefined; + case 8: + if (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && + ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) { + var importSymbol = getSymbolOfNode(node.parent.parent); + var moduleType = getTypeOfSymbol(importSymbol); + return moduleType ? moduleType.symbol : undefined; + } + case 7: + if (node.parent.kind == 154 && node.parent.argumentExpression === node) { + var objectType = checkExpression(node.parent.expression); + if (objectType === unknownType) + return undefined; + var apparentType = getApparentType(objectType); + if (apparentType === unknownType) + return undefined; + return getPropertyOfType(apparentType, node.text); + } + break; + } + return undefined; + } + function getShorthandAssignmentValueSymbol(location) { + if (location && location.kind === 218) { + return resolveEntityName(location, location.name, 107455); + } + return undefined; + } + function getTypeOfNode(node) { + if (isInsideWithStatementBody(node)) { + return unknownType; + } + if (ts.isExpression(node)) { + return getTypeOfExpression(node); + } + if (isTypeNode(node)) { + return getTypeFromTypeNode(node); + } + if (isTypeDeclaration(node)) { + var symbol = getSymbolOfNode(node); + return getDeclaredTypeOfSymbol(symbol); + } + if (isTypeDeclarationName(node)) { + var symbol = getSymbolInfo(node); + return symbol && getDeclaredTypeOfSymbol(symbol); + } + if (ts.isDeclaration(node)) { + var symbol = getSymbolOfNode(node); + return getTypeOfSymbol(symbol); + } + if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(node)) { + var symbol = getSymbolInfo(node); + return symbol && getTypeOfSymbol(symbol); + } + if (isInRightSideOfImportOrExportAssignment(node)) { + var symbol = getSymbolInfo(node); + var declaredType = symbol && getDeclaredTypeOfSymbol(symbol); + return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol); + } + return unknownType; + } + function getTypeOfExpression(expr) { + if (isRightSideOfQualifiedNameOrPropertyAccess(expr)) { + expr = expr.parent; + } + return checkExpression(expr); + } + function getAugmentedPropertiesOfType(type) { + var type = getApparentType(type); + var propsByName = createSymbolTable(getPropertiesOfType(type)); + if (getSignaturesOfType(type, 0).length || getSignaturesOfType(type, 1).length) { + ts.forEach(getPropertiesOfType(globalFunctionType), function (p) { + if (!ts.hasProperty(propsByName, p.name)) { + propsByName[p.name] = p; + } + }); + } + return getNamedMembers(propsByName); + } + function getRootSymbols(symbol) { + if (symbol.flags & 268435456) { + var symbols = []; + var name = symbol.name; + ts.forEach(getSymbolLinks(symbol).unionType.types, function (t) { + symbols.push(getPropertyOfType(t, name)); + }); + return symbols; + } + else if (symbol.flags & 67108864) { + var target = getSymbolLinks(symbol).target; + if (target) { + return [target]; + } + } + return [symbol]; + } + function isExternalModuleSymbol(symbol) { + return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 220; + } + function isNodeDescendentOf(node, ancestor) { + while (node) { + if (node === ancestor) + return true; + node = node.parent; + } + return false; + } + function isUniqueLocalName(name, container) { + for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) { + if (node.locals && ts.hasProperty(node.locals, name)) { + if (node.locals[name].flags & (107455 | 1048576 | 8388608)) { + return false; + } + } + } + return true; + } + function getGeneratedNamesForSourceFile(sourceFile) { + var links = getNodeLinks(sourceFile); + var generatedNames = links.generatedNames; + if (!generatedNames) { + generatedNames = links.generatedNames = {}; + generateNames(sourceFile); + } + return generatedNames; + function generateNames(node) { + switch (node.kind) { + case 200: + generateNameForModuleOrEnum(node); + generateNames(node.body); + break; + case 199: + generateNameForModuleOrEnum(node); + break; + case 203: + generateNameForImportDeclaration(node); + break; + case 209: + generateNameForExportDeclaration(node); + break; + case 220: + case 201: + ts.forEach(node.statements, generateNames); + break; + } + } + function isExistingName(name) { + return ts.hasProperty(globals, name) || ts.hasProperty(sourceFile.identifiers, name) || ts.hasProperty(generatedNames, name); + } + function makeUniqueName(baseName) { + if (baseName.charCodeAt(0) !== 95) { + var baseName = "_" + baseName; + if (!isExistingName(baseName)) { + return generatedNames[baseName] = baseName; + } + } + if (baseName.charCodeAt(baseName.length - 1) !== 95) { + baseName += "_"; + } + var i = 1; + while (true) { + name = baseName + i; + if (!isExistingName(name)) { + return generatedNames[name] = name; + } + i++; + } + } + function assignGeneratedName(node, name) { + getNodeLinks(node).generatedName = ts.unescapeIdentifier(name); + } + function generateNameForModuleOrEnum(node) { + if (node.name.kind === 64) { + var name = node.name.text; + assignGeneratedName(node, 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)); + } + function generateNameForImportDeclaration(node) { + if (node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === 206) { + generateNameForImportOrExportDeclaration(node); + } + } + function generateNameForExportDeclaration(node) { + if (node.moduleSpecifier) { + generateNameForImportOrExportDeclaration(node); + } + } + } + function getGeneratedNameForNode(node) { + var links = getNodeLinks(node); + if (!links.generatedName) { + getGeneratedNamesForSourceFile(getSourceFile(node)); + } + return links.generatedName; + } + function getLocalNameOfContainer(container) { + return getGeneratedNameForNode(container); + } + function getLocalNameForImportDeclaration(node) { + return getGeneratedNameForNode(node); + } + function getImportNameSubstitution(symbol) { + var declaration = getDeclarationOfImportSymbol(symbol); + if (declaration && declaration.kind === 207) { + var moduleName = getGeneratedNameForNode(declaration.parent.parent.parent); + var propertyName = declaration.propertyName || declaration.name; + return moduleName + "." + ts.unescapeIdentifier(propertyName.text); + } + } + function getExportNameSubstitution(symbol, location) { + if (isExternalModuleSymbol(symbol.parent)) { + return "exports." + ts.unescapeIdentifier(symbol.name); + } + var node = location; + var containerSymbol = getParentOfSymbol(symbol); + while (node) { + if ((node.kind === 200 || node.kind === 199) && getSymbolOfNode(node) === containerSymbol) { + return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); + } + node = node.parent; + } + } + function getExpressionNameSubstitution(node) { + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol) { + if (symbol.parent) { + return getExportNameSubstitution(symbol, node.parent); + } + var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); + if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { + return getExportNameSubstitution(exportSymbol, node.parent); + } + if (symbol.flags & 8388608) { + return getImportNameSubstitution(symbol); + } + } + } + function getExportAssignmentName(node) { + var symbol = getExportAssignmentSymbol(getSymbolOfNode(node)); + return symbol && symbol !== unknownSymbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; + } + function isTopLevelValueImportEqualsWithEntityName(node) { + if (node.parent.kind !== 220 || !ts.isInternalModuleImportEqualsDeclaration(node)) { + return false; + } + return isImportResolvedToValue(getSymbolOfNode(node)); + } + function isImportResolvedToValue(symbol) { + var target = resolveImport(symbol); + return target !== unknownSymbol && target.flags & 107455 && !isConstEnumOrConstEnumOnlyModule(target); + } + function isConstEnumOrConstEnumOnlyModule(s) { + return isConstEnumSymbol(s) || s.constEnumOnlyModule; + } + function isReferencedImportDeclaration(node) { + if (isImportSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + if (getSymbolLinks(symbol).referenced) { + return true; + } + if (node.kind === 202 && node.flags & 1 && isImportResolvedToValue(symbol)) { + return true; + } + } + return ts.forEachChild(node, isReferencedImportDeclaration); + } + function isImplementationOfOverload(node) { + if (ts.nodeIsPresent(node.body)) { + var symbol = getSymbolOfNode(node); + var signaturesOfSymbol = getSignaturesOfSymbol(symbol); + return signaturesOfSymbol.length > 1 || + (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node); + } + return false; + } + function getNodeCheckFlags(node) { + return getNodeLinks(node).flags; + } + function getEnumMemberValue(node) { + computeEnumMemberValues(node.parent); + return getNodeLinks(node).enumMemberValue; + } + function getConstantValue(node) { + if (node.kind === 219) { + return getEnumMemberValue(node); + } + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol && (symbol.flags & 8)) { + var declaration = symbol.valueDeclaration; + var constantValue; + if (declaration.kind === 219) { + return getEnumMemberValue(declaration); + } + } + return undefined; + } + function writeTypeOfDeclaration(declaration, enclosingDeclaration, flags, writer) { + var symbol = getSymbolOfNode(declaration); + var type = symbol && !(symbol.flags & (2048 | 131072)) ? getTypeOfSymbol(symbol) : unknownType; + getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); + } + function writeReturnTypeOfSignatureDeclaration(signatureDeclaration, enclosingDeclaration, flags, writer) { + var signature = getSignatureFromDeclaration(signatureDeclaration); + getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags); + } + function isUnknownIdentifier(location, name) { + return !resolveName(location, name, 107455, undefined, undefined) && + !ts.hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), name); + } + function createResolver() { + return { + getGeneratedNameForNode: getGeneratedNameForNode, + getExpressionNameSubstitution: getExpressionNameSubstitution, + getExportAssignmentName: getExportAssignmentName, + isReferencedImportDeclaration: isReferencedImportDeclaration, + getNodeCheckFlags: getNodeCheckFlags, + isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName, + isDeclarationVisible: isDeclarationVisible, + isImplementationOfOverload: isImplementationOfOverload, + writeTypeOfDeclaration: writeTypeOfDeclaration, + writeReturnTypeOfSignatureDeclaration: writeReturnTypeOfSignatureDeclaration, + isSymbolAccessible: isSymbolAccessible, + isEntityNameVisible: isEntityNameVisible, + getConstantValue: getConstantValue, + isUnknownIdentifier: isUnknownIdentifier + }; + } + function initializeTypeChecker() { + ts.forEach(host.getSourceFiles(), function (file) { + ts.bindSourceFile(file); + }); + ts.forEach(host.getSourceFiles(), function (file) { + if (!ts.isExternalModule(file)) { + mergeSymbolTable(globals, file.locals); + } + }); + getSymbolLinks(undefinedSymbol).type = undefinedType; + getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments"); + getSymbolLinks(unknownSymbol).type = unknownType; + globals[undefinedSymbol.name] = undefinedSymbol; + globalArraySymbol = getGlobalTypeSymbol("Array"); + globalArrayType = getTypeOfGlobalSymbol(globalArraySymbol, 1); + globalObjectType = getGlobalType("Object"); + globalFunctionType = getGlobalType("Function"); + globalStringType = getGlobalType("String"); + globalNumberType = getGlobalType("Number"); + globalBooleanType = getGlobalType("Boolean"); + globalRegExpType = getGlobalType("RegExp"); + if (languageVersion >= 2) { + globalTemplateStringsArrayType = getGlobalType("TemplateStringsArray"); + globalESSymbolType = getGlobalType("Symbol"); + globalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol"); + } + else { + globalTemplateStringsArrayType = unknownType; + globalESSymbolType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined); + globalESSymbolConstructorSymbol = undefined; + } + anyArrayType = createArrayType(anyType); + } + function checkGrammarModifiers(node) { + switch (node.kind) { + case 134: + case 135: + case 133: + case 130: + case 129: + case 132: + case 131: + case 138: + case 196: + case 197: + case 200: + case 199: + case 175: + case 195: + case 198: + case 203: + case 202: + case 209: + case 208: + case 128: + break; + default: + return false; + } + if (!node.modifiers) { + return; + } + var lastStatic, lastPrivate, lastProtected, lastDeclare; + var flags = 0; + for (var i = 0, n = node.modifiers.length; i < n; i++) { + var modifier = node.modifiers[i]; + switch (modifier.kind) { + case 109: + case 108: + case 107: + var text; + if (modifier.kind === 109) { + text = "public"; + } + else if (modifier.kind === 108) { + text = "protected"; + lastProtected = modifier; + } + else { + text = "private"; + lastPrivate = modifier; + } + if (flags & 112) { + return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen); + } + else if (flags & 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); + } + else if (node.parent.kind === 201 || node.parent.kind === 220) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); + } + flags |= ts.modifierToFlag(modifier.kind); + break; + case 110: + if (flags & 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); + } + else if (node.parent.kind === 201 || node.parent.kind === 220) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); + } + else if (node.kind === 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); + } + flags |= 128; + lastStatic = modifier; + break; + case 77: + if (flags & 1) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export"); + } + else if (flags & 2) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); + } + else if (node.parent.kind === 196) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); + } + else if (node.kind === 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); + } + flags |= 1; + break; + case 115: + if (flags & 2) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); + } + else if (node.parent.kind === 196) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); + } + else if (node.kind === 128) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); + } + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 201) { + return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); + } + flags |= 2; + lastDeclare = modifier; + break; + } + } + if (node.kind === 133) { + if (flags & 128) { + return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); + } + else if (flags & 64) { + return grammarErrorOnNode(lastProtected, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected"); + } + else if (flags & 32) { + return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); + } + } + else if ((node.kind === 203 || node.kind === 202) && flags & 2) { + return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); + } + else if (node.kind === 197 && flags & 2) { + return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); + } + else if (node.kind === 128 && (flags & 112) && ts.isBindingPattern(node.name)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); + } + } + function checkGrammarForDisallowedTrailingComma(list) { + if (list && list.hasTrailingComma) { + var start = list.end - ",".length; + var end = list.end; + var sourceFile = ts.getSourceFileOfNode(list[0]); + return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Trailing_comma_not_allowed); + } + } + function checkGrammarTypeParameterList(node, typeParameters) { + if (checkGrammarForDisallowedTrailingComma(typeParameters)) { + return true; + } + if (typeParameters && typeParameters.length === 0) { + var start = typeParameters.pos - "<".length; + var sourceFile = ts.getSourceFileOfNode(node); + var end = ts.skipTrivia(sourceFile.text, typeParameters.end) + ">".length; + return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_parameter_list_cannot_be_empty); + } + } + function checkGrammarParameterList(parameters) { + if (checkGrammarForDisallowedTrailingComma(parameters)) { + return true; + } + var seenOptionalParameter = false; + var parameterCount = parameters.length; + for (var i = 0; i < parameterCount; i++) { + var parameter = parameters[i]; + if (parameter.dotDotDotToken) { + if (i !== (parameterCount - 1)) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_rest_parameter_cannot_be_optional); + } + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer); + } + } + else if (parameter.questionToken || parameter.initializer) { + seenOptionalParameter = true; + if (parameter.questionToken && parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.Parameter_cannot_have_question_mark_and_initializer); + } + } + else { + if (seenOptionalParameter) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter); + } + } + } + } + function checkGrammarFunctionLikeDeclaration(node) { + return checkGrammarModifiers(node) || checkGrammarTypeParameterList(node, node.typeParameters) || checkGrammarParameterList(node.parameters); + } + function checkGrammarIndexSignatureParameters(node) { + var parameter = node.parameters[0]; + if (node.parameters.length !== 1) { + if (parameter) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter); + } + else { + return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter); + } + } + if (parameter.dotDotDotToken) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter); + } + if (parameter.flags & 243) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark); + } + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_initializer); + } + if (!parameter.type) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); + } + if (parameter.type.kind !== 121 && parameter.type.kind !== 119) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); + } + if (!node.type) { + return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_a_type_annotation); + } + } + function checkGrammarForIndexSignatureModifier(node) { + if (node.flags & 243) { + grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_not_permitted_on_index_signature_members); + } + } + function checkGrammarIndexSignature(node) { + checkGrammarModifiers(node) || checkGrammarIndexSignatureParameters(node) || checkGrammarForIndexSignatureModifier(node); + } + function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) { + if (typeArguments && typeArguments.length === 0) { + var sourceFile = ts.getSourceFileOfNode(node); + var start = typeArguments.pos - "<".length; + var end = ts.skipTrivia(sourceFile.text, typeArguments.end) + ">".length; + return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty); + } + } + function checkGrammarTypeArguments(node, typeArguments) { + return checkGrammarForDisallowedTrailingComma(typeArguments) || + checkGrammarForAtLeastOneTypeArgument(node, typeArguments); + } + function checkGrammarForOmittedArgument(node, arguments) { + if (arguments) { + var sourceFile = ts.getSourceFileOfNode(node); + for (var i = 0, n = arguments.length; i < n; i++) { + var arg = arguments[i]; + if (arg.kind === 172) { + return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); + } + } + } + } + function checkGrammarArguments(node, arguments) { + return checkGrammarForDisallowedTrailingComma(arguments) || + checkGrammarForOmittedArgument(node, arguments); + } + function checkGrammarHeritageClause(node) { + var types = node.types; + if (checkGrammarForDisallowedTrailingComma(types)) { + return true; + } + if (types && types.length === 0) { + var listType = ts.tokenToString(node.token); + var sourceFile = ts.getSourceFileOfNode(node); + return grammarErrorAtPos(sourceFile, types.pos, 0, ts.Diagnostics._0_list_cannot_be_empty, listType); + } + } + function checkGrammarClassDeclarationHeritageClauses(node) { + var seenExtendsClause = false; + var seenImplementsClause = false; + if (!checkGrammarModifiers(node) && node.heritageClauses) { + for (var i = 0, n = node.heritageClauses.length; i < n; i++) { + ts.Debug.assert(i <= 2); + var heritageClause = node.heritageClauses[i]; + if (heritageClause.token === 78) { + if (seenExtendsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); + } + if (seenImplementsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_must_precede_implements_clause); + } + if (heritageClause.types.length > 1) { + return grammarErrorOnFirstToken(heritageClause.types[1], ts.Diagnostics.Classes_can_only_extend_a_single_class); + } + seenExtendsClause = true; + } + else { + ts.Debug.assert(heritageClause.token === 103); + if (seenImplementsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); + } + seenImplementsClause = true; + } + checkGrammarHeritageClause(heritageClause); + } + } + } + function checkGrammarInterfaceDeclaration(node) { + var seenExtendsClause = false; + if (node.heritageClauses) { + for (var i = 0, n = node.heritageClauses.length; i < n; i++) { + ts.Debug.assert(i <= 1); + var heritageClause = node.heritageClauses[i]; + if (heritageClause.token === 78) { + if (seenExtendsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); + } + seenExtendsClause = true; + } + else { + ts.Debug.assert(heritageClause.token === 103); + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); + } + checkGrammarHeritageClause(heritageClause); + } + } + return false; + } + function checkGrammarComputedPropertyName(node) { + if (node.kind !== 126) { + return false; + } + var computedPropertyName = node; + if (computedPropertyName.expression.kind === 167 && 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) { + return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_currently_supported); + } + } + function checkGrammarFunctionName(name) { + return checkGrammarEvalOrArgumentsInStrictMode(name, name); + } + function checkGrammarForInvalidQuestionMark(node, questionToken, message) { + if (questionToken) { + return grammarErrorOnNode(questionToken, message); + } + } + function checkGrammarObjectLiteralExpression(node) { + var seen = {}; + var Property = 1; + var GetAccessor = 2; + var SetAccesor = 4; + var GetOrSetAccessor = GetAccessor | SetAccesor; + var inStrictMode = (node.parserContextFlags & 1) !== 0; + for (var i = 0, n = node.properties.length; i < n; i++) { + var prop = node.properties[i]; + var name = prop.name; + if (prop.kind === 172 || + name.kind === 126) { + checkGrammarComputedPropertyName(name); + continue; + } + var currentKind; + if (prop.kind === 217 || prop.kind === 218) { + checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); + if (name.kind === 7) { + checkGrammarNumbericLiteral(name); + } + currentKind = Property; + } + else if (prop.kind === 132) { + currentKind = Property; + } + else if (prop.kind === 134) { + currentKind = GetAccessor; + } + else if (prop.kind === 135) { + currentKind = SetAccesor; + } + else { + ts.Debug.fail("Unexpected syntax kind:" + prop.kind); + } + if (!ts.hasProperty(seen, name.text)) { + seen[name.text] = currentKind; + } + else { + var existingKind = seen[name.text]; + if (currentKind === Property && existingKind === Property) { + if (inStrictMode) { + grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode); + } + } + else if ((currentKind & GetOrSetAccessor) && (existingKind & GetOrSetAccessor)) { + if (existingKind !== GetOrSetAccessor && currentKind !== existingKind) { + seen[name.text] = currentKind | existingKind; + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + } + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + } + } + } + } + function checkGrammarForInOrForOfStatement(forInOrOfStatement) { + if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { + return true; + } + if (forInOrOfStatement.initializer.kind === 194) { + var variableList = forInOrOfStatement.initializer; + if (!checkGrammarVariableDeclarationList(variableList)) { + if (variableList.declarations.length > 1) { + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 182 ? 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 === 182 ? 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); + } + } + } + return false; + } + function checkGrammarForOfStatement(forOfStatement) { + return grammarErrorOnFirstToken(forOfStatement, ts.Diagnostics.for_of_statements_are_not_currently_supported); + if (languageVersion < 2) { + return grammarErrorOnFirstToken(forOfStatement, ts.Diagnostics.for_of_statements_are_only_available_when_targeting_ECMAScript_6_or_higher); + } + return checkGrammarForInOrForOfStatement(forOfStatement); + } + function checkGrammarAccessor(accessor) { + var kind = accessor.kind; + if (languageVersion < 1) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher); + } + else if (ts.isInAmbientContext(accessor)) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_be_declared_in_an_ambient_context); + } + else if (accessor.body === undefined) { + return grammarErrorAtPos(ts.getSourceFileOfNode(accessor), accessor.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); + } + else if (accessor.typeParameters) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); + } + else if (kind === 134 && accessor.parameters.length) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); + } + else if (kind === 135) { + if (accessor.type) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); + } + else if (accessor.parameters.length !== 1) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter); + } + else { + var parameter = accessor.parameters[0]; + if (parameter.dotDotDotToken) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter); + } + else if (parameter.flags & 243) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); + } + else if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_set_accessor_cannot_have_an_optional_parameter); + } + else if (parameter.initializer) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer); + } + } + } + } + function checkGrammarForNonSymbolComputedProperty(node, message) { + if (node.kind === 126 && !ts.isWellKnownSymbolSyntactically(node.expression)) { + return grammarErrorOnNode(node, message); + } + } + function checkGrammarMethod(node) { + if (checkGrammarDisallowedModifiersInBlockOrObjectLiteralExpression(node) || + checkGrammarFunctionLikeDeclaration(node) || + checkGrammarForGenerator(node)) { + return true; + } + if (node.parent.kind === 152) { + if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { + return true; + } + else if (node.body === undefined) { + return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); + } + } + if (node.parent.kind === 196) { + if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { + return true; + } + if (ts.isInAmbientContext(node)) { + return checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol); + } + else if (!node.body) { + 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 === 197) { + 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 === 143) { + 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 181: + case 182: + case 183: + case 179: + case 180: + return true; + case 189: + return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); + } + return false; + } + function checkGrammarBreakOrContinueStatement(node) { + var current = node; + while (current) { + if (ts.isAnyFunction(current)) { + return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); + } + switch (current.kind) { + case 189: + if (node.label && current.label.text === node.label.text) { + var isMisplacedContinueLabel = node.kind === 184 && !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); + } + return false; + } + break; + case 188: + if (node.kind === 185 && !node.label) { + return false; + } + break; + default: + if (isIterationStatement(current, false) && !node.label) { + return false; + } + break; + } + current = current.parent; + } + if (node.label) { + var message = node.kind === 185 ? 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 === 185 ? 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); + } + } + function checkGrammarBindingElement(node) { + if (node.dotDotDotToken) { + var elements = node.parent.elements; + if (node !== elements[elements.length - 1]) { + return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_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 (ts.isInAmbientContext(node)) { + if (ts.isBindingPattern(node.name)) { + return grammarErrorOnNode(node, ts.Diagnostics.Destructuring_declarations_are_not_allowed_in_ambient_contexts); + } + if (node.initializer) { + return grammarErrorAtPos(ts.getSourceFileOfNode(node), node.initializer.pos - 1, 1, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts); + } + } + else { + if (!node.initializer) { + if (ts.isBindingPattern(node.name) && !ts.isBindingPattern(node.parent)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer); + } + if (ts.isConst(node)) { + return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_must_be_initialized); + } + } + } + var checkLetConstNames = languageVersion >= 2 && (ts.isLet(node) || ts.isConst(node)); + return (checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name)) || + checkGrammarEvalOrArgumentsInStrictMode(node, node.name); + } + function checkGrammarNameInLetOrConstDeclarations(name) { + if (name.kind === 64) { + if (name.text === "let") { + return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations); + } + } + else { + var elements = name.elements; + for (var i = 0; i < elements.length; ++i) { + checkGrammarNameInLetOrConstDeclarations(elements[i].name); + } + } + } + function checkGrammarVariableDeclarationList(declarationList) { + var declarations = declarationList.declarations; + if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) { + return true; + } + if (!declarationList.declarations.length) { + return grammarErrorAtPos(ts.getSourceFileOfNode(declarationList), declarations.pos, declarations.end - declarations.pos, ts.Diagnostics.Variable_declaration_list_cannot_be_empty); + } + if (languageVersion < 2) { + if (ts.isLet(declarationList)) { + return grammarErrorOnFirstToken(declarationList, ts.Diagnostics.let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher); + } + else if (ts.isConst(declarationList)) { + return grammarErrorOnFirstToken(declarationList, ts.Diagnostics.const_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher); + } + } + } + function allowLetAndConstDeclarations(parent) { + switch (parent.kind) { + case 178: + case 179: + case 180: + case 187: + case 181: + case 182: + case 183: + return false; + case 189: + return allowLetAndConstDeclarations(parent.parent); + } + return true; + } + function checkGrammarForDisallowedLetOrConstStatement(node) { + if (!allowLetAndConstDeclarations(node.parent)) { + if (ts.isLet(node.declarationList)) { + return grammarErrorOnNode(node, ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block); + } + else if (ts.isConst(node.declarationList)) { + return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block); + } + } + } + function isIntegerLiteral(expression) { + if (expression.kind === 165) { + var unaryExpression = expression; + if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { + expression = unaryExpression.operand; + } + } + if (expression.kind === 7) { + return /^[0-9]+([eE]\+?[0-9]+)?$/.test(expression.text); + } + return false; + } + function checkGrammarEnumDeclaration(enumDecl) { + var enumIsConst = (enumDecl.flags & 4096) !== 0; + var hasError = false; + if (!enumIsConst) { + var inConstantEnumMemberSection = true; + var inAmbientContext = ts.isInAmbientContext(enumDecl); + for (var i = 0, n = enumDecl.members.length; i < n; i++) { + var node = enumDecl.members[i]; + if (node.name.kind === 126) { + hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); + } + else if (inAmbientContext) { + if (node.initializer && !isIntegerLiteral(node.initializer)) { + hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers) || hasError; + } + } + else if (node.initializer) { + inConstantEnumMemberSection = isIntegerLiteral(node.initializer); + } + else if (!inConstantEnumMemberSection) { + hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Enum_member_must_have_initializer) || hasError; + } + } + } + return hasError; + } + function hasParseDiagnostics(sourceFile) { + return sourceFile.parseDiagnostics.length > 0; + } + function scanToken(scanner, pos) { + scanner.setTextPos(pos); + scanner.scan(); + var start = scanner.getTokenPos(); + return start; + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var scanner = ts.createScanner(languageVersion, true, sourceFile.text); + var start = scanToken(scanner, node.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, start, scanner.getTextPos() - start, message, arg0, arg1, arg2)); + return true; + } + } + function grammarErrorAtPos(sourceFile, start, length, message, arg0, arg1, arg2) { + if (!hasParseDiagnostics(sourceFile)) { + diagnostics.add(ts.createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2)); + return true; + } + } + function grammarErrorOnNode(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getErrorSpanForNode(node); + var start = span.end > span.pos ? ts.skipTrivia(sourceFile.text, span.pos) : span.pos; + diagnostics.add(ts.createFileDiagnostic(sourceFile, start, span.end - start, message, arg0, arg1, arg2)); + return true; + } + } + function checkGrammarEvalOrArgumentsInStrictMode(contextNode, identifier) { + if (contextNode && (contextNode.parserContextFlags & 1) && ts.isEvalOrArgumentsIdentifier(identifier)) { + var name = ts.declarationNameToString(identifier); + return grammarErrorOnNode(identifier, ts.Diagnostics.Invalid_use_of_0_in_strict_mode, name); + } + } + 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); + } + } + function checkGrammarConstructorTypeAnnotation(node) { + if (node.type) { + return grammarErrorOnNode(node.type, ts.Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration); + } + } + function checkGrammarProperty(node) { + if (node.parent.kind === 196) { + 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 === 197) { + 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 === 143) { + if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { + return true; + } + } + if (ts.isInAmbientContext(node) && node.initializer) { + return grammarErrorOnFirstToken(node.initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts); + } + } + function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { + if (node.kind === 197 || + node.kind === 203 || + node.kind === 202 || + node.kind === 209 || + node.kind === 208 || + (node.flags & 2)) { + return false; + } + return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file); + } + function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { + for (var i = 0, n = file.statements.length; i < n; i++) { + var decl = file.statements[i]; + if (ts.isDeclaration(decl) || decl.kind === 175) { + if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { + return true; + } + } + } + } + function checkGrammarSourceFile(node) { + return ts.isInAmbientContext(node) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node); + } + function checkGrammarStatementInAmbientContext(node) { + if (ts.isInAmbientContext(node)) { + if (isAccessor(node.parent.kind)) { + return getNodeLinks(node).hasReportedStatementInAmbientContext = true; + } + var links = getNodeLinks(node); + if (!links.hasReportedStatementInAmbientContext && ts.isAnyFunction(node.parent)) { + return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); + } + if (node.parent.kind === 174 || node.parent.kind === 201 || node.parent.kind === 220) { + var links = getNodeLinks(node.parent); + if (!links.hasReportedStatementInAmbientContext) { + return links.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); + } + } + else { + } + } + } + function checkGrammarNumbericLiteral(node) { + if (node.flags & 8192) { + 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); + } + } + } + function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var scanner = ts.createScanner(languageVersion, true, sourceFile.text); + scanToken(scanner, node.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, scanner.getTextPos(), 0, message, arg0, arg1, arg2)); + return true; + } + } + initializeTypeChecker(); + return checker; + } + ts.createTypeChecker = createTypeChecker; +})(ts || (ts = {})); +var ts; +(function (ts) { + var indentStrings = ["", " "]; + function getIndentString(level) { + if (indentStrings[level] === undefined) { + indentStrings[level] = getIndentString(level - 1) + indentStrings[1]; + } + return indentStrings[level]; + } + ts.getIndentString = getIndentString; + function getIndentSize() { + return indentStrings[1].length; + } + function shouldEmitToOwnFile(sourceFile, compilerOptions) { + if (!ts.isDeclarationFile(sourceFile)) { + if ((ts.isExternalModule(sourceFile) || !compilerOptions.out) && !ts.fileExtensionIs(sourceFile.fileName, ".js")) { + return true; + } + return false; + } + return false; + } + ts.shouldEmitToOwnFile = shouldEmitToOwnFile; + function isExternalModuleOrDeclarationFile(sourceFile) { + return ts.isExternalModule(sourceFile) || ts.isDeclarationFile(sourceFile); + } + ts.isExternalModuleOrDeclarationFile = isExternalModuleOrDeclarationFile; + function createTextWriter(newLine) { + var output = ""; + var indent = 0; + var lineStart = true; + var lineCount = 0; + var linePos = 0; + function write(s) { + if (s && s.length) { + if (lineStart) { + output += getIndentString(indent); + lineStart = false; + } + output += s; + } + } + function rawWrite(s) { + if (s !== undefined) { + if (lineStart) { + lineStart = false; + } + output += s; + } + } + function writeLiteral(s) { + if (s && s.length) { + write(s); + var lineStartsOfS = ts.computeLineStarts(s); + if (lineStartsOfS.length > 1) { + lineCount = lineCount + lineStartsOfS.length - 1; + linePos = output.length - s.length + lineStartsOfS[lineStartsOfS.length - 1]; + } + } + } + function writeLine() { + if (!lineStart) { + output += newLine; + lineCount++; + linePos = output.length; + lineStart = true; + } + } + function writeTextOfNode(sourceFile, node) { + write(ts.getSourceTextOfNodeFromSourceFile(sourceFile, node)); + } + return { + write: write, + rawWrite: rawWrite, + writeTextOfNode: writeTextOfNode, + writeLiteral: writeLiteral, + writeLine: writeLine, + increaseIndent: function () { return indent++; }, + decreaseIndent: function () { return indent--; }, + getIndent: function () { return indent; }, + getTextPos: function () { return output.length; }, + getLine: function () { return lineCount + 1; }, + getColumn: function () { return lineStart ? indent * getIndentSize() + 1 : output.length - linePos + 1; }, + getText: function () { return output; } + }; + } + function getLineOfLocalPosition(currentSourceFile, pos) { + return ts.getLineAndCharacterOfPosition(currentSourceFile, pos).line; + } + function emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments) { + if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos && + getLineOfLocalPosition(currentSourceFile, node.pos) !== getLineOfLocalPosition(currentSourceFile, leadingComments[0].pos)) { + writer.writeLine(); + } + } + function emitComments(currentSourceFile, writer, comments, trailingSeparator, newLine, writeComment) { + var emitLeadingSpace = !trailingSeparator; + ts.forEach(comments, function (comment) { + if (emitLeadingSpace) { + writer.write(" "); + emitLeadingSpace = false; + } + writeComment(currentSourceFile, writer, comment, newLine); + if (comment.hasTrailingNewLine) { + writer.writeLine(); + } + else if (trailingSeparator) { + writer.write(" "); + } + else { + emitLeadingSpace = true; + } + }); + } + function writeCommentRange(currentSourceFile, writer, comment, newLine) { + if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42) { + var firstCommentLineAndCharacter = ts.getLineAndCharacterOfPosition(currentSourceFile, comment.pos); + var lineCount = ts.getLineStarts(currentSourceFile).length; + var firstCommentLineIndent; + for (var pos = comment.pos, currentLine = firstCommentLineAndCharacter.line; pos < comment.end; currentLine++) { + var nextLineStart = (currentLine + 1) === lineCount ? currentSourceFile.text.length + 1 : ts.getStartPositionOfLine(currentLine + 1, currentSourceFile); + if (pos !== comment.pos) { + if (firstCommentLineIndent === undefined) { + firstCommentLineIndent = calculateIndent(ts.getStartPositionOfLine(firstCommentLineAndCharacter.line, currentSourceFile), comment.pos); + } + var currentWriterIndentSpacing = writer.getIndent() * getIndentSize(); + var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(pos, nextLineStart); + if (spacesToEmit > 0) { + var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize(); + var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize()); + writer.rawWrite(indentSizeSpaceString); + while (numberOfSingleSpacesToEmit) { + writer.rawWrite(" "); + numberOfSingleSpacesToEmit--; + } + } + else { + writer.rawWrite(""); + } + } + writeTrimmedCurrentLine(pos, nextLineStart); + pos = nextLineStart; + } + } + else { + writer.write(currentSourceFile.text.substring(comment.pos, comment.end)); + } + function writeTrimmedCurrentLine(pos, nextLineStart) { + var end = Math.min(comment.end, nextLineStart - 1); + var currentLineText = currentSourceFile.text.substring(pos, end).replace(/^\s+|\s+$/g, ''); + if (currentLineText) { + writer.write(currentLineText); + if (end !== comment.end) { + writer.writeLine(); + } + } + else { + writer.writeLiteral(newLine); + } + } + function calculateIndent(pos, end) { + var currentLineIndent = 0; + for (; pos < end && ts.isWhiteSpace(currentSourceFile.text.charCodeAt(pos)); pos++) { + if (currentSourceFile.text.charCodeAt(pos) === 9) { + currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize()); + } + else { + currentLineIndent++; + } + } + return currentLineIndent; + } + } + function getFirstConstructorWithBody(node) { + return ts.forEach(node.members, function (member) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { + return member; + } + }); + } + function getAllAccessorDeclarations(declarations, accessor) { + var firstAccessor; + var getAccessor; + var setAccessor; + if (ts.hasDynamicName(accessor)) { + firstAccessor = accessor; + if (accessor.kind === 134) { + getAccessor = accessor; + } + else if (accessor.kind === 135) { + setAccessor = accessor; + } + else { + ts.Debug.fail("Accessor has wrong kind"); + } + } + else { + ts.forEach(declarations, function (member) { + if ((member.kind === 134 || member.kind === 135) && (member.flags & 128) === (accessor.flags & 128)) { + var memberName = ts.getPropertyNameForPropertyNameNode(member.name); + var accessorName = ts.getPropertyNameForPropertyNameNode(accessor.name); + if (memberName === accessorName) { + if (!firstAccessor) { + firstAccessor = member; + } + if (member.kind === 134 && !getAccessor) { + getAccessor = member; + } + if (member.kind === 135 && !setAccessor) { + setAccessor = member; + } + } + } + }); + } + return { + firstAccessor: firstAccessor, + getAccessor: getAccessor, + setAccessor: setAccessor + }; + } + function getSourceFilePathInNewDir(sourceFile, host, newDirPath) { + var sourceFilePath = ts.getNormalizedAbsolutePath(sourceFile.fileName, host.getCurrentDirectory()); + sourceFilePath = sourceFilePath.replace(host.getCommonSourceDirectory(), ""); + return ts.combinePaths(newDirPath, sourceFilePath); + } + function getOwnEmitOutputFilePath(sourceFile, host, extension) { + var compilerOptions = host.getCompilerOptions(); + if (compilerOptions.outDir) { + var emitOutputFilePathWithoutExtension = ts.removeFileExtension(getSourceFilePathInNewDir(sourceFile, host, compilerOptions.outDir)); + } + else { + var emitOutputFilePathWithoutExtension = ts.removeFileExtension(sourceFile.fileName); + } + return emitOutputFilePathWithoutExtension + extension; + } + function writeFile(host, diagnostics, fileName, data, writeByteOrderMark) { + host.writeFile(fileName, data, writeByteOrderMark, function (hostErrorMessage) { + diagnostics.push(ts.createCompilerDiagnostic(ts.Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage)); + }); + } + function emitDeclarations(host, resolver, diagnostics, jsFilePath, root) { + var newLine = host.getNewLine(); + var compilerOptions = host.getCompilerOptions(); + var languageVersion = compilerOptions.target || 0; + var write; + var writeLine; + var increaseIndent; + var decreaseIndent; + var writeTextOfNode; + var writer = createAndSetNewTextWriterWithSymbolWriter(); + var enclosingDeclaration; + var currentSourceFile; + var reportedDeclarationError = false; + var emitJsDocComments = compilerOptions.removeComments ? function (declaration) { } : writeJsDocComments; + var emit = compilerOptions.stripInternal ? stripInternal : emitNode; + var aliasDeclarationEmitInfo = []; + var referencePathsOutput = ""; + if (root) { + if (!compilerOptions.noResolve) { + var addedGlobalFileReference = false; + ts.forEach(root.referencedFiles, function (fileReference) { + var referencedFile = ts.tryResolveScriptReference(host, root, fileReference); + if (referencedFile && ((referencedFile.flags & 1024) || + shouldEmitToOwnFile(referencedFile, compilerOptions) || + !addedGlobalFileReference)) { + writeReferencePath(referencedFile); + if (!isExternalModuleOrDeclarationFile(referencedFile)) { + addedGlobalFileReference = true; + } + } + }); + } + emitSourceFile(root); + } + else { + var emittedReferencedFiles = []; + ts.forEach(host.getSourceFiles(), function (sourceFile) { + if (!isExternalModuleOrDeclarationFile(sourceFile)) { + if (!compilerOptions.noResolve) { + ts.forEach(sourceFile.referencedFiles, function (fileReference) { + var referencedFile = ts.tryResolveScriptReference(host, sourceFile, fileReference); + if (referencedFile && (isExternalModuleOrDeclarationFile(referencedFile) && + !ts.contains(emittedReferencedFiles, referencedFile))) { + writeReferencePath(referencedFile); + emittedReferencedFiles.push(referencedFile); + } + }); + } + emitSourceFile(sourceFile); + } + }); + } + return { + reportedDeclarationError: reportedDeclarationError, + aliasDeclarationEmitInfo: aliasDeclarationEmitInfo, + synchronousDeclarationOutput: writer.getText(), + referencePathsOutput: referencePathsOutput + }; + function hasInternalAnnotation(range) { + var text = currentSourceFile.text; + var comment = text.substring(range.pos, range.end); + return comment.indexOf("@internal") >= 0; + } + function stripInternal(node) { + if (node) { + var leadingCommentRanges = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos); + if (ts.forEach(leadingCommentRanges, hasInternalAnnotation)) { + return; + } + emitNode(node); + } + } + function createAndSetNewTextWriterWithSymbolWriter() { + var writer = createTextWriter(newLine); + writer.trackSymbol = trackSymbol; + writer.writeKeyword = writer.write; + writer.writeOperator = writer.write; + writer.writePunctuation = writer.write; + writer.writeSpace = writer.write; + writer.writeStringLiteral = writer.writeLiteral; + writer.writeParameter = writer.write; + writer.writeSymbol = writer.write; + setWriter(writer); + return writer; + } + function setWriter(newWriter) { + writer = newWriter; + write = newWriter.write; + writeTextOfNode = newWriter.writeTextOfNode; + writeLine = newWriter.writeLine; + increaseIndent = newWriter.increaseIndent; + decreaseIndent = newWriter.decreaseIndent; + } + function writeAsychronousImportEqualsDeclarations(importEqualsDeclarations) { + var oldWriter = writer; + ts.forEach(importEqualsDeclarations, function (aliasToWrite) { + var aliasEmitInfo = ts.forEach(aliasDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined; }); + if (aliasEmitInfo) { + createAndSetNewTextWriterWithSymbolWriter(); + for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) { + increaseIndent(); + } + writeImportEqualsDeclaration(aliasToWrite); + aliasEmitInfo.asynchronousOutput = writer.getText(); + } + }); + setWriter(oldWriter); + } + function handleSymbolAccessibilityError(symbolAccesibilityResult) { + if (symbolAccesibilityResult.accessibility === 0) { + if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) { + writeAsychronousImportEqualsDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); + } + } + else { + reportedDeclarationError = true; + var errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult); + if (errorInfo) { + if (errorInfo.typeName) { + diagnostics.push(ts.createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, errorInfo.typeName), symbolAccesibilityResult.errorSymbolName, symbolAccesibilityResult.errorModuleName)); + } + else { + diagnostics.push(ts.createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, symbolAccesibilityResult.errorSymbolName, symbolAccesibilityResult.errorModuleName)); + } + } + } + } + function trackSymbol(symbol, enclosingDeclaration, meaning) { + handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning)); + } + function writeTypeOfDeclaration(declaration, type, getSymbolAccessibilityDiagnostic) { + writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic; + write(": "); + if (type) { + emitType(type); + } + else { + resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, 2, writer); + } + } + function writeReturnTypeAtSignature(signature, getSymbolAccessibilityDiagnostic) { + writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic; + write(": "); + if (signature.type) { + emitType(signature.type); + } + else { + resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, 2, writer); + } + } + function emitLines(nodes) { + for (var i = 0, n = nodes.length; i < n; i++) { + emit(nodes[i]); + } + } + function emitSeparatedList(nodes, separator, eachNodeEmitFn) { + var currentWriterPos = writer.getTextPos(); + for (var i = 0, n = nodes.length; i < n; i++) { + if (currentWriterPos !== writer.getTextPos()) { + write(separator); + } + currentWriterPos = writer.getTextPos(); + eachNodeEmitFn(nodes[i]); + } + } + function emitCommaList(nodes, eachNodeEmitFn) { + emitSeparatedList(nodes, ", ", eachNodeEmitFn); + } + function writeJsDocComments(declaration) { + if (declaration) { + var jsDocComments = ts.getJsDocComments(declaration, currentSourceFile); + emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments); + emitComments(currentSourceFile, writer, jsDocComments, true, newLine, writeCommentRange); + } + } + function emitTypeWithNewGetSymbolAccessibilityDiagnostic(type, getSymbolAccessibilityDiagnostic) { + writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic; + emitType(type); + } + function emitType(type) { + switch (type.kind) { + case 112: + case 121: + case 119: + case 113: + case 122: + case 98: + case 8: + return writeTextOfNode(currentSourceFile, type); + case 139: + return emitTypeReference(type); + case 142: + return emitTypeQuery(type); + case 144: + return emitArrayType(type); + case 145: + return emitTupleType(type); + case 146: + return emitUnionType(type); + case 147: + return emitParenType(type); + case 140: + case 141: + return emitSignatureDeclarationWithJsDocComments(type); + case 143: + return emitTypeLiteral(type); + case 64: + return emitEntityName(type); + case 125: + return emitEntityName(type); + default: + ts.Debug.fail("Unknown type annotation: " + type.kind); + } + function emitEntityName(entityName) { + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 202 ? entityName.parent : enclosingDeclaration); + handleSymbolAccessibilityError(visibilityResult); + writeEntityName(entityName); + function writeEntityName(entityName) { + if (entityName.kind === 64) { + writeTextOfNode(currentSourceFile, entityName); + } + else { + var qualifiedName = entityName; + writeEntityName(qualifiedName.left); + write("."); + writeTextOfNode(currentSourceFile, qualifiedName.right); + } + } + } + function emitTypeReference(type) { + emitEntityName(type.typeName); + if (type.typeArguments) { + write("<"); + emitCommaList(type.typeArguments, emitType); + write(">"); + } + } + function emitTypeQuery(type) { + write("typeof "); + emitEntityName(type.exprName); + } + function emitArrayType(type) { + emitType(type.elementType); + write("[]"); + } + function emitTupleType(type) { + write("["); + emitCommaList(type.elementTypes, emitType); + write("]"); + } + function emitUnionType(type) { + emitSeparatedList(type.types, " | ", emitType); + } + function emitParenType(type) { + write("("); + emitType(type.type); + write(")"); + } + function emitTypeLiteral(type) { + write("{"); + if (type.members.length) { + writeLine(); + increaseIndent(); + emitLines(type.members); + decreaseIndent(); + } + write("}"); + } + } + function emitSourceFile(node) { + currentSourceFile = node; + enclosingDeclaration = node; + emitLines(node.statements); + } + function emitExportAssignment(node) { + write("export = "); + writeTextOfNode(currentSourceFile, node.exportName); + write(";"); + writeLine(); + } + function emitModuleElementDeclarationFlags(node) { + if (node.parent === currentSourceFile) { + if (node.flags & 1) { + write("export "); + } + if (node.kind !== 197) { + write("declare "); + } + } + } + function emitClassMemberDeclarationFlags(node) { + if (node.flags & 32) { + write("private "); + } + else if (node.flags & 64) { + write("protected "); + } + if (node.flags & 128) { + write("static "); + } + } + function emitImportEqualsDeclaration(node) { + var nodeEmitInfo = { + declaration: node, + outputPos: writer.getTextPos(), + indent: writer.getIndent(), + hasWritten: resolver.isDeclarationVisible(node) + }; + aliasDeclarationEmitInfo.push(nodeEmitInfo); + if (nodeEmitInfo.hasWritten) { + writeImportEqualsDeclaration(node); + } + } + function writeImportEqualsDeclaration(node) { + emitJsDocComments(node); + if (node.flags & 1) { + write("export "); + } + write("import "); + writeTextOfNode(currentSourceFile, node.name); + write(" = "); + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.moduleReference, getImportEntityNameVisibilityError); + write(";"); + } + else { + write("require("); + writeTextOfNode(currentSourceFile, ts.getExternalModuleImportEqualsDeclarationExpression(node)); + write(");"); + } + writer.writeLine(); + function getImportEntityNameVisibilityError(symbolAccesibilityResult) { + return { + diagnosticMessage: ts.Diagnostics.Import_declaration_0_is_using_private_name_1, + errorNode: node, + typeName: node.name + }; + } + } + function emitModuleDeclaration(node) { + if (resolver.isDeclarationVisible(node)) { + emitJsDocComments(node); + emitModuleElementDeclarationFlags(node); + write("module "); + writeTextOfNode(currentSourceFile, node.name); + while (node.body.kind !== 201) { + node = node.body; + write("."); + writeTextOfNode(currentSourceFile, node.name); + } + var prevEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = node; + write(" {"); + writeLine(); + increaseIndent(); + emitLines(node.body.statements); + decreaseIndent(); + write("}"); + writeLine(); + enclosingDeclaration = prevEnclosingDeclaration; + } + } + function emitTypeAliasDeclaration(node) { + if (resolver.isDeclarationVisible(node)) { + emitJsDocComments(node); + emitModuleElementDeclarationFlags(node); + write("type "); + writeTextOfNode(currentSourceFile, node.name); + write(" = "); + emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.type, getTypeAliasDeclarationVisibilityError); + write(";"); + writeLine(); + } + function getTypeAliasDeclarationVisibilityError(symbolAccesibilityResult) { + return { + diagnosticMessage: ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, + errorNode: node.type, + typeName: node.name + }; + } + } + function emitEnumDeclaration(node) { + if (resolver.isDeclarationVisible(node)) { + emitJsDocComments(node); + emitModuleElementDeclarationFlags(node); + if (ts.isConst(node)) { + write("const "); + } + write("enum "); + writeTextOfNode(currentSourceFile, node.name); + write(" {"); + writeLine(); + increaseIndent(); + emitLines(node.members); + decreaseIndent(); + write("}"); + writeLine(); + } + } + function emitEnumMemberDeclaration(node) { + emitJsDocComments(node); + writeTextOfNode(currentSourceFile, node.name); + var enumMemberValue = resolver.getConstantValue(node); + if (enumMemberValue !== undefined) { + write(" = "); + write(enumMemberValue.toString()); + } + write(","); + writeLine(); + } + function isPrivateMethodTypeParameter(node) { + return node.parent.kind === 132 && (node.parent.flags & 32); + } + function emitTypeParameters(typeParameters) { + function emitTypeParameter(node) { + increaseIndent(); + emitJsDocComments(node); + decreaseIndent(); + writeTextOfNode(currentSourceFile, node.name); + if (node.constraint && !isPrivateMethodTypeParameter(node)) { + write(" extends "); + if (node.parent.kind === 140 || + node.parent.kind === 141 || + (node.parent.parent && node.parent.parent.kind === 143)) { + ts.Debug.assert(node.parent.kind === 132 || + node.parent.kind === 131 || + node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.kind === 136 || + node.parent.kind === 137); + emitType(node.constraint); + } + else { + emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.constraint, getTypeParameterConstraintVisibilityError); + } + } + function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { + var diagnosticMessage; + switch (node.parent.kind) { + case 196: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; + break; + case 197: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; + break; + case 137: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 136: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 132: + case 131: + 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 === 196) { + 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 195: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; + break; + default: + ts.Debug.fail("This is unknown parent for type parameter: " + node.parent.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + }; + } + } + if (typeParameters) { + write("<"); + emitCommaList(typeParameters, emitTypeParameter); + write(">"); + } + } + function emitHeritageClause(typeReferences, isImplementsList) { + if (typeReferences) { + write(isImplementsList ? " implements " : " extends "); + emitCommaList(typeReferences, emitTypeOfTypeReference); + } + function emitTypeOfTypeReference(node) { + emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError); + function getHeritageClauseVisibilityError(symbolAccesibilityResult) { + var diagnosticMessage; + if (node.parent.parent.kind === 196) { + 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; + } + else { + diagnosticMessage = ts.Diagnostics.Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1; + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.parent.parent.name + }; + } + } + } + function emitClassDeclaration(node) { + function emitParameterProperties(constructorDeclaration) { + if (constructorDeclaration) { + ts.forEach(constructorDeclaration.parameters, function (param) { + if (param.flags & 112) { + emitPropertyDeclaration(param); + } + }); + } + } + if (resolver.isDeclarationVisible(node)) { + emitJsDocComments(node); + emitModuleElementDeclarationFlags(node); + write("class "); + writeTextOfNode(currentSourceFile, node.name); + var prevEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = node; + emitTypeParameters(node.typeParameters); + var baseTypeNode = ts.getClassBaseTypeNode(node); + if (baseTypeNode) { + emitHeritageClause([baseTypeNode], false); + } + emitHeritageClause(ts.getClassImplementedTypeNodes(node), true); + write(" {"); + writeLine(); + increaseIndent(); + emitParameterProperties(getFirstConstructorWithBody(node)); + emitLines(node.members); + decreaseIndent(); + write("}"); + writeLine(); + enclosingDeclaration = prevEnclosingDeclaration; + } + } + function emitInterfaceDeclaration(node) { + if (resolver.isDeclarationVisible(node)) { + emitJsDocComments(node); + emitModuleElementDeclarationFlags(node); + write("interface "); + writeTextOfNode(currentSourceFile, node.name); + var prevEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = node; + emitTypeParameters(node.typeParameters); + emitHeritageClause(ts.getInterfaceBaseTypeNodes(node), false); + write(" {"); + writeLine(); + increaseIndent(); + emitLines(node.members); + decreaseIndent(); + write("}"); + writeLine(); + enclosingDeclaration = prevEnclosingDeclaration; + } + } + function emitPropertyDeclaration(node) { + if (ts.hasDynamicName(node)) { + return; + } + emitJsDocComments(node); + emitClassMemberDeclarationFlags(node); + emitVariableDeclaration(node); + write(";"); + writeLine(); + } + function emitVariableDeclaration(node) { + if (node.kind !== 193 || resolver.isDeclarationVisible(node)) { + writeTextOfNode(currentSourceFile, node.name); + if ((node.kind === 130 || node.kind === 129) && ts.hasQuestionToken(node)) { + write("?"); + } + if ((node.kind === 130 || node.kind === 129) && node.parent.kind === 143) { + emitTypeOfVariableDeclarationFromTypeLiteral(node); + } + else if (!(node.flags & 32)) { + writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError); + } + } + function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult) { + var diagnosticMessage; + if (node.kind === 193) { + diagnosticMessage = 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 === 130 || node.kind === 129) { + if (node.flags & 128) { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 196) { + diagnosticMessage = 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 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + } + function emitTypeOfVariableDeclarationFromTypeLiteral(node) { + if (node.type) { + write(": "); + emitType(node.type); + } + } + function emitVariableStatement(node) { + var hasDeclarationWithEmit = ts.forEach(node.declarationList.declarations, function (varDeclaration) { return resolver.isDeclarationVisible(varDeclaration); }); + if (hasDeclarationWithEmit) { + emitJsDocComments(node); + emitModuleElementDeclarationFlags(node); + if (ts.isLet(node.declarationList)) { + write("let "); + } + else if (ts.isConst(node.declarationList)) { + write("const "); + } + else { + write("var "); + } + emitCommaList(node.declarationList.declarations, emitVariableDeclaration); + write(";"); + writeLine(); + } + } + function emitAccessorDeclaration(node) { + if (ts.hasDynamicName(node)) { + return; + } + var accessors = getAllAccessorDeclarations(node.parent.members, node); + if (node === accessors.firstAccessor) { + emitJsDocComments(accessors.getAccessor); + emitJsDocComments(accessors.setAccessor); + emitClassMemberDeclarationFlags(node); + writeTextOfNode(currentSourceFile, node.name); + if (!(node.flags & 32)) { + var accessorWithTypeAnnotation = node; + var type = getTypeAnnotationFromAccessor(node); + if (!type) { + var anotherAccessor = node.kind === 134 ? accessors.setAccessor : accessors.getAccessor; + type = getTypeAnnotationFromAccessor(anotherAccessor); + if (type) { + accessorWithTypeAnnotation = anotherAccessor; + } + } + writeTypeOfDeclaration(node, type, getAccessorDeclarationTypeVisibilityError); + } + write(";"); + writeLine(); + } + function getTypeAnnotationFromAccessor(accessor) { + if (accessor) { + return accessor.kind === 134 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; + } + } + function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { + var diagnosticMessage; + if (accessorWithTypeAnnotation.kind === 135) { + 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 : ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1; + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: accessorWithTypeAnnotation.parameters[0], + typeName: accessorWithTypeAnnotation.name + }; + } + else { + if (accessorWithTypeAnnotation.flags & 128) { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0; + } + else { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0; + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: accessorWithTypeAnnotation.name, + typeName: undefined + }; + } + } + } + function emitFunctionDeclaration(node) { + if (ts.hasDynamicName(node)) { + return; + } + if ((node.kind !== 195 || resolver.isDeclarationVisible(node)) && + !resolver.isImplementationOfOverload(node)) { + emitJsDocComments(node); + if (node.kind === 195) { + emitModuleElementDeclarationFlags(node); + } + else if (node.kind === 132) { + emitClassMemberDeclarationFlags(node); + } + if (node.kind === 195) { + write("function "); + writeTextOfNode(currentSourceFile, node.name); + } + else if (node.kind === 133) { + write("constructor"); + } + else { + writeTextOfNode(currentSourceFile, node.name); + if (ts.hasQuestionToken(node)) { + write("?"); + } + } + emitSignatureDeclaration(node); + } + } + function emitSignatureDeclarationWithJsDocComments(node) { + emitJsDocComments(node); + emitSignatureDeclaration(node); + } + function emitSignatureDeclaration(node) { + if (node.kind === 137 || node.kind === 141) { + write("new "); + } + emitTypeParameters(node.typeParameters); + if (node.kind === 138) { + write("["); + } + else { + write("("); + } + var prevEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = node; + emitCommaList(node.parameters, emitParameterDeclaration); + if (node.kind === 138) { + write("]"); + } + else { + write(")"); + } + var isFunctionTypeOrConstructorType = node.kind === 140 || node.kind === 141; + if (isFunctionTypeOrConstructorType || node.parent.kind === 143) { + if (node.type) { + write(isFunctionTypeOrConstructorType ? " => " : ": "); + emitType(node.type); + } + } + else if (node.kind !== 133 && !(node.flags & 32)) { + writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); + } + enclosingDeclaration = prevEnclosingDeclaration; + if (!isFunctionTypeOrConstructorType) { + write(";"); + writeLine(); + } + function getReturnTypeVisibilityError(symbolAccesibilityResult) { + var diagnosticMessage; + switch (node.kind) { + case 137: + 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 136: + 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 138: + 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 132: + case 131: + if (node.flags & 128) { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : 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 === 196) { + 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 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; + } + else { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; + } + break; + case 195: + 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 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; + break; + default: + ts.Debug.fail("This is unknown kind for signature: " + node.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node.name || node + }; + } + } + function emitParameterDeclaration(node) { + increaseIndent(); + emitJsDocComments(node); + if (node.dotDotDotToken) { + write("..."); + } + if (ts.isBindingPattern(node.name)) { + write("_" + ts.indexOf(node.parent.parameters, node)); + } + else { + writeTextOfNode(currentSourceFile, node.name); + } + if (node.initializer || ts.hasQuestionToken(node)) { + write("?"); + } + decreaseIndent(); + if (node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.parent.kind === 143) { + emitTypeOfVariableDeclarationFromTypeLiteral(node); + } + else if (!(node.parent.flags & 32)) { + writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError); + } + function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) { + var diagnosticMessage; + switch (node.parent.kind) { + case 133: + diagnosticMessage = 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; + break; + case 137: + diagnosticMessage = 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; + break; + case 136: + diagnosticMessage = 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; + break; + case 132: + case 131: + if (node.parent.flags & 128) { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 196) { + diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccesibilityResult.errorModuleName ? 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; + } + break; + case 195: + diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; + break; + default: + ts.Debug.fail("This is unknown parent for parameter: " + node.parent.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + }; + } + } + function emitNode(node) { + switch (node.kind) { + case 133: + case 195: + case 132: + case 131: + return emitFunctionDeclaration(node); + case 137: + case 136: + case 138: + return emitSignatureDeclarationWithJsDocComments(node); + case 134: + case 135: + return emitAccessorDeclaration(node); + case 175: + return emitVariableStatement(node); + case 130: + case 129: + return emitPropertyDeclaration(node); + case 197: + return emitInterfaceDeclaration(node); + case 196: + return emitClassDeclaration(node); + case 198: + return emitTypeAliasDeclaration(node); + case 219: + return emitEnumMemberDeclaration(node); + case 199: + return emitEnumDeclaration(node); + case 200: + return emitModuleDeclaration(node); + case 202: + return emitImportEqualsDeclaration(node); + case 208: + return emitExportAssignment(node); + case 220: + return emitSourceFile(node); + } + } + function writeReferencePath(referencedFile) { + var declFileName = referencedFile.flags & 1024 ? referencedFile.fileName : shouldEmitToOwnFile(referencedFile, compilerOptions) ? getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") : ts.removeFileExtension(compilerOptions.out) + ".d.ts"; + declFileName = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizeSlashes(jsFilePath)), declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, false); + referencePathsOutput += "/// " + newLine; + } + } + function getDeclarationDiagnostics(host, resolver, targetSourceFile) { + var diagnostics = []; + var jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js"); + emitDeclarations(host, resolver, diagnostics, jsFilePath, targetSourceFile); + return diagnostics; + } + ts.getDeclarationDiagnostics = getDeclarationDiagnostics; + function emitFiles(resolver, host, targetSourceFile) { + var compilerOptions = host.getCompilerOptions(); + var languageVersion = compilerOptions.target || 0; + var sourceMapDataList = compilerOptions.sourceMap ? [] : undefined; + var diagnostics = []; + var newLine = host.getNewLine(); + if (targetSourceFile === undefined) { + ts.forEach(host.getSourceFiles(), function (sourceFile) { + if (shouldEmitToOwnFile(sourceFile, compilerOptions)) { + var jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, ".js"); + emitFile(jsFilePath, sourceFile); + } + }); + if (compilerOptions.out) { + emitFile(compilerOptions.out); + } + } + else { + if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) { + var jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js"); + emitFile(jsFilePath, targetSourceFile); + } + else if (!ts.isDeclarationFile(targetSourceFile) && compilerOptions.out) { + emitFile(compilerOptions.out); + } + } + diagnostics = ts.sortAndDeduplicateDiagnostics(diagnostics); + return { + emitSkipped: false, + diagnostics: diagnostics, + sourceMaps: sourceMapDataList + }; + function emitJavaScript(jsFilePath, root) { + var writer = createTextWriter(newLine); + var write = writer.write; + var writeTextOfNode = writer.writeTextOfNode; + var writeLine = writer.writeLine; + var increaseIndent = writer.increaseIndent; + var decreaseIndent = writer.decreaseIndent; + var currentSourceFile; + var extendsEmitted = false; + var tempCount = 0; + var tempVariables; + var tempParameters; + var externalImports; + var exportSpecifiers; + var writeEmittedFiles = writeJavaScriptFile; + var emitLeadingComments = compilerOptions.removeComments ? function (node) { } : emitLeadingDeclarationComments; + var emitTrailingComments = compilerOptions.removeComments ? function (node) { } : emitTrailingDeclarationComments; + var emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos) { } : emitLeadingCommentsOfLocalPosition; + var detachedCommentsInfo; + var emitDetachedComments = compilerOptions.removeComments ? function (node) { } : emitDetachedCommentsAtPosition; + var emitPinnedOrTripleSlashComments = compilerOptions.removeComments ? function (node) { } : emitPinnedOrTripleSlashCommentsOfNode; + var writeComment = writeCommentRange; + var emit = emitNode; + var emitStart = function (node) { }; + var emitEnd = function (node) { }; + var emitToken = emitTokenText; + var scopeEmitStart = function (scopeDeclaration, scopeName) { }; + var scopeEmitEnd = function () { }; + var sourceMapData; + if (compilerOptions.sourceMap) { + initializeEmitterWithSourceMaps(); + } + if (root) { + emit(root); + } + else { + ts.forEach(host.getSourceFiles(), function (sourceFile) { + if (!isExternalModuleOrDeclarationFile(sourceFile)) { + emit(sourceFile); + } + }); + } + writeLine(); + writeEmittedFiles(writer.getText(), compilerOptions.emitBOM); + return; + function initializeEmitterWithSourceMaps() { + var sourceMapDir; + var sourceMapSourceIndex = -1; + var sourceMapNameIndexMap = {}; + var sourceMapNameIndices = []; + function getSourceMapNameIndex() { + return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1; + } + var lastRecordedSourceMapSpan; + var lastEncodedSourceMapSpan = { + emittedLine: 1, + emittedColumn: 1, + sourceLine: 1, + sourceColumn: 1, + sourceIndex: 0 + }; + var lastEncodedNameIndex = 0; + function encodeLastRecordedSourceMapSpan() { + if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) { + return; + } + var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn; + if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) { + if (sourceMapData.sourceMapMappings) { + sourceMapData.sourceMapMappings += ","; + } + } + else { + for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) { + sourceMapData.sourceMapMappings += ";"; + } + prevEncodedEmittedColumn = 1; + } + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn); + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex); + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine); + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn); + if (lastRecordedSourceMapSpan.nameIndex >= 0) { + sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex); + lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex; + } + lastEncodedSourceMapSpan = lastRecordedSourceMapSpan; + sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan); + function base64VLQFormatEncode(inValue) { + function base64FormatEncode(inValue) { + if (inValue < 64) { + return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(inValue); + } + throw TypeError(inValue + ": not a 64 based value"); + } + if (inValue < 0) { + inValue = ((-inValue) << 1) + 1; + } + else { + inValue = inValue << 1; + } + var encodedStr = ""; + do { + var currentDigit = inValue & 31; + inValue = inValue >> 5; + if (inValue > 0) { + currentDigit = currentDigit | 32; + } + encodedStr = encodedStr + base64FormatEncode(currentDigit); + } while (inValue > 0); + return encodedStr; + } + } + function recordSourceMapSpan(pos) { + var sourceLinePos = ts.getLineAndCharacterOfPosition(currentSourceFile, pos); + sourceLinePos.line++; + sourceLinePos.character++; + var emittedLine = writer.getLine(); + var emittedColumn = writer.getColumn(); + if (!lastRecordedSourceMapSpan || + lastRecordedSourceMapSpan.emittedLine != emittedLine || + lastRecordedSourceMapSpan.emittedColumn != emittedColumn || + (lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex && + (lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line || + (lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) { + encodeLastRecordedSourceMapSpan(); + lastRecordedSourceMapSpan = { + emittedLine: emittedLine, + emittedColumn: emittedColumn, + sourceLine: sourceLinePos.line, + sourceColumn: sourceLinePos.character, + nameIndex: getSourceMapNameIndex(), + sourceIndex: sourceMapSourceIndex + }; + } + else { + lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line; + lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character; + lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex; + } + } + function recordEmitNodeStartSpan(node) { + recordSourceMapSpan(ts.skipTrivia(currentSourceFile.text, node.pos)); + } + function recordEmitNodeEndSpan(node) { + recordSourceMapSpan(node.end); + } + function writeTextWithSpanRecord(tokenKind, startPos, emitFn) { + var tokenStartPos = ts.skipTrivia(currentSourceFile.text, startPos); + recordSourceMapSpan(tokenStartPos); + var tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn); + recordSourceMapSpan(tokenEndPos); + return tokenEndPos; + } + function recordNewSourceFileStart(node) { + var sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir; + sourceMapData.sourceMapSources.push(ts.getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, node.fileName, host.getCurrentDirectory(), host.getCanonicalFileName, true)); + sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1; + sourceMapData.inputSourceFileNames.push(node.fileName); + } + function recordScopeNameOfNode(node, scopeName) { + function recordScopeNameIndex(scopeNameIndex) { + sourceMapNameIndices.push(scopeNameIndex); + } + function recordScopeNameStart(scopeName) { + var scopeNameIndex = -1; + if (scopeName) { + var parentIndex = getSourceMapNameIndex(); + if (parentIndex !== -1) { + var name = node.name; + if (!name || name.kind !== 126) { + scopeName = "." + scopeName; + } + scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; + } + scopeNameIndex = ts.getProperty(sourceMapNameIndexMap, scopeName); + if (scopeNameIndex === undefined) { + scopeNameIndex = sourceMapData.sourceMapNames.length; + sourceMapData.sourceMapNames.push(scopeName); + sourceMapNameIndexMap[scopeName] = scopeNameIndex; + } + } + recordScopeNameIndex(scopeNameIndex); + } + if (scopeName) { + recordScopeNameStart(scopeName); + } + else if (node.kind === 195 || + node.kind === 160 || + node.kind === 132 || + node.kind === 131 || + node.kind === 134 || + node.kind === 135 || + node.kind === 200 || + node.kind === 196 || + node.kind === 199) { + if (node.name) { + var name = node.name; + scopeName = name.kind === 126 ? ts.getTextOfNode(name) : node.name.text; + } + recordScopeNameStart(scopeName); + } + else { + recordScopeNameIndex(getSourceMapNameIndex()); + } + } + function recordScopeNameEnd() { + sourceMapNameIndices.pop(); + } + ; + function writeCommentRangeWithMap(curentSourceFile, writer, comment, newLine) { + recordSourceMapSpan(comment.pos); + writeCommentRange(currentSourceFile, writer, comment, newLine); + recordSourceMapSpan(comment.end); + } + function serializeSourceMapContents(version, file, sourceRoot, sources, names, mappings) { + if (typeof JSON !== "undefined") { + return JSON.stringify({ + version: version, + file: file, + sourceRoot: sourceRoot, + sources: sources, + names: names, + mappings: mappings + }); + } + return "{\"version\":" + version + ",\"file\":\"" + ts.escapeString(file) + "\",\"sourceRoot\":\"" + ts.escapeString(sourceRoot) + "\",\"sources\":[" + serializeStringArray(sources) + "],\"names\":[" + serializeStringArray(names) + "],\"mappings\":\"" + ts.escapeString(mappings) + "\"}"; + function serializeStringArray(list) { + var output = ""; + for (var i = 0, n = list.length; i < n; i++) { + if (i) { + output += ","; + } + output += "\"" + ts.escapeString(list[i]) + "\""; + } + return output; + } + } + function writeJavaScriptAndSourceMapFile(emitOutput, writeByteOrderMark) { + encodeLastRecordedSourceMapSpan(); + writeFile(host, diagnostics, sourceMapData.sourceMapFilePath, serializeSourceMapContents(3, sourceMapData.sourceMapFile, sourceMapData.sourceMapSourceRoot, sourceMapData.sourceMapSources, sourceMapData.sourceMapNames, sourceMapData.sourceMapMappings), false); + sourceMapDataList.push(sourceMapData); + writeJavaScriptFile(emitOutput + "//# sourceMappingURL=" + sourceMapData.jsSourceMappingURL, writeByteOrderMark); + } + var sourceMapJsFile = ts.getBaseFileName(ts.normalizeSlashes(jsFilePath)); + sourceMapData = { + sourceMapFilePath: jsFilePath + ".map", + jsSourceMappingURL: sourceMapJsFile + ".map", + sourceMapFile: sourceMapJsFile, + sourceMapSourceRoot: compilerOptions.sourceRoot || "", + sourceMapSources: [], + inputSourceFileNames: [], + sourceMapNames: [], + sourceMapMappings: "", + sourceMapDecodedMappings: [] + }; + sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot); + if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== 47) { + sourceMapData.sourceMapSourceRoot += ts.directorySeparator; + } + if (compilerOptions.mapRoot) { + sourceMapDir = ts.normalizeSlashes(compilerOptions.mapRoot); + if (root) { + sourceMapDir = ts.getDirectoryPath(getSourceFilePathInNewDir(root, host, sourceMapDir)); + } + if (!ts.isRootedDiskPath(sourceMapDir) && !ts.isUrl(sourceMapDir)) { + sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir); + sourceMapData.jsSourceMappingURL = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(jsFilePath)), ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), host.getCurrentDirectory(), host.getCanonicalFileName, true); + } + else { + sourceMapData.jsSourceMappingURL = ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL); + } + } + else { + sourceMapDir = ts.getDirectoryPath(ts.normalizePath(jsFilePath)); + } + function emitNodeWithMap(node) { + if (node) { + if (node.kind != 220) { + recordEmitNodeStartSpan(node); + emitNode(node); + recordEmitNodeEndSpan(node); + } + else { + recordNewSourceFileStart(node); + emitNode(node); + } + } + } + writeEmittedFiles = writeJavaScriptAndSourceMapFile; + emit = emitNodeWithMap; + emitStart = recordEmitNodeStartSpan; + emitEnd = recordEmitNodeEndSpan; + emitToken = writeTextWithSpanRecord; + scopeEmitStart = recordScopeNameOfNode; + scopeEmitEnd = recordScopeNameEnd; + writeComment = writeCommentRangeWithMap; + } + function writeJavaScriptFile(emitOutput, writeByteOrderMark) { + writeFile(host, diagnostics, jsFilePath, emitOutput, writeByteOrderMark); + } + function createTempVariable(location, forLoopVariable) { + var name = forLoopVariable ? "_i" : undefined; + while (true) { + if (name && resolver.isUnknownIdentifier(location, name)) { + break; + } + name = "_" + (tempCount < 25 ? String.fromCharCode(tempCount + (tempCount < 8 ? 0 : 1) + 97) : tempCount - 25); + tempCount++; + } + var result = ts.createNode(64); + result.text = name; + return result; + } + function recordTempDeclaration(name) { + if (!tempVariables) { + tempVariables = []; + } + tempVariables.push(name); + } + function createAndRecordTempVariable(location) { + var temp = createTempVariable(location, false); + recordTempDeclaration(temp); + return temp; + } + function emitTempDeclarations(newLine) { + if (tempVariables) { + if (newLine) { + writeLine(); + } + else { + write(" "); + } + write("var "); + emitCommaList(tempVariables); + write(";"); + } + } + function emitTokenText(tokenKind, startPos, emitFn) { + var tokenString = ts.tokenToString(tokenKind); + if (emitFn) { + emitFn(); + } + else { + write(tokenString); + } + return startPos + tokenString.length; + } + function emitOptional(prefix, node) { + if (node) { + write(prefix); + emit(node); + } + } + function emitParenthesized(node, parenthesized) { + if (parenthesized) { + write("("); + } + emit(node); + if (parenthesized) { + write(")"); + } + } + function emitTrailingCommaIfPresent(nodeList) { + if (nodeList.hasTrailingComma) { + write(","); + } + } + function emitLinePreservingList(parent, nodes, allowTrailingComma, spacesBetweenBraces) { + ts.Debug.assert(nodes.length > 0); + increaseIndent(); + if (nodeStartPositionsAreOnSameLine(parent, nodes[0])) { + if (spacesBetweenBraces) { + write(" "); + } + } + else { + writeLine(); + } + for (var i = 0, n = nodes.length; i < n; i++) { + if (i) { + if (nodeEndIsOnSameLineAsNodeStart(nodes[i - 1], nodes[i])) { + write(", "); + } + else { + write(","); + writeLine(); + } + } + emit(nodes[i]); + } + var closeTokenIsOnSameLineAsLastElement = nodeEndPositionsAreOnSameLine(parent, ts.lastOrUndefined(nodes)); + if (nodes.hasTrailingComma && allowTrailingComma) { + write(","); + } + decreaseIndent(); + if (closeTokenIsOnSameLineAsLastElement) { + if (spacesBetweenBraces) { + write(" "); + } + } + else { + writeLine(); + } + } + function emitList(nodes, start, count, multiLine, trailingComma) { + for (var i = 0; i < count; i++) { + if (multiLine) { + if (i) { + write(","); + } + writeLine(); + } + else { + if (i) { + write(", "); + } + } + emit(nodes[start + i]); + } + if (trailingComma) { + write(","); + } + if (multiLine) { + writeLine(); + } + } + function emitCommaList(nodes) { + if (nodes) { + emitList(nodes, 0, nodes.length, false, false); + } + } + function emitLines(nodes) { + emitLinesStartingAt(nodes, 0); + } + function emitLinesStartingAt(nodes, startIndex) { + for (var i = startIndex; i < nodes.length; i++) { + writeLine(); + emit(nodes[i]); + } + } + function isBinaryOrOctalIntegerLiteral(text) { + if (text.length <= 0) { + return false; + } + if (text.charCodeAt(1) === 66 || text.charCodeAt(1) === 98 || + text.charCodeAt(1) === 79 || text.charCodeAt(1) === 111) { + return true; + } + return false; + } + function emitLiteral(node) { + var text = languageVersion < 2 && ts.isTemplateLiteralKind(node.kind) ? getTemplateLiteralAsStringLiteral(node) : node.parent ? ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node) : node.text; + if (compilerOptions.sourceMap && (node.kind === 8 || ts.isTemplateLiteralKind(node.kind))) { + writer.writeLiteral(text); + } + else if (languageVersion < 2 && node.kind === 7 && isBinaryOrOctalIntegerLiteral(text)) { + write(node.text); + } + else { + write(text); + } + } + function getTemplateLiteralAsStringLiteral(node) { + return '"' + ts.escapeString(node.text) + '"'; + } + function emitTemplateExpression(node) { + if (languageVersion >= 2) { + ts.forEachChild(node, emit); + return; + } + var emitOuterParens = ts.isExpression(node.parent) && templateNeedsParens(node, node.parent); + if (emitOuterParens) { + write("("); + } + var headEmitted = false; + if (shouldEmitTemplateHead()) { + emitLiteral(node.head); + headEmitted = true; + } + for (var i = 0; i < node.templateSpans.length; i++) { + var templateSpan = node.templateSpans[i]; + var needsParens = templateSpan.expression.kind !== 159 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; + if (i > 0 || headEmitted) { + write(" + "); + } + emitParenthesized(templateSpan.expression, needsParens); + if (templateSpan.literal.text.length !== 0) { + write(" + "); + emitLiteral(templateSpan.literal); + } + } + if (emitOuterParens) { + write(")"); + } + function shouldEmitTemplateHead() { + ts.Debug.assert(node.templateSpans.length !== 0); + return node.head.text.length !== 0 || node.templateSpans[0].literal.text.length === 0; + } + function templateNeedsParens(template, parent) { + switch (parent.kind) { + case 155: + case 156: + return parent.expression === template; + case 157: + case 159: + return false; + default: + return comparePrecedenceToBinaryPlus(parent) !== -1; + } + } + function comparePrecedenceToBinaryPlus(expression) { + switch (expression.kind) { + case 167: + switch (expression.operatorToken.kind) { + case 35: + case 36: + case 37: + return 1; + case 33: + case 34: + return 0; + default: + return -1; + } + case 168: + return -1; + default: + return 1; + } + } + } + function emitTemplateSpan(span) { + emit(span.expression); + emit(span.literal); + } + function emitExpressionForPropertyName(node) { + ts.Debug.assert(node.kind !== 150); + if (node.kind === 8) { + emitLiteral(node); + } + else if (node.kind === 126) { + emit(node.expression); + } + else { + write("\""); + if (node.kind === 7) { + write(node.text); + } + else { + writeTextOfNode(currentSourceFile, node); + } + write("\""); + } + } + function isNotExpressionIdentifier(node) { + var parent = node.parent; + switch (parent.kind) { + case 128: + case 193: + case 150: + case 130: + case 129: + case 217: + case 218: + case 219: + case 132: + case 131: + case 195: + case 134: + case 135: + case 160: + case 196: + case 197: + case 199: + case 200: + case 202: + return parent.name === node; + case 185: + case 184: + case 208: + return false; + case 189: + return node.parent.label === node; + case 216: + return node.parent.name === node; + } + } + function emitExpressionIdentifier(node) { + var substitution = resolver.getExpressionNameSubstitution(node); + if (substitution) { + write(substitution); + } + else { + writeTextOfNode(currentSourceFile, node); + } + } + function emitIdentifier(node) { + if (!node.parent) { + write(node.text); + } + else if (!isNotExpressionIdentifier(node)) { + emitExpressionIdentifier(node); + } + else { + writeTextOfNode(currentSourceFile, node); + } + } + function emitThis(node) { + if (resolver.getNodeCheckFlags(node) & 2) { + write("_this"); + } + else { + write("this"); + } + } + function emitSuper(node) { + var flags = resolver.getNodeCheckFlags(node); + if (flags & 16) { + write("_super.prototype"); + } + else if (flags & 32) { + write("_super"); + } + else { + write("super"); + } + } + function emitObjectBindingPattern(node) { + write("{ "); + var elements = node.elements; + emitList(elements, 0, elements.length, false, elements.hasTrailingComma); + write(" }"); + } + function emitArrayBindingPattern(node) { + write("["); + var elements = node.elements; + emitList(elements, 0, elements.length, false, elements.hasTrailingComma); + write("]"); + } + function emitBindingElement(node) { + if (node.propertyName) { + emit(node.propertyName); + write(": "); + } + if (node.dotDotDotToken) { + write("..."); + } + if (ts.isBindingPattern(node.name)) { + emit(node.name); + } + else { + emitModuleMemberName(node); + } + emitOptional(" = ", node.initializer); + } + function emitSpreadElementExpression(node) { + write("..."); + emit(node.expression); + } + function needsParenthesisForPropertyAccess(node) { + switch (node.kind) { + case 64: + case 151: + case 153: + case 154: + case 155: + case 159: + return false; + } + return true; + } + function emitListWithSpread(elements, multiLine, trailingComma) { + var pos = 0; + var group = 0; + var length = elements.length; + while (pos < length) { + if (group === 1) { + write(".concat("); + } + else if (group > 1) { + write(", "); + } + var e = elements[pos]; + if (e.kind === 171) { + e = e.expression; + emitParenthesized(e, group === 0 && needsParenthesisForPropertyAccess(e)); + pos++; + } + else { + var i = pos; + while (i < length && elements[i].kind !== 171) { + i++; + } + write("["); + if (multiLine) { + increaseIndent(); + } + emitList(elements, pos, i - pos, multiLine, trailingComma && i === length); + if (multiLine) { + decreaseIndent(); + } + write("]"); + pos = i; + } + group++; + } + if (group > 1) { + write(")"); + } + } + function isSpreadElementExpression(node) { + return node.kind === 171; + } + function emitArrayLiteral(node) { + var elements = node.elements; + if (elements.length === 0) { + write("[]"); + } + else if (languageVersion >= 2 || !ts.forEach(elements, isSpreadElementExpression)) { + write("["); + emitLinePreservingList(node, node.elements, elements.hasTrailingComma, false); + write("]"); + } + else { + emitListWithSpread(elements, (node.flags & 256) !== 0, elements.hasTrailingComma); + } + } + function createSynthesizedNode(kind) { + var node = ts.createNode(kind); + node.pos = -1; + node.end = -1; + return node; + } + function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) { + var parenthesizedObjectLiteral = createDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex); + return emit(parenthesizedObjectLiteral); + } + function createDownlevelObjectLiteralWithComputedProperties(originalObjectLiteral, firstComputedPropertyIndex) { + var tempVar = createAndRecordTempVariable(originalObjectLiteral); + var initialObjectLiteral = createSynthesizedNode(152); + initialObjectLiteral.properties = originalObjectLiteral.properties.slice(0, firstComputedPropertyIndex); + initialObjectLiteral.flags |= 256; + var propertyPatches = createBinaryExpression(tempVar, 52, initialObjectLiteral); + ts.forEach(originalObjectLiteral.properties, function (property) { + var patchedProperty = tryCreatePatchingPropertyAssignment(originalObjectLiteral, tempVar, property); + if (patchedProperty) { + propertyPatches = createBinaryExpression(propertyPatches, 23, patchedProperty); + } + }); + propertyPatches = createBinaryExpression(propertyPatches, 23, tempVar); + var result = createParenthesizedExpression(propertyPatches); + return result; + } + function addCommentsToSynthesizedNode(node, leadingCommentRanges, trailingCommentRanges) { + node.leadingCommentRanges = leadingCommentRanges; + node.trailingCommentRanges = trailingCommentRanges; + } + function tryCreatePatchingPropertyAssignment(objectLiteral, tempVar, property) { + var leftHandSide = createMemberAccessForPropertyName(tempVar, property.name); + var maybeRightHandSide = tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral, property); + return maybeRightHandSide && createBinaryExpression(leftHandSide, 52, maybeRightHandSide); + } + function tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral, property) { + switch (property.kind) { + case 217: + return property.initializer; + case 218: + return createIdentifier(resolver.getExpressionNameSubstitution(property.name)); + case 132: + return createFunctionExpression(property.parameters, property.body); + case 134: + case 135: + var _a = getAllAccessorDeclarations(objectLiteral.properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; + if (firstAccessor !== property) { + return undefined; + } + var propertyDescriptor = createSynthesizedNode(152); + var descriptorProperties = []; + if (getAccessor) { + var getProperty = createPropertyAssignment(createIdentifier("get"), createFunctionExpression(getAccessor.parameters, getAccessor.body)); + descriptorProperties.push(getProperty); + } + if (setAccessor) { + var setProperty = createPropertyAssignment(createIdentifier("set"), createFunctionExpression(setAccessor.parameters, setAccessor.body)); + descriptorProperties.push(setProperty); + } + var trueExpr = createSynthesizedNode(94); + var enumerableTrue = createPropertyAssignment(createIdentifier("enumerable"), trueExpr); + descriptorProperties.push(enumerableTrue); + var configurableTrue = createPropertyAssignment(createIdentifier("configurable"), trueExpr); + descriptorProperties.push(configurableTrue); + propertyDescriptor.properties = descriptorProperties; + var objectDotDefineProperty = createPropertyAccessExpression(createIdentifier("Object"), createIdentifier("defineProperty")); + return createCallExpression(objectDotDefineProperty, createNodeArray(propertyDescriptor)); + default: + ts.Debug.fail("ObjectLiteralElement kind " + property.kind + " not accounted for."); + } + } + function createParenthesizedExpression(expression) { + var result = createSynthesizedNode(159); + result.expression = expression; + return result; + } + function createNodeArray() { + var elements = []; + for (var _i = 0; _i < arguments.length; _i++) { + elements[_i - 0] = arguments[_i]; + } + var result = elements; + result.pos = -1; + result.end = -1; + return result; + } + function createBinaryExpression(left, operator, right) { + var result = createSynthesizedNode(167); + result.operatorToken = createSynthesizedNode(operator); + result.left = left; + result.right = right; + return result; + } + function createMemberAccessForPropertyName(expression, memberName) { + if (memberName.kind === 64) { + return createPropertyAccessExpression(expression, memberName); + } + else if (memberName.kind === 8 || memberName.kind === 7) { + return createElementAccessExpression(expression, memberName); + } + else if (memberName.kind === 126) { + return createElementAccessExpression(expression, memberName.expression); + } + else { + ts.Debug.fail("Kind '" + memberName.kind + "' not accounted for."); + } + } + function createPropertyAssignment(name, initializer) { + var result = createSynthesizedNode(217); + result.name = name; + result.initializer = initializer; + return result; + } + function createFunctionExpression(parameters, body) { + var result = createSynthesizedNode(160); + result.parameters = parameters; + result.body = body; + return result; + } + function createPropertyAccessExpression(expression, name) { + var result = createSynthesizedNode(153); + result.expression = expression; + result.name = name; + return result; + } + function createElementAccessExpression(expression, argumentExpression) { + var result = createSynthesizedNode(154); + result.expression = expression; + result.argumentExpression = argumentExpression; + return result; + } + function createIdentifier(name) { + var result = createSynthesizedNode(64); + result.text = name; + return result; + } + function createCallExpression(invokedExpression, arguments) { + var result = createSynthesizedNode(155); + result.expression = invokedExpression; + result.arguments = arguments; + return result; + } + function emitObjectLiteral(node) { + var properties = node.properties; + if (languageVersion < 2) { + var numProperties = properties.length; + var numInitialNonComputedProperties = numProperties; + for (var i = 0, n = properties.length; i < n; i++) { + if (properties[i].name.kind === 126) { + numInitialNonComputedProperties = i; + break; + } + } + var hasComputedProperty = numInitialNonComputedProperties !== properties.length; + if (hasComputedProperty) { + emitDownlevelObjectLiteralWithComputedProperties(node, numInitialNonComputedProperties); + return; + } + } + write("{"); + var properties = node.properties; + if (properties.length) { + emitLinePreservingList(node, properties, languageVersion >= 1, true); + } + write("}"); + } + function emitComputedPropertyName(node) { + write("["); + emit(node.expression); + write("]"); + } + function emitMethod(node) { + emit(node.name); + if (languageVersion < 2) { + write(": function "); + } + emitSignatureAndBody(node); + } + function emitPropertyAssignment(node) { + emit(node.name); + write(": "); + emit(node.initializer); + } + function emitShorthandPropertyAssignment(node) { + emit(node.name); + if (languageVersion < 2 || resolver.getExpressionNameSubstitution(node.name)) { + write(": "); + emitExpressionIdentifier(node.name); + } + } + function tryEmitConstantValue(node) { + var constantValue = resolver.getConstantValue(node); + if (constantValue !== undefined) { + write(constantValue.toString()); + if (!compilerOptions.removeComments) { + var propertyName = node.kind === 153 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + write(" /* " + propertyName + " */"); + } + return true; + } + return false; + } + function emitPropertyAccess(node) { + if (tryEmitConstantValue(node)) { + return; + } + emit(node.expression); + write("."); + emit(node.name); + } + function emitQualifiedName(node) { + emit(node.left); + write("."); + emit(node.right); + } + function emitIndexedAccess(node) { + if (tryEmitConstantValue(node)) { + return; + } + emit(node.expression); + write("["); + emit(node.argumentExpression); + write("]"); + } + function hasSpreadElement(elements) { + return ts.forEach(elements, function (e) { return e.kind === 171; }); + } + function skipParentheses(node) { + while (node.kind === 159 || node.kind === 158) { + node = node.expression; + } + return node; + } + function emitCallTarget(node) { + if (node.kind === 64 || node.kind === 92 || node.kind === 90) { + emit(node); + return node; + } + var temp = createAndRecordTempVariable(node); + write("("); + emit(temp); + write(" = "); + emit(node); + write(")"); + return temp; + } + function emitCallWithSpread(node) { + var target; + var expr = skipParentheses(node.expression); + if (expr.kind === 153) { + target = emitCallTarget(expr.expression); + write("."); + emit(expr.name); + } + else if (expr.kind === 154) { + target = emitCallTarget(expr.expression); + write("["); + emit(expr.argumentExpression); + write("]"); + } + else if (expr.kind === 90) { + target = expr; + write("_super"); + } + else { + emit(node.expression); + } + write(".apply("); + if (target) { + if (target.kind === 90) { + emitThis(target); + } + else { + emit(target); + } + } + else { + write("void 0"); + } + write(", "); + emitListWithSpread(node.arguments, false, false); + write(")"); + } + function emitCallExpression(node) { + if (languageVersion < 2 && hasSpreadElement(node.arguments)) { + emitCallWithSpread(node); + return; + } + var superCall = false; + if (node.expression.kind === 90) { + write("_super"); + superCall = true; + } + else { + emit(node.expression); + superCall = node.expression.kind === 153 && node.expression.expression.kind === 90; + } + if (superCall) { + write(".call("); + emitThis(node.expression); + if (node.arguments.length) { + write(", "); + emitCommaList(node.arguments); + } + write(")"); + } + else { + write("("); + emitCommaList(node.arguments); + write(")"); + } + } + function emitNewExpression(node) { + write("new "); + emit(node.expression); + if (node.arguments) { + write("("); + emitCommaList(node.arguments); + write(")"); + } + } + function emitTaggedTemplateExpression(node) { + emit(node.tag); + write(" "); + emit(node.template); + } + function emitParenExpression(node) { + if (node.expression.kind === 158) { + var operand = node.expression.expression; + while (operand.kind == 158) { + operand = operand.expression; + } + if (operand.kind !== 165 && + operand.kind !== 164 && + operand.kind !== 163 && + operand.kind !== 162 && + operand.kind !== 166 && + operand.kind !== 156 && + !(operand.kind === 155 && node.parent.kind === 156) && + !(operand.kind === 160 && node.parent.kind === 155)) { + emit(operand); + return; + } + } + write("("); + emit(node.expression); + write(")"); + } + function emitDeleteExpression(node) { + write(ts.tokenToString(73)); + write(" "); + emit(node.expression); + } + function emitVoidExpression(node) { + write(ts.tokenToString(98)); + write(" "); + emit(node.expression); + } + function emitTypeOfExpression(node) { + write(ts.tokenToString(96)); + write(" "); + emit(node.expression); + } + function emitPrefixUnaryExpression(node) { + write(ts.tokenToString(node.operator)); + if (node.operand.kind === 165) { + var operand = node.operand; + if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { + write(" "); + } + else if (node.operator === 34 && (operand.operator === 34 || operand.operator === 39)) { + write(" "); + } + } + emit(node.operand); + } + function emitPostfixUnaryExpression(node) { + emit(node.operand); + write(ts.tokenToString(node.operator)); + } + function emitBinaryExpression(node) { + if (languageVersion < 2 && node.operatorToken.kind === 52 && + (node.left.kind === 152 || node.left.kind === 151)) { + emitDestructuring(node); + } + else { + emit(node.left); + if (node.operatorToken.kind !== 23) { + write(" "); + } + write(ts.tokenToString(node.operatorToken.kind)); + var operatorEnd = ts.getLineAndCharacterOfPosition(currentSourceFile, node.operatorToken.end); + var rightStart = ts.getLineAndCharacterOfPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.right.pos)); + var onDifferentLine = operatorEnd.line !== rightStart.line; + if (onDifferentLine) { + var exprStart = ts.getLineAndCharacterOfPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos)); + var firstCharOfExpr = getFirstNonWhitespaceCharacterIndexOnLine(exprStart.line); + var shouldIndent = rightStart.character > firstCharOfExpr; + if (shouldIndent) { + increaseIndent(); + } + writeLine(); + } + else { + write(" "); + } + emit(node.right); + if (shouldIndent) { + decreaseIndent(); + } + } + } + function getFirstNonWhitespaceCharacterIndexOnLine(line) { + var lineStart = ts.getLineStarts(currentSourceFile)[line]; + var text = currentSourceFile.text; + for (var i = lineStart; i < text.length; i++) { + var ch = text.charCodeAt(i); + if (!ts.isWhiteSpace(text.charCodeAt(i)) || ts.isLineBreak(ch)) { + break; + } + } + return i - lineStart; + } + function emitConditionalExpression(node) { + emit(node.condition); + write(" ? "); + emit(node.whenTrue); + write(" : "); + emit(node.whenFalse); + } + function isSingleLineEmptyBlock(node) { + if (node && node.kind === 174) { + var block = node; + return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); + } + } + function emitBlock(node) { + if (isSingleLineEmptyBlock(node)) { + emitToken(14, node.pos); + write(" "); + emitToken(15, node.statements.end); + return; + } + emitToken(14, node.pos); + increaseIndent(); + scopeEmitStart(node.parent); + if (node.kind === 201) { + ts.Debug.assert(node.parent.kind === 200); + emitCaptureThisForNodeIfNecessary(node.parent); + } + emitLines(node.statements); + if (node.kind === 201) { + emitTempDeclarations(true); + } + decreaseIndent(); + writeLine(); + emitToken(15, node.statements.end); + scopeEmitEnd(); + } + function emitEmbeddedStatement(node) { + if (node.kind === 174) { + write(" "); + emit(node); + } + else { + increaseIndent(); + writeLine(); + emit(node); + decreaseIndent(); + } + } + function emitExpressionStatement(node) { + emitParenthesized(node.expression, node.expression.kind === 161); + write(";"); + } + function emitIfStatement(node) { + var endPos = emitToken(83, node.pos); + write(" "); + endPos = emitToken(16, endPos); + emit(node.expression); + emitToken(17, node.expression.end); + emitEmbeddedStatement(node.thenStatement); + if (node.elseStatement) { + writeLine(); + emitToken(75, node.thenStatement.end); + if (node.elseStatement.kind === 178) { + write(" "); + emit(node.elseStatement); + } + else { + emitEmbeddedStatement(node.elseStatement); + } + } + } + function emitDoStatement(node) { + write("do"); + emitEmbeddedStatement(node.statement); + if (node.statement.kind === 174) { + write(" "); + } + else { + writeLine(); + } + write("while ("); + emit(node.expression); + write(");"); + } + function emitWhileStatement(node) { + write("while ("); + emit(node.expression); + write(")"); + emitEmbeddedStatement(node.statement); + } + function emitForStatement(node) { + var endPos = emitToken(81, node.pos); + write(" "); + endPos = emitToken(16, endPos); + if (node.initializer && node.initializer.kind === 194) { + var variableDeclarationList = node.initializer; + var declarations = variableDeclarationList.declarations; + if (declarations[0] && ts.isLet(declarations[0])) { + emitToken(105, endPos); + } + else if (declarations[0] && ts.isConst(declarations[0])) { + emitToken(69, endPos); + } + else { + emitToken(97, endPos); + } + write(" "); + emitCommaList(variableDeclarationList.declarations); + } + else if (node.initializer) { + emit(node.initializer); + } + write(";"); + emitOptional(" ", node.condition); + write(";"); + emitOptional(" ", node.iterator); + write(")"); + emitEmbeddedStatement(node.statement); + } + function emitForInOrForOfStatement(node) { + var endPos = emitToken(81, node.pos); + write(" "); + endPos = emitToken(16, endPos); + if (node.initializer.kind === 194) { + var variableDeclarationList = node.initializer; + if (variableDeclarationList.declarations.length >= 1) { + var decl = variableDeclarationList.declarations[0]; + if (ts.isLet(decl)) { + emitToken(105, endPos); + } + else { + emitToken(97, endPos); + } + write(" "); + emit(decl); + } + } + else { + emit(node.initializer); + } + if (node.kind === 182) { + write(" in "); + } + else { + write(" of "); + } + emit(node.expression); + emitToken(17, node.expression.end); + emitEmbeddedStatement(node.statement); + } + function emitBreakOrContinueStatement(node) { + emitToken(node.kind === 185 ? 65 : 70, node.pos); + emitOptional(" ", node.label); + write(";"); + } + function emitReturnStatement(node) { + emitToken(89, node.pos); + emitOptional(" ", node.expression); + write(";"); + } + function emitWithStatement(node) { + write("with ("); + emit(node.expression); + write(")"); + emitEmbeddedStatement(node.statement); + } + function emitSwitchStatement(node) { + var endPos = emitToken(91, node.pos); + write(" "); + emitToken(16, endPos); + emit(node.expression); + endPos = emitToken(17, node.expression.end); + write(" "); + emitToken(14, endPos); + increaseIndent(); + emitLines(node.clauses); + decreaseIndent(); + writeLine(); + emitToken(15, node.clauses.end); + } + function nodeStartPositionsAreOnSameLine(node1, node2) { + return getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node1.pos)) === + getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); + } + function nodeEndPositionsAreOnSameLine(node1, node2) { + return getLineOfLocalPosition(currentSourceFile, node1.end) === + getLineOfLocalPosition(currentSourceFile, node2.end); + } + function nodeEndIsOnSameLineAsNodeStart(node1, node2) { + return getLineOfLocalPosition(currentSourceFile, node1.end) === + getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); + } + function emitCaseOrDefaultClause(node) { + if (node.kind === 213) { + write("case "); + emit(node.expression); + write(":"); + } + else { + write("default:"); + } + if (node.statements.length === 1 && nodeStartPositionsAreOnSameLine(node, node.statements[0])) { + write(" "); + emit(node.statements[0]); + } + else { + increaseIndent(); + emitLines(node.statements); + decreaseIndent(); + } + } + function emitThrowStatement(node) { + write("throw "); + emit(node.expression); + write(";"); + } + function emitTryStatement(node) { + write("try "); + emit(node.tryBlock); + emit(node.catchClause); + if (node.finallyBlock) { + writeLine(); + write("finally "); + emit(node.finallyBlock); + } + } + function emitCatchClause(node) { + writeLine(); + var endPos = emitToken(67, node.pos); + write(" "); + emitToken(16, endPos); + emit(node.name); + emitToken(17, node.name.end); + write(" "); + emitBlock(node.block); + } + function emitDebuggerStatement(node) { + emitToken(71, node.pos); + write(";"); + } + function emitLabelledStatement(node) { + emit(node.label); + write(": "); + emit(node.statement); + } + function getContainingModule(node) { + do { + node = node.parent; + } while (node && node.kind !== 200); + return node; + } + function emitContainingModuleName(node) { + var container = getContainingModule(node); + write(container ? resolver.getGeneratedNameForNode(container) : "exports"); + } + function emitModuleMemberName(node) { + emitStart(node.name); + if (ts.getCombinedNodeFlags(node) & 1) { + emitContainingModuleName(node); + write("."); + } + emitNode(node.name); + emitEnd(node.name); + } + function emitExportMemberAssignments(name) { + if (exportSpecifiers && ts.hasProperty(exportSpecifiers, name.text)) { + ts.forEach(exportSpecifiers[name.text], function (specifier) { + writeLine(); + emitStart(specifier.name); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + emitEnd(specifier.name); + write(" = "); + emitNode(name); + write(";"); + }); + } + } + function emitDestructuring(root, value) { + var emitCount = 0; + var isDeclaration = (root.kind === 193 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 128; + if (root.kind === 167) { + emitAssignmentExpression(root); + } + else { + emitBindingElement(root, value); + } + function emitAssignment(name, value) { + if (emitCount++) { + write(", "); + } + if (name.parent && (name.parent.kind === 193 || name.parent.kind === 150)) { + emitModuleMemberName(name.parent); + } + else { + emit(name); + } + write(" = "); + emit(value); + } + function ensureIdentifier(expr) { + if (expr.kind !== 64) { + var identifier = createTempVariable(root); + if (!isDeclaration) { + recordTempDeclaration(identifier); + } + emitAssignment(identifier, expr); + expr = identifier; + } + return expr; + } + function createVoidZero() { + var zero = ts.createNode(7); + zero.text = "0"; + var result = ts.createNode(164); + result.expression = zero; + return result; + } + function createDefaultValueCheck(value, defaultValue) { + value = ensureIdentifier(value); + var equals = ts.createNode(167); + equals.left = value; + equals.operatorToken = ts.createNode(30); + equals.right = createVoidZero(); + var cond = ts.createNode(168); + cond.condition = equals; + cond.whenTrue = defaultValue; + cond.whenFalse = value; + return cond; + } + function createNumericLiteral(value) { + var node = ts.createNode(7); + node.text = "" + value; + return node; + } + function parenthesizeForAccess(expr) { + if (expr.kind === 64 || expr.kind === 153 || expr.kind === 154) { + return expr; + } + var node = ts.createNode(159); + node.expression = expr; + return node; + } + function createPropertyAccess(object, propName) { + if (propName.kind !== 64) { + return createElementAccess(object, propName); + } + var node = ts.createNode(153); + node.expression = parenthesizeForAccess(object); + node.name = propName; + return node; + } + function createElementAccess(object, index) { + var node = ts.createNode(154); + node.expression = parenthesizeForAccess(object); + node.argumentExpression = index; + return node; + } + function emitObjectLiteralAssignment(target, value) { + var properties = target.properties; + if (properties.length !== 1) { + value = ensureIdentifier(value); + } + for (var i = 0; i < properties.length; i++) { + var p = properties[i]; + if (p.kind === 217 || p.kind === 218) { + var propName = (p.name); + emitDestructuringAssignment(p.initializer || propName, createPropertyAccess(value, propName)); + } + } + } + function emitArrayLiteralAssignment(target, value) { + var elements = target.elements; + if (elements.length !== 1) { + value = ensureIdentifier(value); + } + for (var i = 0; i < elements.length; i++) { + var e = elements[i]; + if (e.kind !== 172) { + if (e.kind !== 171) { + emitDestructuringAssignment(e, createElementAccess(value, createNumericLiteral(i))); + } + else { + if (i === elements.length - 1) { + value = ensureIdentifier(value); + emitAssignment(e.expression, value); + write(".slice(" + i + ")"); + } + } + } + } + } + function emitDestructuringAssignment(target, value) { + if (target.kind === 167 && target.operatorToken.kind === 52) { + value = createDefaultValueCheck(value, target.right); + target = target.left; + } + if (target.kind === 152) { + emitObjectLiteralAssignment(target, value); + } + else if (target.kind === 151) { + emitArrayLiteralAssignment(target, value); + } + else { + emitAssignment(target, value); + } + } + function emitAssignmentExpression(root) { + var target = root.left; + var value = root.right; + if (root.parent.kind === 177) { + emitDestructuringAssignment(target, value); + } + else { + if (root.parent.kind !== 159) { + write("("); + } + value = ensureIdentifier(value); + emitDestructuringAssignment(target, value); + write(", "); + emit(value); + if (root.parent.kind !== 159) { + write(")"); + } + } + } + function emitBindingElement(target, value) { + if (target.initializer) { + value = value ? createDefaultValueCheck(value, target.initializer) : target.initializer; + } + else if (!value) { + value = createVoidZero(); + } + if (ts.isBindingPattern(target.name)) { + var pattern = target.name; + var elements = pattern.elements; + if (elements.length !== 1) { + value = ensureIdentifier(value); + } + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + if (pattern.kind === 148) { + var propName = element.propertyName || element.name; + emitBindingElement(element, createPropertyAccess(value, propName)); + } + else if (element.kind !== 172) { + if (!element.dotDotDotToken) { + emitBindingElement(element, createElementAccess(value, createNumericLiteral(i))); + } + else { + if (i === elements.length - 1) { + value = ensureIdentifier(value); + emitAssignment(element.name, value); + write(".slice(" + i + ")"); + } + } + } + } + } + else { + emitAssignment(target.name, value); + } + } + } + function emitVariableDeclaration(node) { + if (ts.isBindingPattern(node.name)) { + if (languageVersion < 2) { + emitDestructuring(node); + } + else { + emit(node.name); + emitOptional(" = ", node.initializer); + } + } + else { + emitModuleMemberName(node); + emitOptional(" = ", node.initializer); + } + } + function emitExportVariableAssignments(node) { + var name = node.name; + if (name.kind === 64) { + emitExportMemberAssignments(name); + } + else if (ts.isBindingPattern(name)) { + ts.forEach(name.elements, emitExportVariableAssignments); + } + } + function emitVariableStatement(node) { + if (!(node.flags & 1)) { + if (ts.isLet(node.declarationList)) { + write("let "); + } + else if (ts.isConst(node.declarationList)) { + write("const "); + } + else { + write("var "); + } + } + emitCommaList(node.declarationList.declarations); + write(";"); + if (languageVersion < 2 && node.parent === currentSourceFile) { + ts.forEach(node.declarationList.declarations, emitExportVariableAssignments); + } + } + function emitParameter(node) { + if (languageVersion < 2) { + if (ts.isBindingPattern(node.name)) { + var name = createTempVariable(node); + if (!tempParameters) { + tempParameters = []; + } + tempParameters.push(name); + emit(name); + } + else { + emit(node.name); + } + } + else { + if (node.dotDotDotToken) { + write("..."); + } + emit(node.name); + emitOptional(" = ", node.initializer); + } + } + function emitDefaultValueAssignments(node) { + if (languageVersion < 2) { + var tempIndex = 0; + ts.forEach(node.parameters, function (p) { + if (ts.isBindingPattern(p.name)) { + writeLine(); + write("var "); + emitDestructuring(p, tempParameters[tempIndex]); + write(";"); + tempIndex++; + } + else if (p.initializer) { + writeLine(); + emitStart(p); + write("if ("); + emitNode(p.name); + write(" === void 0)"); + emitEnd(p); + write(" { "); + emitStart(p); + emitNode(p.name); + write(" = "); + emitNode(p.initializer); + emitEnd(p); + write("; }"); + } + }); + } + } + function emitRestParameter(node) { + if (languageVersion < 2 && ts.hasRestParameters(node)) { + var restIndex = node.parameters.length - 1; + var restParam = node.parameters[restIndex]; + var tempName = createTempVariable(node, true).text; + writeLine(); + emitLeadingComments(restParam); + emitStart(restParam); + write("var "); + emitNode(restParam.name); + write(" = [];"); + emitEnd(restParam); + emitTrailingComments(restParam); + writeLine(); + write("for ("); + emitStart(restParam); + write("var " + tempName + " = " + restIndex + ";"); + emitEnd(restParam); + write(" "); + emitStart(restParam); + write(tempName + " < arguments.length;"); + emitEnd(restParam); + write(" "); + emitStart(restParam); + write(tempName + "++"); + emitEnd(restParam); + write(") {"); + increaseIndent(); + writeLine(); + emitStart(restParam); + emitNode(restParam.name); + write("[" + tempName + " - " + restIndex + "] = arguments[" + tempName + "];"); + emitEnd(restParam); + decreaseIndent(); + writeLine(); + write("}"); + } + } + function emitAccessor(node) { + write(node.kind === 134 ? "get " : "set "); + emit(node.name); + emitSignatureAndBody(node); + } + function shouldEmitAsArrowFunction(node) { + return node.kind === 161 && languageVersion >= 2; + } + function emitFunctionDeclaration(node) { + if (ts.nodeIsMissing(node.body)) { + return emitPinnedOrTripleSlashComments(node); + } + if (node.kind !== 132 && node.kind !== 131) { + emitLeadingComments(node); + } + if (!shouldEmitAsArrowFunction(node)) { + write("function "); + } + if (node.kind === 195 || (node.kind === 160 && node.name)) { + emit(node.name); + } + emitSignatureAndBody(node); + if (languageVersion < 2 && node.kind === 195 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + if (node.kind !== 132 && node.kind !== 131) { + emitTrailingComments(node); + } + } + function emitCaptureThisForNodeIfNecessary(node) { + if (resolver.getNodeCheckFlags(node) & 4) { + writeLine(); + emitStart(node); + write("var _this = this;"); + emitEnd(node); + } + } + function emitSignatureParameters(node) { + increaseIndent(); + write("("); + if (node) { + var parameters = node.parameters; + var omitCount = languageVersion < 2 && ts.hasRestParameters(node) ? 1 : 0; + emitList(parameters, 0, parameters.length - omitCount, false, false); + } + write(")"); + decreaseIndent(); + } + function emitSignatureParametersForArrow(node) { + if (node.parameters.length === 1 && node.pos === node.parameters[0].pos) { + emit(node.parameters[0]); + return; + } + emitSignatureParameters(node); + } + function emitSignatureAndBody(node) { + var saveTempCount = tempCount; + var saveTempVariables = tempVariables; + var saveTempParameters = tempParameters; + tempCount = 0; + tempVariables = undefined; + tempParameters = undefined; + if (shouldEmitAsArrowFunction(node)) { + emitSignatureParametersForArrow(node); + write(" =>"); + } + else { + emitSignatureParameters(node); + } + if (!node.body) { + write(" { }"); + } + else if (node.body.kind === 174) { + emitBlockFunctionBody(node, node.body); + } + else { + emitExpressionFunctionBody(node, node.body); + } + if (node.flags & 1) { + writeLine(); + emitStart(node); + emitModuleMemberName(node); + write(" = "); + emit(node.name); + emitEnd(node); + write(";"); + } + tempCount = saveTempCount; + tempVariables = saveTempVariables; + tempParameters = saveTempParameters; + } + function emitFunctionBodyPreamble(node) { + emitCaptureThisForNodeIfNecessary(node); + emitDefaultValueAssignments(node); + emitRestParameter(node); + } + function emitExpressionFunctionBody(node, body) { + if (languageVersion < 2) { + emitDownLevelExpressionFunctionBody(node, body); + return; + } + write(" "); + emit(body); + } + function emitDownLevelExpressionFunctionBody(node, body) { + write(" {"); + scopeEmitStart(node); + increaseIndent(); + var outPos = writer.getTextPos(); + emitDetachedComments(node.body); + emitFunctionBodyPreamble(node); + var preambleEmitted = writer.getTextPos() !== outPos; + decreaseIndent(); + if (!preambleEmitted && nodeStartPositionsAreOnSameLine(node, body)) { + write(" "); + emitStart(body); + write("return "); + emitNode(body, true); + emitEnd(body); + write(";"); + emitTempDeclarations(false); + write(" "); + } + else { + increaseIndent(); + writeLine(); + emitLeadingComments(node.body); + write("return "); + emit(node.body, true); + write(";"); + emitTrailingComments(node.body); + emitTempDeclarations(true); + decreaseIndent(); + writeLine(); + } + emitStart(node.body); + write("}"); + emitEnd(node.body); + scopeEmitEnd(); + } + function emitBlockFunctionBody(node, body) { + if (body.statements.length === 0 && !anyParameterHasBindingPatternOrInitializer(node)) { + emitFunctionBodyWithNoStatements(node, body); + } + else { + emitFunctionBodyWithStatements(node, body); + } + } + function anyParameterHasBindingPatternOrInitializer(func) { + return ts.forEach(func.parameters, hasBindingPatternOrInitializer); + } + function hasBindingPatternOrInitializer(parameter) { + return parameter.initializer || ts.isBindingPattern(parameter.name); + } + function emitFunctionBodyWithNoStatements(node, body) { + var singleLine = isSingleLineEmptyBlock(node.body); + write(" {"); + if (singleLine) { + write(" "); + } + else { + increaseIndent(); + writeLine(); + } + emitLeadingCommentsOfPosition(body.statements.end); + if (!singleLine) { + decreaseIndent(); + } + emitToken(15, body.statements.end); + } + function emitFunctionBodyWithStatements(node, body) { + write(" {"); + scopeEmitStart(node); + var outPos = writer.getTextPos(); + increaseIndent(); + emitDetachedComments(body.statements); + var startIndex = emitDirectivePrologues(body.statements, true); + emitFunctionBodyPreamble(node); + decreaseIndent(); + var preambleEmitted = writer.getTextPos() !== outPos; + if (!preambleEmitted && nodeEndIsOnSameLineAsNodeStart(body, body)) { + for (var i = 0, n = body.statements.length; i < n; i++) { + write(" "); + emit(body.statements[i]); + } + emitTempDeclarations(false); + write(" "); + emitLeadingCommentsOfPosition(body.statements.end); + } + else { + increaseIndent(); + emitLinesStartingAt(body.statements, startIndex); + emitTempDeclarations(true); + writeLine(); + emitLeadingCommentsOfPosition(body.statements.end); + decreaseIndent(); + } + emitToken(15, body.statements.end); + scopeEmitEnd(); + } + function findInitialSuperCall(ctor) { + if (ctor.body) { + var statement = ctor.body.statements[0]; + if (statement && statement.kind === 177) { + var expr = statement.expression; + if (expr && expr.kind === 155) { + var func = expr.expression; + if (func && func.kind === 90) { + return statement; + } + } + } + } + } + function emitParameterPropertyAssignments(node) { + ts.forEach(node.parameters, function (param) { + if (param.flags & 112) { + writeLine(); + emitStart(param); + emitStart(param.name); + write("this."); + emitNode(param.name); + emitEnd(param.name); + write(" = "); + emit(param.name); + write(";"); + emitEnd(param); + } + }); + } + function emitMemberAccessForPropertyName(memberName) { + if (memberName.kind === 8 || memberName.kind === 7) { + write("["); + emitNode(memberName); + write("]"); + } + else if (memberName.kind === 126) { + emitComputedPropertyName(memberName); + } + else { + write("."); + emitNode(memberName); + } + } + function emitMemberAssignments(node, staticFlag) { + ts.forEach(node.members, function (member) { + if (member.kind === 130 && (member.flags & 128) === staticFlag && member.initializer) { + writeLine(); + emitLeadingComments(member); + emitStart(member); + emitStart(member.name); + if (staticFlag) { + emitNode(node.name); + } + else { + write("this"); + } + emitMemberAccessForPropertyName(member.name); + emitEnd(member.name); + write(" = "); + emit(member.initializer); + write(";"); + emitEnd(member); + emitTrailingComments(member); + } + }); + } + function emitMemberFunctions(node) { + ts.forEach(node.members, function (member) { + if (member.kind === 132 || node.kind === 131) { + if (!member.body) { + return emitPinnedOrTripleSlashComments(member); + } + writeLine(); + emitLeadingComments(member); + emitStart(member); + emitStart(member.name); + emitNode(node.name); + if (!(member.flags & 128)) { + write(".prototype"); + } + emitMemberAccessForPropertyName(member.name); + emitEnd(member.name); + write(" = "); + emitStart(member); + emitFunctionDeclaration(member); + emitEnd(member); + emitEnd(member); + write(";"); + emitTrailingComments(member); + } + else if (member.kind === 134 || member.kind === 135) { + var accessors = getAllAccessorDeclarations(node.members, member); + if (member === accessors.firstAccessor) { + writeLine(); + emitStart(member); + write("Object.defineProperty("); + emitStart(member.name); + emitNode(node.name); + if (!(member.flags & 128)) { + write(".prototype"); + } + write(", "); + emitExpressionForPropertyName(member.name); + emitEnd(member.name); + write(", {"); + increaseIndent(); + if (accessors.getAccessor) { + writeLine(); + emitLeadingComments(accessors.getAccessor); + write("get: "); + emitStart(accessors.getAccessor); + write("function "); + emitSignatureAndBody(accessors.getAccessor); + emitEnd(accessors.getAccessor); + emitTrailingComments(accessors.getAccessor); + write(","); + } + if (accessors.setAccessor) { + writeLine(); + emitLeadingComments(accessors.setAccessor); + write("set: "); + emitStart(accessors.setAccessor); + write("function "); + emitSignatureAndBody(accessors.setAccessor); + emitEnd(accessors.setAccessor); + emitTrailingComments(accessors.setAccessor); + write(","); + } + writeLine(); + write("enumerable: true,"); + writeLine(); + write("configurable: true"); + decreaseIndent(); + writeLine(); + write("});"); + emitEnd(member); + } + } + }); + } + function emitClassDeclaration(node) { + write("var "); + emit(node.name); + write(" = (function ("); + var baseTypeNode = ts.getClassBaseTypeNode(node); + if (baseTypeNode) { + write("_super"); + } + write(") {"); + increaseIndent(); + scopeEmitStart(node); + if (baseTypeNode) { + writeLine(); + emitStart(baseTypeNode); + write("__extends("); + emit(node.name); + write(", _super);"); + emitEnd(baseTypeNode); + } + writeLine(); + emitConstructorOfClass(); + emitMemberFunctions(node); + emitMemberAssignments(node, 128); + writeLine(); + function emitClassReturnStatement() { + write("return "); + emitNode(node.name); + } + emitToken(15, node.members.end, emitClassReturnStatement); + write(";"); + decreaseIndent(); + writeLine(); + emitToken(15, node.members.end); + scopeEmitEnd(); + emitStart(node); + write(")("); + if (baseTypeNode) { + emit(baseTypeNode.typeName); + } + write(");"); + emitEnd(node); + if (node.flags & 1) { + writeLine(); + emitStart(node); + emitModuleMemberName(node); + write(" = "); + emit(node.name); + emitEnd(node); + write(";"); + } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + function emitConstructorOfClass() { + var saveTempCount = tempCount; + var saveTempVariables = tempVariables; + var saveTempParameters = tempParameters; + tempCount = 0; + tempVariables = undefined; + tempParameters = undefined; + ts.forEach(node.members, function (member) { + if (member.kind === 133 && !member.body) { + emitPinnedOrTripleSlashComments(member); + } + }); + var ctor = getFirstConstructorWithBody(node); + if (ctor) { + emitLeadingComments(ctor); + } + emitStart(ctor || node); + write("function "); + emit(node.name); + emitSignatureParameters(ctor); + write(" {"); + scopeEmitStart(node, "constructor"); + increaseIndent(); + if (ctor) { + emitDetachedComments(ctor.body.statements); + } + emitCaptureThisForNodeIfNecessary(node); + if (ctor) { + emitDefaultValueAssignments(ctor); + emitRestParameter(ctor); + if (baseTypeNode) { + var superCall = findInitialSuperCall(ctor); + if (superCall) { + writeLine(); + emit(superCall); + } + } + emitParameterPropertyAssignments(ctor); + } + else { + if (baseTypeNode) { + writeLine(); + emitStart(baseTypeNode); + write("_super.apply(this, arguments);"); + emitEnd(baseTypeNode); + } + } + emitMemberAssignments(node, 0); + if (ctor) { + var statements = ctor.body.statements; + if (superCall) + statements = statements.slice(1); + emitLines(statements); + } + emitTempDeclarations(true); + writeLine(); + if (ctor) { + emitLeadingCommentsOfPosition(ctor.body.statements.end); + } + decreaseIndent(); + emitToken(15, ctor ? ctor.body.statements.end : node.members.end); + scopeEmitEnd(); + emitEnd(ctor || node); + if (ctor) { + emitTrailingComments(ctor); + } + tempCount = saveTempCount; + tempVariables = saveTempVariables; + tempParameters = saveTempParameters; + } + } + function emitInterfaceDeclaration(node) { + emitPinnedOrTripleSlashComments(node); + } + function shouldEmitEnumDeclaration(node) { + var isConstEnum = ts.isConst(node); + return !isConstEnum || compilerOptions.preserveConstEnums; + } + function emitEnumDeclaration(node) { + if (!shouldEmitEnumDeclaration(node)) { + return; + } + if (!(node.flags & 1)) { + emitStart(node); + write("var "); + emit(node.name); + emitEnd(node); + write(";"); + } + writeLine(); + emitStart(node); + write("(function ("); + emitStart(node.name); + write(resolver.getGeneratedNameForNode(node)); + emitEnd(node.name); + write(") {"); + increaseIndent(); + scopeEmitStart(node); + emitLines(node.members); + decreaseIndent(); + writeLine(); + emitToken(15, node.members.end); + scopeEmitEnd(); + write(")("); + emitModuleMemberName(node); + write(" || ("); + emitModuleMemberName(node); + write(" = {}));"); + emitEnd(node); + if (node.flags & 1) { + writeLine(); + emitStart(node); + write("var "); + emit(node.name); + write(" = "); + emitModuleMemberName(node); + emitEnd(node); + write(";"); + } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + } + function emitEnumMember(node) { + var enumParent = node.parent; + emitStart(node); + write(resolver.getGeneratedNameForNode(enumParent)); + write("["); + write(resolver.getGeneratedNameForNode(enumParent)); + write("["); + emitExpressionForPropertyName(node.name); + write("] = "); + writeEnumMemberDeclarationValue(node); + write("] = "); + emitExpressionForPropertyName(node.name); + emitEnd(node); + write(";"); + } + function writeEnumMemberDeclarationValue(member) { + if (!member.initializer || ts.isConst(member.parent)) { + var value = resolver.getConstantValue(member); + if (value !== undefined) { + write(value.toString()); + return; + } + } + if (member.initializer) { + emit(member.initializer); + } + else { + write("undefined"); + } + } + function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { + if (moduleDeclaration.body.kind === 200) { + var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); + return recursiveInnerModule || moduleDeclaration.body; + } + } + function shouldEmitModuleDeclaration(node) { + return ts.isInstantiatedModule(node, compilerOptions.preserveConstEnums); + } + function emitModuleDeclaration(node) { + var shouldEmit = shouldEmitModuleDeclaration(node); + if (!shouldEmit) { + return emitPinnedOrTripleSlashComments(node); + } + emitStart(node); + write("var "); + emit(node.name); + write(";"); + emitEnd(node); + writeLine(); + emitStart(node); + write("(function ("); + emitStart(node.name); + write(resolver.getGeneratedNameForNode(node)); + emitEnd(node.name); + write(") "); + if (node.body.kind === 201) { + var saveTempCount = tempCount; + var saveTempVariables = tempVariables; + tempCount = 0; + tempVariables = undefined; + emit(node.body); + tempCount = saveTempCount; + tempVariables = saveTempVariables; + } + else { + write("{"); + increaseIndent(); + scopeEmitStart(node); + emitCaptureThisForNodeIfNecessary(node); + writeLine(); + emit(node.body); + decreaseIndent(); + writeLine(); + var moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body; + emitToken(15, moduleBlock.statements.end); + scopeEmitEnd(); + } + write(")("); + if (node.flags & 1) { + emit(node.name); + write(" = "); + } + emitModuleMemberName(node); + write(" || ("); + emitModuleMemberName(node); + write(" = {}));"); + emitEnd(node); + if (languageVersion < 2 && node.name.kind === 64 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + } + function emitRequire(moduleName) { + if (moduleName.kind === 8) { + write("require("); + emitStart(moduleName); + emitLiteral(moduleName); + emitEnd(moduleName); + emitToken(17, moduleName.end); + write(";"); + } + else { + write("require();"); + } + } + function emitImportDeclaration(node) { + var info = getExternalImportInfo(node); + if (info) { + var declarationNode = info.declarationNode; + var namedImports = info.namedImports; + if (compilerOptions.module !== 2) { + emitLeadingComments(node); + emitStart(node); + var moduleName = ts.getExternalModuleName(node); + if (declarationNode) { + if (!(declarationNode.flags & 1)) + write("var "); + emitModuleMemberName(declarationNode); + write(" = "); + emitRequire(moduleName); + } + else if (namedImports) { + write("var "); + write(resolver.getGeneratedNameForNode(node)); + write(" = "); + emitRequire(moduleName); + } + else { + emitRequire(moduleName); + } + emitEnd(node); + emitTrailingComments(node); + } + else { + if (declarationNode) { + if (declarationNode.flags & 1) { + emitModuleMemberName(declarationNode); + write(" = "); + emit(declarationNode.name); + write(";"); + } + } + } + } + } + function emitImportEqualsDeclaration(node) { + if (ts.isExternalModuleImportEqualsDeclaration(node)) { + emitImportDeclaration(node); + return; + } + if (resolver.isReferencedImportDeclaration(node) || + (!ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node))) { + emitLeadingComments(node); + emitStart(node); + if (!(node.flags & 1)) + write("var "); + emitModuleMemberName(node); + write(" = "); + emit(node.moduleReference); + write(";"); + emitEnd(node); + emitTrailingComments(node); + } + } + function emitExportDeclaration(node) { + if (node.moduleSpecifier) { + emitStart(node); + var generatedName = resolver.getGeneratedNameForNode(node); + if (compilerOptions.module !== 2) { + write("var "); + write(generatedName); + write(" = "); + emitRequire(ts.getExternalModuleName(node)); + } + if (node.exportClause) { + ts.forEach(node.exportClause.elements, function (specifier) { + writeLine(); + emitStart(specifier); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + write(" = "); + write(generatedName); + write("."); + emitNode(specifier.propertyName || specifier.name); + write(";"); + emitEnd(specifier); + }); + } + else { + var tempName = createTempVariable(node).text; + writeLine(); + write("for (var " + tempName + " in " + generatedName + ") if (!"); + emitContainingModuleName(node); + write(".hasOwnProperty(" + tempName + ")) "); + emitContainingModuleName(node); + write("[" + tempName + "] = " + generatedName + "[" + tempName + "];"); + } + emitEnd(node); + } + } + function createExternalImportInfo(node) { + if (node.kind === 202) { + if (node.moduleReference.kind === 212) { + return { + rootNode: node, + declarationNode: node + }; + } + } + else if (node.kind === 203) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + return { + rootNode: node, + declarationNode: importClause + }; + } + if (importClause.namedBindings.kind === 205) { + return { + rootNode: node, + declarationNode: importClause.namedBindings + }; + } + return { + rootNode: node, + namedImports: importClause.namedBindings, + localName: resolver.getGeneratedNameForNode(node) + }; + } + return { + rootNode: node + }; + } + else if (node.kind === 209) { + if (node.moduleSpecifier) { + return { + rootNode: node + }; + } + } + } + function createExternalModuleInfo(sourceFile) { + externalImports = []; + exportSpecifiers = {}; + ts.forEach(sourceFile.statements, function (node) { + if (node.kind === 209 && !node.moduleSpecifier) { + ts.forEach(node.exportClause.elements, function (specifier) { + var name = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier); + }); + } + else { + var info = createExternalImportInfo(node); + if (info) { + if ((!info.declarationNode && !info.namedImports) || resolver.isReferencedImportDeclaration(node)) { + externalImports.push(info); + } + } + } + }); + } + function getExternalImportInfo(node) { + if (externalImports) { + for (var i = 0; i < externalImports.length; i++) { + var info = externalImports[i]; + if (info.rootNode === node) { + return info; + } + } + } + } + function getFirstExportAssignment(sourceFile) { + return ts.forEach(sourceFile.statements, function (node) { + if (node.kind === 208) { + return node; + } + }); + } + function sortAMDModules(amdModules) { + return amdModules.sort(function (moduleA, moduleB) { + if (moduleA.name === moduleB.name) { + return 0; + } + else if (!moduleA.name) { + return 1; + } + else { + return -1; + } + }); + } + function emitAMDModule(node, startIndex) { + writeLine(); + write("define("); + sortAMDModules(node.amdDependencies); + if (node.amdModuleName) { + write("\"" + node.amdModuleName + "\", "); + } + write("[\"require\", \"exports\""); + ts.forEach(externalImports, function (info) { + write(", "); + var moduleName = ts.getExternalModuleName(info.rootNode); + if (moduleName.kind === 8) { + emitLiteral(moduleName); + } + else { + write("\"\""); + } + }); + ts.forEach(node.amdDependencies, function (amdDependency) { + var text = "\"" + amdDependency.path + "\""; + write(", "); + write(text); + }); + write("], function (require, exports"); + ts.forEach(externalImports, function (info) { + write(", "); + if (info.declarationNode) { + emit(info.declarationNode.name); + } + else { + write(resolver.getGeneratedNameForNode(info.rootNode)); + } + }); + ts.forEach(node.amdDependencies, function (amdDependency) { + if (amdDependency.name) { + write(", "); + write(amdDependency.name); + } + }); + write(") {"); + increaseIndent(); + emitCaptureThisForNodeIfNecessary(node); + emitLinesStartingAt(node.statements, startIndex); + emitTempDeclarations(true); + var exportName = resolver.getExportAssignmentName(node); + if (exportName) { + writeLine(); + var exportAssignment = getFirstExportAssignment(node); + emitStart(exportAssignment); + write("return "); + emitStart(exportAssignment.exportName); + write(exportName); + emitEnd(exportAssignment.exportName); + write(";"); + emitEnd(exportAssignment); + } + decreaseIndent(); + writeLine(); + write("});"); + } + function emitCommonJSModule(node, startIndex) { + emitCaptureThisForNodeIfNecessary(node); + emitLinesStartingAt(node.statements, startIndex); + emitTempDeclarations(true); + var exportName = resolver.getExportAssignmentName(node); + if (exportName) { + writeLine(); + var exportAssignment = getFirstExportAssignment(node); + emitStart(exportAssignment); + write("module.exports = "); + emitStart(exportAssignment.exportName); + write(exportName); + emitEnd(exportAssignment.exportName); + write(";"); + emitEnd(exportAssignment); + } + } + function emitDirectivePrologues(statements, startWithNewLine) { + for (var i = 0; i < statements.length; ++i) { + if (ts.isPrologueDirective(statements[i])) { + if (startWithNewLine || i > 0) { + writeLine(); + } + emit(statements[i]); + } + else { + return i; + } + } + return statements.length; + } + function emitSourceFile(node) { + currentSourceFile = node; + writeLine(); + emitDetachedComments(node); + var startIndex = emitDirectivePrologues(node.statements, false); + if (!extendsEmitted && resolver.getNodeCheckFlags(node) & 8) { + writeLine(); + write("var __extends = this.__extends || function (d, b) {"); + increaseIndent(); + writeLine(); + write("for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];"); + writeLine(); + write("function __() { this.constructor = d; }"); + writeLine(); + write("__.prototype = b.prototype;"); + writeLine(); + write("d.prototype = new __();"); + decreaseIndent(); + writeLine(); + write("};"); + extendsEmitted = true; + } + if (ts.isExternalModule(node)) { + createExternalModuleInfo(node); + if (compilerOptions.module === 2) { + emitAMDModule(node, startIndex); + } + else { + emitCommonJSModule(node, startIndex); + } + } + else { + externalImports = undefined; + exportSpecifiers = undefined; + emitCaptureThisForNodeIfNecessary(node); + emitLinesStartingAt(node.statements, startIndex); + emitTempDeclarations(true); + } + emitLeadingComments(node.endOfFileToken); + } + function emitNode(node, disableComments) { + if (!node) { + return; + } + if (node.flags & 2) { + return emitPinnedOrTripleSlashComments(node); + } + var emitComments = !disableComments && shouldEmitLeadingAndTrailingComments(node); + if (emitComments) { + emitLeadingComments(node); + } + emitJavaScriptWorker(node); + if (emitComments) { + emitTrailingComments(node); + } + } + function shouldEmitLeadingAndTrailingComments(node) { + switch (node.kind) { + case 197: + case 195: + case 203: + case 202: + case 198: + case 208: + return false; + case 200: + return shouldEmitModuleDeclaration(node); + case 199: + return shouldEmitEnumDeclaration(node); + } + return true; + } + function emitJavaScriptWorker(node) { + switch (node.kind) { + case 64: + return emitIdentifier(node); + case 128: + return emitParameter(node); + case 132: + case 131: + return emitMethod(node); + case 134: + case 135: + return emitAccessor(node); + case 92: + return emitThis(node); + case 90: + return emitSuper(node); + case 88: + return write("null"); + case 94: + return write("true"); + case 79: + return write("false"); + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + return emitLiteral(node); + case 169: + return emitTemplateExpression(node); + case 173: + return emitTemplateSpan(node); + case 125: + return emitQualifiedName(node); + case 148: + return emitObjectBindingPattern(node); + case 149: + return emitArrayBindingPattern(node); + case 150: + return emitBindingElement(node); + case 151: + return emitArrayLiteral(node); + case 152: + return emitObjectLiteral(node); + case 217: + return emitPropertyAssignment(node); + case 218: + return emitShorthandPropertyAssignment(node); + case 126: + return emitComputedPropertyName(node); + case 153: + return emitPropertyAccess(node); + case 154: + return emitIndexedAccess(node); + case 155: + return emitCallExpression(node); + case 156: + return emitNewExpression(node); + case 157: + return emitTaggedTemplateExpression(node); + case 158: + return emit(node.expression); + case 159: + return emitParenExpression(node); + case 195: + case 160: + case 161: + return emitFunctionDeclaration(node); + case 162: + return emitDeleteExpression(node); + case 163: + return emitTypeOfExpression(node); + case 164: + return emitVoidExpression(node); + case 165: + return emitPrefixUnaryExpression(node); + case 166: + return emitPostfixUnaryExpression(node); + case 167: + return emitBinaryExpression(node); + case 168: + return emitConditionalExpression(node); + case 171: + return emitSpreadElementExpression(node); + case 172: + return; + case 174: + case 201: + return emitBlock(node); + case 175: + return emitVariableStatement(node); + case 176: + return write(";"); + case 177: + return emitExpressionStatement(node); + case 178: + return emitIfStatement(node); + case 179: + return emitDoStatement(node); + case 180: + return emitWhileStatement(node); + case 181: + return emitForStatement(node); + case 183: + case 182: + return emitForInOrForOfStatement(node); + case 184: + case 185: + return emitBreakOrContinueStatement(node); + case 186: + return emitReturnStatement(node); + case 187: + return emitWithStatement(node); + case 188: + return emitSwitchStatement(node); + case 213: + case 214: + return emitCaseOrDefaultClause(node); + case 189: + return emitLabelledStatement(node); + case 190: + return emitThrowStatement(node); + case 191: + return emitTryStatement(node); + case 216: + return emitCatchClause(node); + case 192: + return emitDebuggerStatement(node); + case 193: + return emitVariableDeclaration(node); + case 196: + return emitClassDeclaration(node); + case 197: + return emitInterfaceDeclaration(node); + case 199: + return emitEnumDeclaration(node); + case 219: + return emitEnumMember(node); + case 200: + return emitModuleDeclaration(node); + case 203: + return emitImportDeclaration(node); + case 202: + return emitImportEqualsDeclaration(node); + case 209: + return emitExportDeclaration(node); + case 220: + return emitSourceFile(node); + } + } + function hasDetachedComments(pos) { + return detachedCommentsInfo !== undefined && detachedCommentsInfo[detachedCommentsInfo.length - 1].nodePos === pos; + } + function getLeadingCommentsWithoutDetachedComments() { + var leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, detachedCommentsInfo[detachedCommentsInfo.length - 1].detachedCommentEndPos); + if (detachedCommentsInfo.length - 1) { + detachedCommentsInfo.pop(); + } + else { + detachedCommentsInfo = undefined; + } + return leadingComments; + } + function getLeadingCommentsToEmit(node) { + if (node.parent) { + if (node.parent.kind === 220 || node.pos !== node.parent.pos) { + var leadingComments; + if (hasDetachedComments(node.pos)) { + leadingComments = getLeadingCommentsWithoutDetachedComments(); + } + else { + leadingComments = ts.getLeadingCommentRangesOfNode(node, currentSourceFile); + } + return leadingComments; + } + } + } + function emitLeadingDeclarationComments(node) { + var leadingComments = getLeadingCommentsToEmit(node); + emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments); + emitComments(currentSourceFile, writer, leadingComments, true, newLine, writeComment); + } + function emitTrailingDeclarationComments(node) { + if (node.parent) { + if (node.parent.kind === 220 || node.end !== node.parent.end) { + var trailingComments = ts.getTrailingCommentRanges(currentSourceFile.text, node.end); + emitComments(currentSourceFile, writer, trailingComments, false, newLine, writeComment); + } + } + } + function emitLeadingCommentsOfLocalPosition(pos) { + var leadingComments; + if (hasDetachedComments(pos)) { + leadingComments = getLeadingCommentsWithoutDetachedComments(); + } + else { + leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, pos); + } + emitNewLineBeforeLeadingComments(currentSourceFile, writer, { pos: pos, end: pos }, leadingComments); + emitComments(currentSourceFile, writer, leadingComments, true, newLine, writeComment); + } + function emitDetachedCommentsAtPosition(node) { + var leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos); + if (leadingComments) { + var detachedComments = []; + var lastComment; + ts.forEach(leadingComments, function (comment) { + if (lastComment) { + var lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end); + var commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos); + if (commentLine >= lastCommentLine + 2) { + return detachedComments; + } + } + detachedComments.push(comment); + lastComment = comment; + }); + if (detachedComments.length) { + var lastCommentLine = getLineOfLocalPosition(currentSourceFile, detachedComments[detachedComments.length - 1].end); + var nodeLine = getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos)); + if (nodeLine >= lastCommentLine + 2) { + emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments); + emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment); + var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: detachedComments[detachedComments.length - 1].end }; + if (detachedCommentsInfo) { + detachedCommentsInfo.push(currentDetachedCommentInfo); + } + else { + detachedCommentsInfo = [currentDetachedCommentInfo]; + } + } + } + } + } + function emitPinnedOrTripleSlashCommentsOfNode(node) { + var pinnedComments = ts.filter(getLeadingCommentsToEmit(node), isPinnedOrTripleSlashComment); + function isPinnedOrTripleSlashComment(comment) { + if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42) { + return currentSourceFile.text.charCodeAt(comment.pos + 2) === 33; + } + else if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 47 && + comment.pos + 2 < comment.end && + currentSourceFile.text.charCodeAt(comment.pos + 2) === 47 && + currentSourceFile.text.substring(comment.pos, comment.end).match(ts.fullTripleSlashReferencePathRegEx)) { + return true; + } + } + emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, pinnedComments); + emitComments(currentSourceFile, writer, pinnedComments, true, newLine, writeComment); + } + } + function writeDeclarationFile(jsFilePath, sourceFile) { + var emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile); + if (!emitDeclarationResult.reportedDeclarationError) { + var declarationOutput = emitDeclarationResult.referencePathsOutput; + var appliedSyncOutputPos = 0; + ts.forEach(emitDeclarationResult.aliasDeclarationEmitInfo, function (aliasEmitInfo) { + if (aliasEmitInfo.asynchronousOutput) { + declarationOutput += emitDeclarationResult.synchronousDeclarationOutput.substring(appliedSyncOutputPos, aliasEmitInfo.outputPos); + declarationOutput += aliasEmitInfo.asynchronousOutput; + appliedSyncOutputPos = aliasEmitInfo.outputPos; + } + }); + declarationOutput += emitDeclarationResult.synchronousDeclarationOutput.substring(appliedSyncOutputPos); + writeFile(host, diagnostics, ts.removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, compilerOptions.emitBOM); + } + } + function emitFile(jsFilePath, sourceFile) { + emitJavaScript(jsFilePath, sourceFile); + if (compilerOptions.declaration) { + writeDeclarationFile(jsFilePath, sourceFile); + } + } + } + ts.emitFiles = emitFiles; +})(ts || (ts = {})); +var ts; +(function (ts) { + ts.emitTime = 0; + function createCompilerHost(options) { + var currentDirectory; + var existingDirectories = {}; + function getCanonicalFileName(fileName) { + return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(); + } + var unsupportedFileEncodingErrorCode = -2147024809; + function getSourceFile(fileName, languageVersion, onError) { + try { + var text = ts.sys.readFile(fileName, options.charset); + } + catch (e) { + if (onError) { + onError(e.number === unsupportedFileEncodingErrorCode ? ts.createCompilerDiagnostic(ts.Diagnostics.Unsupported_file_encoding).messageText : e.message); + } + text = ""; + } + return text !== undefined ? ts.createSourceFile(fileName, text, languageVersion) : undefined; + } + function writeFile(fileName, data, writeByteOrderMark, onError) { + function directoryExists(directoryPath) { + if (ts.hasProperty(existingDirectories, directoryPath)) { + return true; + } + if (ts.sys.directoryExists(directoryPath)) { + existingDirectories[directoryPath] = true; + return true; + } + return false; + } + function ensureDirectoriesExist(directoryPath) { + if (directoryPath.length > ts.getRootLength(directoryPath) && !directoryExists(directoryPath)) { + var parentDirectory = ts.getDirectoryPath(directoryPath); + ensureDirectoriesExist(parentDirectory); + ts.sys.createDirectory(directoryPath); + } + } + try { + ensureDirectoriesExist(ts.getDirectoryPath(ts.normalizePath(fileName))); + ts.sys.writeFile(fileName, data, writeByteOrderMark); + } + catch (e) { + if (onError) { + onError(e.message); + } + } + } + return { + getSourceFile: getSourceFile, + getDefaultLibFileName: function (options) { return ts.combinePaths(ts.getDirectoryPath(ts.normalizePath(ts.sys.getExecutingFilePath())), ts.getDefaultLibFileName(options)); }, + writeFile: writeFile, + getCurrentDirectory: function () { return currentDirectory || (currentDirectory = ts.sys.getCurrentDirectory()); }, + useCaseSensitiveFileNames: function () { return ts.sys.useCaseSensitiveFileNames; }, + getCanonicalFileName: getCanonicalFileName, + getNewLine: function () { return ts.sys.newLine; } + }; + } + ts.createCompilerHost = createCompilerHost; + function getPreEmitDiagnostics(program) { + var diagnostics = program.getSyntacticDiagnostics().concat(program.getGlobalDiagnostics()).concat(program.getSemanticDiagnostics()); + return ts.sortAndDeduplicateDiagnostics(diagnostics); + } + ts.getPreEmitDiagnostics = getPreEmitDiagnostics; + function flattenDiagnosticMessageText(messageText, newLine) { + if (typeof messageText === "string") { + return messageText; + } + else { + var diagnosticChain = messageText; + var result = ""; + var indent = 0; + while (diagnosticChain) { + if (indent) { + result += newLine; + for (var i = 0; i < indent; i++) { + result += " "; + } + } + result += diagnosticChain.messageText; + indent++; + diagnosticChain = diagnosticChain.next; + } + return result; + } + } + ts.flattenDiagnosticMessageText = flattenDiagnosticMessageText; + function createProgram(rootNames, options, host) { + var program; + var files = []; + var filesByName = {}; + var diagnostics = ts.createDiagnosticCollection(); + var seenNoDefaultLib = options.noLib; + var commonSourceDirectory; + host = host || createCompilerHost(options); + ts.forEach(rootNames, function (name) { return processRootFile(name, false); }); + if (!seenNoDefaultLib) { + processRootFile(host.getDefaultLibFileName(options), true); + } + verifyCompilerOptions(); + var diagnosticsProducingTypeChecker; + var noDiagnosticsTypeChecker; + program = { + getSourceFile: getSourceFile, + getSourceFiles: function () { return files; }, + getCompilerOptions: function () { return options; }, + getSyntacticDiagnostics: getSyntacticDiagnostics, + getGlobalDiagnostics: getGlobalDiagnostics, + getSemanticDiagnostics: getSemanticDiagnostics, + getDeclarationDiagnostics: getDeclarationDiagnostics, + getTypeChecker: getTypeChecker, + getDiagnosticsProducingTypeChecker: getDiagnosticsProducingTypeChecker, + getCommonSourceDirectory: function () { return commonSourceDirectory; }, + emit: emit, + getCurrentDirectory: host.getCurrentDirectory, + getNodeCount: function () { return getDiagnosticsProducingTypeChecker().getNodeCount(); }, + getIdentifierCount: function () { return getDiagnosticsProducingTypeChecker().getIdentifierCount(); }, + getSymbolCount: function () { return getDiagnosticsProducingTypeChecker().getSymbolCount(); }, + getTypeCount: function () { return getDiagnosticsProducingTypeChecker().getTypeCount(); } + }; + return program; + function getEmitHost(writeFileCallback) { + return { + getCanonicalFileName: host.getCanonicalFileName, + getCommonSourceDirectory: program.getCommonSourceDirectory, + getCompilerOptions: program.getCompilerOptions, + getCurrentDirectory: host.getCurrentDirectory, + getNewLine: host.getNewLine, + getSourceFile: program.getSourceFile, + getSourceFiles: program.getSourceFiles, + writeFile: writeFileCallback || host.writeFile + }; + } + function getDiagnosticsProducingTypeChecker() { + return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = ts.createTypeChecker(program, true)); + } + function getTypeChecker() { + return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, false)); + } + function getDeclarationDiagnostics(targetSourceFile) { + var resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(targetSourceFile); + return ts.getDeclarationDiagnostics(getEmitHost(), resolver, targetSourceFile); + } + function emit(sourceFile, writeFileCallback) { + if (options.noEmitOnError && getPreEmitDiagnostics(this).length > 0) { + return { diagnostics: [], sourceMaps: undefined, emitSkipped: true }; + } + var start = new Date().getTime(); + var emitResult = ts.emitFiles(getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile), getEmitHost(writeFileCallback), sourceFile); + ts.emitTime += new Date().getTime() - start; + return emitResult; + } + function getSourceFile(fileName) { + fileName = host.getCanonicalFileName(fileName); + return ts.hasProperty(filesByName, fileName) ? filesByName[fileName] : undefined; + } + function getDiagnosticsHelper(sourceFile, getDiagnostics) { + if (sourceFile) { + return getDiagnostics(sourceFile); + } + var allDiagnostics = []; + ts.forEach(program.getSourceFiles(), function (sourceFile) { + ts.addRange(allDiagnostics, getDiagnostics(sourceFile)); + }); + return ts.sortAndDeduplicateDiagnostics(allDiagnostics); + } + function getSyntacticDiagnostics(sourceFile) { + return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile); + } + function getSemanticDiagnostics(sourceFile) { + return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile); + } + function getSyntacticDiagnosticsForFile(sourceFile) { + return sourceFile.parseDiagnostics; + } + function getSemanticDiagnosticsForFile(sourceFile) { + var typeChecker = getDiagnosticsProducingTypeChecker(); + ts.Debug.assert(!!sourceFile.bindDiagnostics); + var bindDiagnostics = sourceFile.bindDiagnostics; + var checkDiagnostics = typeChecker.getDiagnostics(sourceFile); + var programDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName); + return bindDiagnostics.concat(checkDiagnostics).concat(programDiagnostics); + } + function getGlobalDiagnostics() { + var typeChecker = getDiagnosticsProducingTypeChecker(); + var allDiagnostics = []; + ts.addRange(allDiagnostics, typeChecker.getGlobalDiagnostics()); + ts.addRange(allDiagnostics, diagnostics.getGlobalDiagnostics()); + return ts.sortAndDeduplicateDiagnostics(allDiagnostics); + } + function hasExtension(fileName) { + return ts.getBaseFileName(fileName).indexOf(".") >= 0; + } + function processRootFile(fileName, isDefaultLib) { + processSourceFile(ts.normalizePath(fileName), isDefaultLib); + } + function processSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd) { + if (refEnd !== undefined && refPos !== undefined) { + var start = refPos; + var length = refEnd - refPos; + } + var diagnostic; + if (hasExtension(fileName)) { + if (!options.allowNonTsExtensions && !ts.fileExtensionIs(host.getCanonicalFileName(fileName), ".ts")) { + diagnostic = ts.Diagnostics.File_0_must_have_extension_ts_or_d_ts; + } + else if (!findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd)) { + diagnostic = ts.Diagnostics.File_0_not_found; + } + else if (refFile && host.getCanonicalFileName(fileName) === host.getCanonicalFileName(refFile.fileName)) { + diagnostic = ts.Diagnostics.A_file_cannot_have_a_reference_to_itself; + } + } + else { + if (options.allowNonTsExtensions && !findSourceFile(fileName, isDefaultLib, refFile, refPos, refEnd)) { + diagnostic = ts.Diagnostics.File_0_not_found; + } + else if (!findSourceFile(fileName + ".ts", isDefaultLib, refFile, refPos, refEnd) && !findSourceFile(fileName + ".d.ts", isDefaultLib, refFile, refPos, refEnd)) { + diagnostic = ts.Diagnostics.File_0_not_found; + fileName += ".ts"; + } + } + if (diagnostic) { + if (refFile) { + diagnostics.add(ts.createFileDiagnostic(refFile, start, length, diagnostic, fileName)); + } + else { + diagnostics.add(ts.createCompilerDiagnostic(diagnostic, fileName)); + } + } + } + function findSourceFile(fileName, isDefaultLib, refFile, refStart, refLength) { + var canonicalName = host.getCanonicalFileName(fileName); + if (ts.hasProperty(filesByName, canonicalName)) { + return getSourceFileFromCache(fileName, canonicalName, false); + } + else { + var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); + var canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); + if (ts.hasProperty(filesByName, canonicalAbsolutePath)) { + return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, true); + } + var file = filesByName[canonicalName] = 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)); + } + else { + diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); + } + }); + if (file) { + seenNoDefaultLib = seenNoDefaultLib || file.hasNoDefaultLib; + filesByName[canonicalAbsolutePath] = file; + if (!options.noResolve) { + var basePath = ts.getDirectoryPath(fileName); + processReferencedFiles(file, basePath); + processImportedModules(file, basePath); + } + if (isDefaultLib) { + files.unshift(file); + } + else { + files.push(file); + } + } + } + return file; + function getSourceFileFromCache(fileName, canonicalName, useAbsolutePath) { + var file = filesByName[canonicalName]; + if (file && host.useCaseSensitiveFileNames()) { + var sourceFileName = useAbsolutePath ? ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; + if (canonicalName !== sourceFileName) { + diagnostics.add(ts.createFileDiagnostic(refFile, refStart, refLength, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, fileName, sourceFileName)); + } + } + return file; + } + } + function processReferencedFiles(file, basePath) { + ts.forEach(file.referencedFiles, function (ref) { + var referencedFileName = ts.isRootedDiskPath(ref.fileName) ? ref.fileName : ts.combinePaths(basePath, ref.fileName); + processSourceFile(ts.normalizePath(referencedFileName), false, file, ref.pos, ref.end); + }); + } + function processImportedModules(file, basePath) { + ts.forEach(file.statements, function (node) { + if (node.kind === 203 || node.kind === 202 || node.kind === 209) { + var moduleNameExpr = ts.getExternalModuleName(node); + if (moduleNameExpr && moduleNameExpr.kind === 8) { + var moduleNameText = moduleNameExpr.text; + if (moduleNameText) { + var searchPath = basePath; + while (true) { + var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleNameText)); + if (findModuleSourceFile(searchName + ".ts", moduleNameExpr) || findModuleSourceFile(searchName + ".d.ts", moduleNameExpr)) { + break; + } + var parentPath = ts.getDirectoryPath(searchPath); + if (parentPath === searchPath) { + break; + } + searchPath = parentPath; + } + } + } + } + else if (node.kind === 200 && 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) { + var nameLiteral = ts.getExternalModuleImportEqualsDeclarationExpression(node); + var moduleName = nameLiteral.text; + if (moduleName) { + var searchName = ts.normalizePath(ts.combinePaths(basePath, moduleName)); + var tsFile = findModuleSourceFile(searchName + ".ts", nameLiteral); + if (!tsFile) { + findModuleSourceFile(searchName + ".d.ts", nameLiteral); + } + } + } + }); + } + }); + function findModuleSourceFile(fileName, nameLiteral) { + return findSourceFile(fileName, false, file, nameLiteral.pos, nameLiteral.end - nameLiteral.pos); + } + } + function verifyCompilerOptions() { + if (!options.sourceMap && (options.mapRoot || options.sourceRoot)) { + if (options.mapRoot) { + diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option)); + } + if (options.sourceRoot) { + diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option)); + } + return; + } + var firstExternalModule = ts.forEach(files, function (f) { return ts.isExternalModule(f) ? f : undefined; }); + if (firstExternalModule && !options.module) { + var externalModuleErrorSpan = ts.getErrorSpanForNode(firstExternalModule.externalModuleIndicator); + var errorStart = ts.skipTrivia(firstExternalModule.text, externalModuleErrorSpan.pos); + var errorLength = externalModuleErrorSpan.end - errorStart; + diagnostics.add(ts.createFileDiagnostic(firstExternalModule, errorStart, errorLength, ts.Diagnostics.Cannot_compile_external_modules_unless_the_module_flag_is_provided)); + } + if (options.outDir || + options.sourceRoot || + (options.mapRoot && + (!options.out || firstExternalModule !== undefined))) { + var commonPathComponents; + ts.forEach(files, function (sourceFile) { + if (!(sourceFile.flags & 1024) && !ts.fileExtensionIs(sourceFile.fileName, ".js")) { + var sourcePathComponents = ts.getNormalizedPathComponents(sourceFile.fileName, host.getCurrentDirectory()); + sourcePathComponents.pop(); + if (commonPathComponents) { + for (var i = 0; i < Math.min(commonPathComponents.length, sourcePathComponents.length); i++) { + if (commonPathComponents[i] !== sourcePathComponents[i]) { + if (i === 0) { + diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files)); + return; + } + commonPathComponents.length = i; + break; + } + } + if (sourcePathComponents.length < commonPathComponents.length) { + commonPathComponents.length = sourcePathComponents.length; + } + } + else { + commonPathComponents = sourcePathComponents; + } + } + }); + commonSourceDirectory = ts.getNormalizedPathFromPathComponents(commonPathComponents); + if (commonSourceDirectory) { + commonSourceDirectory += ts.directorySeparator; + } + } + if (options.noEmit) { + if (options.out || options.outDir) { + diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_noEmit_cannot_be_specified_with_option_out_or_outDir)); + } + if (options.declaration) { + diagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_noEmit_cannot_be_specified_with_option_declaration)); + } + } + } + } + ts.createProgram = createProgram; +})(ts || (ts = {})); +var ts; +(function (ts) { + var BreakpointResolver; + (function (BreakpointResolver) { + function spanInSourceFileAtLocation(sourceFile, position) { + if (sourceFile.flags & 1024) { + return undefined; + } + var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position); + var lineOfPosition = sourceFile.getLineAndCharacterOfPosition(position).line; + if (sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getStart()).line > lineOfPosition) { + tokenAtLocation = ts.findPrecedingToken(tokenAtLocation.pos, sourceFile); + if (!tokenAtLocation || sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getEnd()).line !== lineOfPosition) { + return undefined; + } + } + if (ts.isInAmbientContext(tokenAtLocation)) { + return undefined; + } + return spanInNode(tokenAtLocation); + function textSpan(startNode, endNode) { + return ts.createTextSpanFromBounds(startNode.getStart(), (endNode || startNode).getEnd()); + } + function spanInNodeIfStartsOnSameLine(node, otherwiseOnNode) { + if (node && lineOfPosition === sourceFile.getLineAndCharacterOfPosition(node.getStart()).line) { + return spanInNode(node); + } + return spanInNode(otherwiseOnNode); + } + function spanInPreviousNode(node) { + return spanInNode(ts.findPrecedingToken(node.pos, sourceFile)); + } + function spanInNextNode(node) { + return spanInNode(ts.findNextToken(node, node.parent)); + } + function spanInNode(node) { + if (node) { + if (ts.isExpression(node)) { + if (node.parent.kind === 179) { + return spanInPreviousNode(node); + } + if (node.parent.kind === 181) { + return textSpan(node); + } + if (node.parent.kind === 167 && node.parent.operatorToken.kind === 23) { + return textSpan(node); + } + if (node.parent.kind == 161 && node.parent.body == node) { + return textSpan(node); + } + } + switch (node.kind) { + case 175: + return spanInVariableDeclaration(node.declarationList.declarations[0]); + case 193: + case 130: + case 129: + return spanInVariableDeclaration(node); + case 128: + return spanInParameterDeclaration(node); + case 195: + case 132: + case 131: + case 134: + case 135: + case 133: + case 160: + case 161: + return spanInFunctionDeclaration(node); + case 174: + if (ts.isFunctionBlock(node)) { + return spanInFunctionBlock(node); + } + case 201: + return spanInBlock(node); + case 216: + return spanInBlock(node.block); + case 177: + return textSpan(node.expression); + case 186: + return textSpan(node.getChildAt(0), node.expression); + case 180: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 179: + return spanInNode(node.statement); + case 192: + return textSpan(node.getChildAt(0)); + case 178: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 189: + return spanInNode(node.statement); + case 185: + case 184: + return textSpan(node.getChildAt(0), node.label); + case 181: + return spanInForStatement(node); + case 182: + case 183: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 188: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 213: + case 214: + return spanInNode(node.statements[0]); + case 191: + return spanInBlock(node.tryBlock); + case 190: + return textSpan(node, node.expression); + case 208: + return textSpan(node, node.exportName); + case 202: + return textSpan(node, node.moduleReference); + case 200: + if (ts.getModuleInstanceState(node) !== 1) { + return undefined; + } + case 196: + case 199: + case 219: + case 155: + case 156: + return textSpan(node); + case 187: + return spanInNode(node.statement); + case 197: + case 198: + return undefined; + case 22: + case 1: + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile)); + case 23: + return spanInPreviousNode(node); + case 14: + return spanInOpenBraceToken(node); + case 15: + return spanInCloseBraceToken(node); + case 16: + return spanInOpenParenToken(node); + case 17: + return spanInCloseParenToken(node); + case 51: + return spanInColonToken(node); + case 25: + case 24: + return spanInGreaterThanOrLessThanToken(node); + case 99: + return spanInWhileKeyword(node); + case 75: + case 67: + case 80: + return spanInNextNode(node); + default: + if (node.parent.kind === 217 && node.parent.name === node) { + return spanInNode(node.parent.initializer); + } + if (node.parent.kind === 158 && node.parent.type === node) { + return spanInNode(node.parent.expression); + } + if (ts.isAnyFunction(node.parent) && node.parent.type === node) { + return spanInPreviousNode(node); + } + return spanInNode(node.parent); + } + } + function spanInVariableDeclaration(variableDeclaration) { + if (variableDeclaration.parent.parent.kind === 182 || + variableDeclaration.parent.parent.kind === 183) { + return spanInNode(variableDeclaration.parent.parent); + } + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 175; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 181 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement ? variableDeclaration.parent.parent.initializer.declarations : undefined; + if (variableDeclaration.initializer || (variableDeclaration.flags & 1)) { + if (declarations && declarations[0] === variableDeclaration) { + if (isParentVariableStatement) { + return textSpan(variableDeclaration.parent, variableDeclaration); + } + else { + ts.Debug.assert(isDeclarationOfForStatement); + return textSpan(ts.findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration); + } + } + else { + return textSpan(variableDeclaration); + } + } + else if (declarations && declarations[0] !== variableDeclaration) { + var indexOfCurrentDeclaration = ts.indexOf(declarations, variableDeclaration); + return spanInVariableDeclaration(declarations[indexOfCurrentDeclaration - 1]); + } + } + function canHaveSpanInParameterDeclaration(parameter) { + return !!parameter.initializer || parameter.dotDotDotToken !== undefined || + !!(parameter.flags & 16) || !!(parameter.flags & 32); + } + function spanInParameterDeclaration(parameter) { + if (canHaveSpanInParameterDeclaration(parameter)) { + return textSpan(parameter); + } + else { + var functionDeclaration = parameter.parent; + var indexOfParameter = ts.indexOf(functionDeclaration.parameters, parameter); + if (indexOfParameter) { + return spanInParameterDeclaration(functionDeclaration.parameters[indexOfParameter - 1]); + } + else { + return spanInNode(functionDeclaration.body); + } + } + } + function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { + return !!(functionDeclaration.flags & 1) || + (functionDeclaration.parent.kind === 196 && functionDeclaration.kind !== 133); + } + function spanInFunctionDeclaration(functionDeclaration) { + if (!functionDeclaration.body) { + return undefined; + } + if (canFunctionHaveSpanInWholeDeclaration(functionDeclaration)) { + return textSpan(functionDeclaration); + } + return spanInNode(functionDeclaration.body); + } + function spanInFunctionBlock(block) { + var nodeForSpanInBlock = block.statements.length ? block.statements[0] : block.getLastToken(); + if (canFunctionHaveSpanInWholeDeclaration(block.parent)) { + return spanInNodeIfStartsOnSameLine(block.parent, nodeForSpanInBlock); + } + return spanInNode(nodeForSpanInBlock); + } + function spanInBlock(block) { + switch (block.parent.kind) { + case 200: + if (ts.getModuleInstanceState(block.parent) !== 1) { + return undefined; + } + case 180: + case 178: + case 182: + case 183: + return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); + case 181: + 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 === 194) { + var variableDeclarationList = forStatement.initializer; + if (variableDeclarationList.declarations.length > 0) { + return spanInNode(variableDeclarationList.declarations[0]); + } + } + else { + return spanInNode(forStatement.initializer); + } + } + if (forStatement.condition) { + return textSpan(forStatement.condition); + } + if (forStatement.iterator) { + return textSpan(forStatement.iterator); + } + } + function spanInOpenBraceToken(node) { + switch (node.parent.kind) { + case 199: + var enumDeclaration = node.parent; + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); + case 196: + var classDeclaration = node.parent; + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); + case 188: + return spanInNodeIfStartsOnSameLine(node.parent, node.parent.clauses[0]); + } + return spanInNode(node.parent); + } + function spanInCloseBraceToken(node) { + switch (node.parent.kind) { + case 201: + if (ts.getModuleInstanceState(node.parent.parent) !== 1) { + return undefined; + } + case 199: + case 196: + return textSpan(node); + case 174: + if (ts.isFunctionBlock(node.parent)) { + return textSpan(node); + } + case 216: + return spanInNode(node.parent.statements[node.parent.statements.length - 1]); + ; + case 188: + var switchStatement = node.parent; + var lastClause = switchStatement.clauses[switchStatement.clauses.length - 1]; + if (lastClause) { + return spanInNode(lastClause.statements[lastClause.statements.length - 1]); + } + return undefined; + default: + return spanInNode(node.parent); + } + } + function spanInOpenParenToken(node) { + if (node.parent.kind === 179) { + return spanInPreviousNode(node); + } + return spanInNode(node.parent); + } + function spanInCloseParenToken(node) { + switch (node.parent.kind) { + case 160: + case 195: + case 161: + case 132: + case 131: + case 134: + case 135: + case 133: + case 180: + case 179: + case 181: + return spanInPreviousNode(node); + default: + return spanInNode(node.parent); + } + return spanInNode(node.parent); + } + function spanInColonToken(node) { + if (ts.isAnyFunction(node.parent) || node.parent.kind === 217) { + return spanInPreviousNode(node); + } + return spanInNode(node.parent); + } + function spanInGreaterThanOrLessThanToken(node) { + if (node.parent.kind === 158) { + return spanInNode(node.parent.expression); + } + return spanInNode(node.parent); + } + function spanInWhileKeyword(node) { + if (node.parent.kind === 179) { + return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); + } + return spanInNode(node.parent); + } + } + } + BreakpointResolver.spanInSourceFileAtLocation = spanInSourceFileAtLocation; + })(BreakpointResolver = ts.BreakpointResolver || (ts.BreakpointResolver = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var OutliningElementsCollector; + (function (OutliningElementsCollector) { + function collectElements(sourceFile) { + var elements = []; + var collapseText = "..."; + function addOutliningSpan(hintSpanNode, startElement, endElement, autoCollapse) { + if (hintSpanNode && startElement && endElement) { + var span = { + textSpan: ts.createTextSpanFromBounds(startElement.pos, endElement.end), + hintSpan: ts.createTextSpanFromBounds(hintSpanNode.getStart(), hintSpanNode.end), + bannerText: collapseText, + autoCollapse: autoCollapse + }; + elements.push(span); + } + } + function autoCollapse(node) { + return ts.isFunctionBlock(node) && node.parent.kind !== 161; + } + var depth = 0; + var maxDepth = 20; + function walk(n) { + if (depth > maxDepth) { + return; + } + switch (n.kind) { + case 174: + if (!ts.isFunctionBlock(n)) { + var parent = n.parent; + var openBrace = ts.findChildOfKind(n, 14, sourceFile); + var closeBrace = ts.findChildOfKind(n, 15, sourceFile); + if (parent.kind === 179 || + parent.kind === 182 || + parent.kind === 183 || + parent.kind === 181 || + parent.kind === 178 || + parent.kind === 180 || + parent.kind === 187 || + parent.kind === 216) { + addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n)); + break; + } + if (parent.kind === 191) { + var tryStatement = parent; + if (tryStatement.tryBlock === n) { + addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n)); + break; + } + else if (tryStatement.finallyBlock === n) { + var finallyKeyword = ts.findChildOfKind(tryStatement, 80, sourceFile); + if (finallyKeyword) { + addOutliningSpan(finallyKeyword, openBrace, closeBrace, autoCollapse(n)); + break; + } + } + } + var span = ts.createTextSpanFromBounds(n.getStart(), n.end); + elements.push({ + textSpan: span, + hintSpan: span, + bannerText: collapseText, + autoCollapse: autoCollapse(n) + }); + break; + } + case 201: + var openBrace = ts.findChildOfKind(n, 14, sourceFile); + var closeBrace = ts.findChildOfKind(n, 15, sourceFile); + addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); + break; + case 196: + case 197: + case 199: + case 152: + case 188: + var openBrace = ts.findChildOfKind(n, 14, sourceFile); + var closeBrace = ts.findChildOfKind(n, 15, sourceFile); + addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); + break; + case 151: + var openBracket = ts.findChildOfKind(n, 18, sourceFile); + var closeBracket = ts.findChildOfKind(n, 19, sourceFile); + addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); + break; + } + depth++; + ts.forEachChild(n, walk); + depth--; + } + walk(sourceFile); + return elements; + } + OutliningElementsCollector.collectElements = collectElements; + })(OutliningElementsCollector = ts.OutliningElementsCollector || (ts.OutliningElementsCollector = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var NavigateTo; + (function (NavigateTo) { + function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) { + var patternMatcher = ts.createPatternMatcher(searchValue); + var rawItems = []; + ts.forEach(program.getSourceFiles(), function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + var declarations = sourceFile.getNamedDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + var declaration = declarations[i]; + var name = getDeclarationName(declaration); + if (name !== undefined) { + var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name); + if (!matches) { + continue; + } + if (patternMatcher.patternContainsDots) { + var containers = getContainers(declaration); + if (!containers) { + return undefined; + } + matches = patternMatcher.getMatches(containers, name); + if (!matches) { + continue; + } + } + var fileName = sourceFile.fileName; + var matchKind = bestMatchKind(matches); + rawItems.push({ name: name, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); + } + } + }); + rawItems.sort(compareNavigateToItems); + if (maxResultCount !== undefined) { + rawItems = rawItems.slice(0, maxResultCount); + } + var items = ts.map(rawItems, createNavigateToItem); + return items; + function allMatchesAreCaseSensitive(matches) { + ts.Debug.assert(matches.length > 0); + for (var i = 0, n = matches.length; i < n; i++) { + if (!matches[i].isCaseSensitive) { + return false; + } + } + return true; + } + function getDeclarationName(declaration) { + var result = getTextOfIdentifierOrLiteral(declaration.name); + if (result !== undefined) { + return result; + } + if (declaration.name.kind === 126) { + var expr = declaration.name.expression; + if (expr.kind === 153) { + return expr.name.text; + } + return getTextOfIdentifierOrLiteral(expr); + } + return undefined; + } + function getTextOfIdentifierOrLiteral(node) { + if (node.kind === 64 || + node.kind === 8 || + node.kind === 7) { + return node.text; + } + return undefined; + } + function tryAddSingleDeclarationName(declaration, containers) { + if (declaration && declaration.name) { + var text = getTextOfIdentifierOrLiteral(declaration.name); + if (text !== undefined) { + containers.unshift(text); + } + else if (declaration.name.kind === 126) { + return tryAddComputedPropertyName(declaration.name.expression, containers, true); + } + else { + return false; + } + } + return true; + } + function tryAddComputedPropertyName(expression, containers, includeLastPortion) { + var text = getTextOfIdentifierOrLiteral(expression); + if (text !== undefined) { + if (includeLastPortion) { + containers.unshift(text); + } + return true; + } + if (expression.kind === 153) { + var propertyAccess = expression; + if (includeLastPortion) { + containers.unshift(propertyAccess.name.text); + } + return tryAddComputedPropertyName(propertyAccess.expression, containers, true); + } + return false; + } + function getContainers(declaration) { + var containers = []; + if (declaration.name.kind === 126) { + if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { + return undefined; + } + } + declaration = ts.getContainerNode(declaration); + while (declaration) { + if (!tryAddSingleDeclarationName(declaration, containers)) { + return undefined; + } + declaration = ts.getContainerNode(declaration); + } + return containers; + } + function bestMatchKind(matches) { + ts.Debug.assert(matches.length > 0); + var bestMatchKind = 3; + for (var i = 0, n = matches.length; i < n; i++) { + var kind = matches[i].kind; + if (kind < bestMatchKind) { + bestMatchKind = kind; + } + } + return bestMatchKind; + } + var baseSensitivity = { sensitivity: "base" }; + function compareNavigateToItems(i1, i2) { + return i1.matchKind - i2.matchKind || + i1.name.localeCompare(i2.name, undefined, baseSensitivity) || + i1.name.localeCompare(i2.name); + } + function createNavigateToItem(rawItem) { + var declaration = rawItem.declaration; + var container = ts.getContainerNode(declaration); + return { + name: rawItem.name, + kind: ts.getNodeKind(declaration), + kindModifiers: ts.getNodeModifiers(declaration), + matchKind: ts.PatternMatchKind[rawItem.matchKind], + isCaseSensitive: rawItem.isCaseSensitive, + fileName: rawItem.fileName, + textSpan: ts.createTextSpanFromBounds(declaration.getStart(), declaration.getEnd()), + containerName: container && container.name ? container.name.text : "", + containerKind: container && container.name ? ts.getNodeKind(container) : "" + }; + } + } + NavigateTo.getNavigateToItems = getNavigateToItems; + })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var NavigationBar; + (function (NavigationBar) { + function getNavigationBarItems(sourceFile) { + var hasGlobalNode = false; + return getItemsWorker(getTopLevelNodes(sourceFile), createTopLevelItem); + function getIndent(node) { + var indent = hasGlobalNode ? 1 : 0; + var current = node.parent; + while (current) { + switch (current.kind) { + case 200: + do { + current = current.parent; + } while (current.kind === 200); + case 196: + case 199: + case 197: + case 195: + indent++; + } + current = current.parent; + } + return indent; + } + function getChildNodes(nodes) { + var childNodes = []; + function visit(node) { + switch (node.kind) { + case 175: + ts.forEach(node.declarationList.declarations, visit); + break; + case 148: + case 149: + ts.forEach(node.elements, visit); + break; + case 150: + case 193: + if (ts.isBindingPattern(node.name)) { + visit(node.name); + break; + } + case 196: + case 199: + case 197: + case 200: + case 195: + childNodes.push(node); + } + } + ts.forEach(nodes, visit); + return sortNodes(childNodes); + } + function getTopLevelNodes(node) { + var topLevelNodes = []; + topLevelNodes.push(node); + addTopLevelNodes(node.statements, topLevelNodes); + return topLevelNodes; + } + function sortNodes(nodes) { + return nodes.slice(0).sort(function (n1, n2) { + if (n1.name && n2.name) { + return ts.getPropertyNameForPropertyNameNode(n1.name).localeCompare(ts.getPropertyNameForPropertyNameNode(n2.name)); + } + else if (n1.name) { + return 1; + } + else if (n2.name) { + return -1; + } + else { + return n1.kind - n2.kind; + } + }); + } + function addTopLevelNodes(nodes, topLevelNodes) { + nodes = sortNodes(nodes); + for (var i = 0, n = nodes.length; i < n; i++) { + var node = nodes[i]; + switch (node.kind) { + case 196: + case 199: + case 197: + topLevelNodes.push(node); + break; + case 200: + var moduleDeclaration = node; + topLevelNodes.push(node); + addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); + break; + case 195: + var functionDeclaration = node; + if (isTopLevelFunctionDeclaration(functionDeclaration)) { + topLevelNodes.push(node); + addTopLevelNodes(functionDeclaration.body.statements, topLevelNodes); + } + break; + } + } + } + function isTopLevelFunctionDeclaration(functionDeclaration) { + if (functionDeclaration.kind === 195) { + if (functionDeclaration.body && functionDeclaration.body.kind === 174) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 195 && !isEmpty(s.name.text); })) { + return true; + } + if (!ts.isFunctionBlock(functionDeclaration.parent)) { + return true; + } + } + } + return false; + } + function getItemsWorker(nodes, createItem) { + var items = []; + var keyToItem = {}; + for (var i = 0, n = nodes.length; i < n; i++) { + var child = nodes[i]; + var item = createItem(child); + if (item !== undefined) { + if (item.text.length > 0) { + var key = item.text + "-" + item.kind + "-" + item.indent; + var itemWithSameName = keyToItem[key]; + if (itemWithSameName) { + merge(itemWithSameName, item); + } + else { + keyToItem[key] = item; + items.push(item); + } + } + } + } + return items; + } + function merge(target, source) { + target.spans.push.apply(target.spans, source.spans); + if (source.childItems) { + if (!target.childItems) { + target.childItems = []; + } + outer: for (var i = 0, n = source.childItems.length; i < n; i++) { + var sourceChild = source.childItems[i]; + for (var j = 0, m = target.childItems.length; j < m; j++) { + var targetChild = target.childItems[j]; + if (targetChild.text === sourceChild.text && targetChild.kind === sourceChild.kind) { + merge(targetChild, sourceChild); + continue outer; + } + } + target.childItems.push(sourceChild); + } + } + } + function createChildItem(node) { + switch (node.kind) { + case 128: + if (ts.isBindingPattern(node.name)) { + break; + } + if ((node.flags & 243) === 0) { + return undefined; + } + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 132: + case 131: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); + case 134: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); + case 135: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); + case 138: + return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); + case 219: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 136: + return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); + case 137: + return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); + case 130: + case 129: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 195: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); + case 193: + case 150: + var variableDeclarationNode; + var name; + if (node.kind === 150) { + name = node.name; + variableDeclarationNode = node; + while (variableDeclarationNode && variableDeclarationNode.kind !== 193) { + variableDeclarationNode = variableDeclarationNode.parent; + } + ts.Debug.assert(variableDeclarationNode !== undefined); + } + else { + ts.Debug.assert(!ts.isBindingPattern(node.name)); + variableDeclarationNode = node; + name = node.name; + } + if (ts.isConst(variableDeclarationNode)) { + return createItem(node, getTextOfNode(name), ts.ScriptElementKind.constElement); + } + else if (ts.isLet(variableDeclarationNode)) { + return createItem(node, getTextOfNode(name), ts.ScriptElementKind.letElement); + } + else { + return createItem(node, getTextOfNode(name), ts.ScriptElementKind.variableElement); + } + case 133: + return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); + } + return undefined; + function createItem(node, name, scriptElementKind) { + return getNavigationBarItem(name, scriptElementKind, ts.getNodeModifiers(node), [getNodeSpan(node)]); + } + } + function isEmpty(text) { + return !text || text.trim() === ""; + } + function getNavigationBarItem(text, kind, kindModifiers, spans, childItems, indent) { + if (childItems === void 0) { childItems = []; } + if (indent === void 0) { indent = 0; } + if (isEmpty(text)) { + return undefined; + } + return { + text: text, + kind: kind, + kindModifiers: kindModifiers, + spans: spans, + childItems: childItems, + indent: indent, + bolded: false, + grayed: false + }; + } + function createTopLevelItem(node) { + switch (node.kind) { + case 220: + return createSourceFileItem(node); + case 196: + return createClassItem(node); + case 199: + return createEnumItem(node); + case 197: + return createIterfaceItem(node); + case 200: + return createModuleItem(node); + case 195: + return createFunctionItem(node); + } + return undefined; + function getModuleName(moduleDeclaration) { + if (moduleDeclaration.name.kind === 8) { + return getTextOfNode(moduleDeclaration.name); + } + var result = []; + result.push(moduleDeclaration.name.text); + while (moduleDeclaration.body && moduleDeclaration.body.kind === 200) { + moduleDeclaration = moduleDeclaration.body; + result.push(moduleDeclaration.name.text); + } + return result.join("."); + } + function createModuleItem(node) { + var moduleName = getModuleName(node); + var childItems = getItemsWorker(getChildNodes(getInnermostModule(node).body.statements), createChildItem); + return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); + } + function createFunctionItem(node) { + if (node.name && node.body && node.body.kind === 174) { + var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); + return getNavigationBarItem(node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); + } + return undefined; + } + function createSourceFileItem(node) { + var childItems = getItemsWorker(getChildNodes(node.statements), createChildItem); + if (childItems === undefined || childItems.length === 0) { + return undefined; + } + hasGlobalNode = true; + var rootName = ts.isExternalModule(node) ? "\"" + ts.escapeString(ts.getBaseFileName(ts.removeFileExtension(ts.normalizePath(node.fileName)))) + "\"" : ""; + return getNavigationBarItem(rootName, ts.ScriptElementKind.moduleElement, ts.ScriptElementKindModifier.none, [getNodeSpan(node)], childItems); + } + function createClassItem(node) { + var childItems; + if (node.members) { + var constructor = ts.forEach(node.members, function (member) { + return member.kind === 133 && member; + }); + var nodes = removeDynamicallyNamedProperties(node); + if (constructor) { + nodes.push.apply(nodes, ts.filter(constructor.parameters, function (p) { return !ts.isBindingPattern(p.name); })); + } + var childItems = getItemsWorker(sortNodes(nodes), createChildItem); + } + return getNavigationBarItem(node.name.text, ts.ScriptElementKind.classElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); + } + function createEnumItem(node) { + var childItems = getItemsWorker(sortNodes(removeComputedProperties(node)), createChildItem); + return getNavigationBarItem(node.name.text, ts.ScriptElementKind.enumElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); + } + function createIterfaceItem(node) { + var childItems = getItemsWorker(sortNodes(removeDynamicallyNamedProperties(node)), createChildItem); + return getNavigationBarItem(node.name.text, ts.ScriptElementKind.interfaceElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); + } + } + function removeComputedProperties(node) { + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 126; }); + } + function removeDynamicallyNamedProperties(node) { + return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); + } + function getInnermostModule(node) { + while (node.body.kind === 200) { + node = node.body; + } + return node; + } + function getNodeSpan(node) { + return node.kind === 220 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); + } + function getTextOfNode(node) { + return ts.getTextOfNodeFromSourceText(sourceFile.text, node); + } + } + NavigationBar.getNavigationBarItems = getNavigationBarItems; + })(NavigationBar = ts.NavigationBar || (ts.NavigationBar = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + (function (PatternMatchKind) { + PatternMatchKind[PatternMatchKind["exact"] = 0] = "exact"; + PatternMatchKind[PatternMatchKind["prefix"] = 1] = "prefix"; + PatternMatchKind[PatternMatchKind["substring"] = 2] = "substring"; + PatternMatchKind[PatternMatchKind["camelCase"] = 3] = "camelCase"; + })(ts.PatternMatchKind || (ts.PatternMatchKind = {})); + var PatternMatchKind = ts.PatternMatchKind; + function createPatternMatch(kind, punctuationStripped, isCaseSensitive, camelCaseWeight) { + return { + kind: kind, + punctuationStripped: punctuationStripped, + isCaseSensitive: isCaseSensitive, + camelCaseWeight: camelCaseWeight + }; + } + function createPatternMatcher(pattern) { + var stringToWordSpans = {}; + pattern = pattern.trim(); + var fullPatternSegment = createSegment(pattern); + var dotSeparatedSegments = pattern.split(".").map(function (p) { return createSegment(p.trim()); }); + var invalidPattern = dotSeparatedSegments.length === 0 || ts.forEach(dotSeparatedSegments, segmentIsInvalid); + return { + getMatches: getMatches, + getMatchesForLastSegmentOfPattern: getMatchesForLastSegmentOfPattern, + patternContainsDots: dotSeparatedSegments.length > 1 + }; + function skipMatch(candidate) { + return invalidPattern || !candidate; + } + function getMatchesForLastSegmentOfPattern(candidate) { + if (skipMatch(candidate)) { + return undefined; + } + return matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments)); + } + function getMatches(candidateContainers, candidate) { + if (skipMatch(candidate)) { + return undefined; + } + var candidateMatch = matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments)); + if (!candidateMatch) { + return undefined; + } + candidateContainers = candidateContainers || []; + if (dotSeparatedSegments.length - 1 > candidateContainers.length) { + return undefined; + } + var totalMatch = candidateMatch; + for (var i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i--, j--) { + var segment = dotSeparatedSegments[i]; + var containerName = candidateContainers[j]; + var containerMatch = matchSegment(containerName, segment); + if (!containerMatch) { + return undefined; + } + ts.addRange(totalMatch, containerMatch); + } + return totalMatch; + } + function getWordSpans(word) { + if (!ts.hasProperty(stringToWordSpans, word)) { + stringToWordSpans[word] = breakIntoWordSpans(word); + } + return stringToWordSpans[word]; + } + function matchTextChunk(candidate, chunk, punctuationStripped) { + var index = indexOfIgnoringCase(candidate, chunk.textLowerCase); + if (index === 0) { + if (chunk.text.length === candidate.length) { + return createPatternMatch(0, punctuationStripped, candidate === chunk.text); + } + else { + return createPatternMatch(1, punctuationStripped, startsWith(candidate, chunk.text)); + } + } + var isLowercase = chunk.isLowerCase; + if (isLowercase) { + if (index > 0) { + var wordSpans = getWordSpans(candidate); + for (var i = 0, n = wordSpans.length; i < n; i++) { + var span = wordSpans[i]; + if (partStartsWith(candidate, span, chunk.text, true)) { + return createPatternMatch(2, punctuationStripped, partStartsWith(candidate, span, chunk.text, false)); + } + } + } + } + else { + if (candidate.indexOf(chunk.text) > 0) { + return createPatternMatch(2, punctuationStripped, true); + } + } + if (!isLowercase) { + if (chunk.characterSpans.length > 0) { + var candidateParts = getWordSpans(candidate); + var camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, false); + if (camelCaseWeight !== undefined) { + return createPatternMatch(3, punctuationStripped, true, camelCaseWeight); + } + camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, true); + if (camelCaseWeight !== undefined) { + return createPatternMatch(3, punctuationStripped, false, camelCaseWeight); + } + } + } + if (isLowercase) { + if (chunk.text.length < candidate.length) { + if (index > 0 && isUpperCaseLetter(candidate.charCodeAt(index))) { + return createPatternMatch(2, punctuationStripped, false); + } + } + } + return undefined; + } + function containsSpaceOrAsterisk(text) { + for (var i = 0; i < text.length; i++) { + var ch = text.charCodeAt(i); + if (ch === 32 || ch === 42) { + return true; + } + } + return false; + } + function matchSegment(candidate, segment) { + if (!containsSpaceOrAsterisk(segment.totalTextChunk.text)) { + var match = matchTextChunk(candidate, segment.totalTextChunk, false); + if (match) { + return [match]; + } + } + var subWordTextChunks = segment.subWordTextChunks; + var matches = undefined; + for (var i = 0, n = subWordTextChunks.length; i < n; i++) { + var subWordTextChunk = subWordTextChunks[i]; + var result = matchTextChunk(candidate, subWordTextChunk, true); + if (!result) { + return undefined; + } + matches = matches || []; + matches.push(result); + } + return matches; + } + function partStartsWith(candidate, candidateSpan, pattern, ignoreCase, patternSpan) { + var patternPartStart = patternSpan ? patternSpan.start : 0; + var patternPartLength = patternSpan ? patternSpan.length : pattern.length; + if (patternPartLength > candidateSpan.length) { + return false; + } + if (ignoreCase) { + for (var i = 0; i < patternPartLength; i++) { + var ch1 = pattern.charCodeAt(patternPartStart + i); + var ch2 = candidate.charCodeAt(candidateSpan.start + i); + if (toLowerCase(ch1) !== toLowerCase(ch2)) { + return false; + } + } + } + else { + for (var i = 0; i < patternPartLength; i++) { + var ch1 = pattern.charCodeAt(patternPartStart + i); + var ch2 = candidate.charCodeAt(candidateSpan.start + i); + if (ch1 !== ch2) { + return false; + } + } + } + return true; + } + function tryCamelCaseMatch(candidate, candidateParts, chunk, ignoreCase) { + var chunkCharacterSpans = chunk.characterSpans; + var currentCandidate = 0; + var currentChunkSpan = 0; + var firstMatch = undefined; + var contiguous = undefined; + while (true) { + if (currentChunkSpan === chunkCharacterSpans.length) { + var weight = 0; + if (contiguous) { + weight += 1; + } + if (firstMatch === 0) { + weight += 2; + } + return weight; + } + else if (currentCandidate === candidateParts.length) { + return undefined; + } + var candidatePart = candidateParts[currentCandidate]; + var gotOneMatchThisCandidate = false; + for (; currentChunkSpan < chunkCharacterSpans.length; currentChunkSpan++) { + var chunkCharacterSpan = chunkCharacterSpans[currentChunkSpan]; + if (gotOneMatchThisCandidate) { + if (!isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan - 1].start)) || + !isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan].start))) { + break; + } + } + if (!partStartsWith(candidate, candidatePart, chunk.text, ignoreCase, chunkCharacterSpan)) { + break; + } + gotOneMatchThisCandidate = true; + firstMatch = firstMatch === undefined ? currentCandidate : firstMatch; + contiguous = contiguous === undefined ? true : contiguous; + candidatePart = ts.createTextSpan(candidatePart.start + chunkCharacterSpan.length, candidatePart.length - chunkCharacterSpan.length); + } + if (!gotOneMatchThisCandidate && contiguous !== undefined) { + contiguous = false; + } + currentCandidate++; + } + } + } + ts.createPatternMatcher = createPatternMatcher; + function patternMatchCompareTo(match1, match2) { + return compareType(match1, match2) || + compareCamelCase(match1, match2) || + compareCase(match1, match2) || + comparePunctuation(match1, match2); + } + function comparePunctuation(result1, result2) { + if (result1.punctuationStripped !== result2.punctuationStripped) { + return result1.punctuationStripped ? 1 : -1; + } + return 0; + } + function compareCase(result1, result2) { + if (result1.isCaseSensitive !== result2.isCaseSensitive) { + return result1.isCaseSensitive ? -1 : 1; + } + return 0; + } + function compareType(result1, result2) { + return result1.kind - result2.kind; + } + function compareCamelCase(result1, result2) { + if (result1.kind === 3 && result2.kind === 3) { + return result2.camelCaseWeight - result1.camelCaseWeight; + } + return 0; + } + function createSegment(text) { + return { + totalTextChunk: createTextChunk(text), + subWordTextChunks: breakPatternIntoTextChunks(text) + }; + } + function segmentIsInvalid(segment) { + return segment.subWordTextChunks.length === 0; + } + function isUpperCaseLetter(ch) { + if (ch >= 65 && ch <= 90) { + return true; + } + if (ch < 127 || !ts.isUnicodeIdentifierStart(ch, 2)) { + return false; + } + var str = String.fromCharCode(ch); + return str === str.toUpperCase(); + } + function isLowerCaseLetter(ch) { + if (ch >= 97 && ch <= 122) { + return true; + } + if (ch < 127 || !ts.isUnicodeIdentifierStart(ch, 2)) { + return false; + } + var str = String.fromCharCode(ch); + return str === str.toLowerCase(); + } + function containsUpperCaseLetter(string) { + for (var i = 0, n = string.length; i < n; i++) { + if (isUpperCaseLetter(string.charCodeAt(i))) { + return true; + } + } + return false; + } + function startsWith(string, search) { + for (var i = 0, n = search.length; i < n; i++) { + if (string.charCodeAt(i) !== search.charCodeAt(i)) { + return false; + } + } + return true; + } + function indexOfIgnoringCase(string, value) { + for (var i = 0, n = string.length - value.length; i <= n; i++) { + if (startsWithIgnoringCase(string, value, i)) { + return i; + } + } + return -1; + } + function startsWithIgnoringCase(string, value, start) { + for (var i = 0, n = value.length; i < n; i++) { + var ch1 = toLowerCase(string.charCodeAt(i + start)); + var ch2 = value.charCodeAt(i); + if (ch1 !== ch2) { + return false; + } + } + return true; + } + function toLowerCase(ch) { + if (ch >= 65 && ch <= 90) { + return 97 + (ch - 65); + } + if (ch < 127) { + return ch; + } + return String.fromCharCode(ch).toLowerCase().charCodeAt(0); + } + function isDigit(ch) { + return ch >= 48 && ch <= 57; + } + function isWordChar(ch) { + return isUpperCaseLetter(ch) || isLowerCaseLetter(ch) || isDigit(ch) || ch === 95 || ch === 36; + } + function breakPatternIntoTextChunks(pattern) { + var result = []; + var wordStart = 0; + var wordLength = 0; + for (var i = 0; i < pattern.length; i++) { + var ch = pattern.charCodeAt(i); + if (isWordChar(ch)) { + if (wordLength++ === 0) { + wordStart = i; + } + } + else { + if (wordLength > 0) { + result.push(createTextChunk(pattern.substr(wordStart, wordLength))); + wordLength = 0; + } + } + } + if (wordLength > 0) { + result.push(createTextChunk(pattern.substr(wordStart, wordLength))); + } + return result; + } + function createTextChunk(text) { + var textLowerCase = text.toLowerCase(); + return { + text: text, + textLowerCase: textLowerCase, + isLowerCase: text === textLowerCase, + characterSpans: breakIntoCharacterSpans(text) + }; + } + function breakIntoCharacterSpans(identifier) { + return breakIntoSpans(identifier, false); + } + ts.breakIntoCharacterSpans = breakIntoCharacterSpans; + function breakIntoWordSpans(identifier) { + return breakIntoSpans(identifier, true); + } + ts.breakIntoWordSpans = breakIntoWordSpans; + function breakIntoSpans(identifier, word) { + var result = []; + var wordStart = 0; + for (var i = 1, n = identifier.length; i < n; i++) { + var lastIsDigit = isDigit(identifier.charCodeAt(i - 1)); + var currentIsDigit = isDigit(identifier.charCodeAt(i)); + var hasTransitionFromLowerToUpper = transitionFromLowerToUpper(identifier, word, i); + var hasTransitionFromUpperToLower = transitionFromUpperToLower(identifier, word, i, wordStart); + if (charIsPunctuation(identifier.charCodeAt(i - 1)) || + charIsPunctuation(identifier.charCodeAt(i)) || + lastIsDigit != currentIsDigit || + hasTransitionFromLowerToUpper || + hasTransitionFromUpperToLower) { + if (!isAllPunctuation(identifier, wordStart, i)) { + result.push(ts.createTextSpan(wordStart, i - wordStart)); + } + wordStart = i; + } + } + if (!isAllPunctuation(identifier, wordStart, identifier.length)) { + result.push(ts.createTextSpan(wordStart, identifier.length - wordStart)); + } + return result; + } + function charIsPunctuation(ch) { + switch (ch) { + case 33: + case 34: + case 35: + case 37: + case 38: + case 39: + case 40: + case 41: + case 42: + case 44: + case 45: + case 46: + case 47: + case 58: + case 59: + case 63: + case 64: + case 91: + case 92: + case 93: + case 95: + case 123: + case 125: + return true; + } + return false; + } + function isAllPunctuation(identifier, start, end) { + for (var i = start; i < end; i++) { + var ch = identifier.charCodeAt(i); + if (!charIsPunctuation(ch) || ch === 95 || ch === 36) { + return false; + } + } + return true; + } + function transitionFromUpperToLower(identifier, word, index, wordStart) { + if (word) { + if (index != wordStart && + index + 1 < identifier.length) { + var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); + var nextIsLower = isLowerCaseLetter(identifier.charCodeAt(index + 1)); + if (currentIsUpper && nextIsLower) { + for (var i = wordStart; i < index; i++) { + if (!isUpperCaseLetter(identifier.charCodeAt(i))) { + return false; + } + } + return true; + } + } + } + return false; + } + function transitionFromLowerToUpper(identifier, word, index) { + var lastIsUpper = isUpperCaseLetter(identifier.charCodeAt(index - 1)); + var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); + var transition = word ? (currentIsUpper && !lastIsUpper) : currentIsUpper; + return transition; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var SignatureHelp; + (function (SignatureHelp) { + var emptyArray = []; + function getSignatureHelpItems(sourceFile, position, typeInfoResolver, cancellationToken) { + var startingToken = ts.findTokenOnLeftOfPosition(sourceFile, position); + if (!startingToken) { + return undefined; + } + var argumentInfo = getContainingArgumentInfo(startingToken); + cancellationToken.throwIfCancellationRequested(); + if (!argumentInfo) { + return undefined; + } + var call = argumentInfo.invocation; + var candidates = []; + var resolvedSignature = typeInfoResolver.getResolvedSignature(call, candidates); + cancellationToken.throwIfCancellationRequested(); + if (!candidates.length) { + return undefined; + } + return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo); + function getImmediatelyContainingArgumentInfo(node) { + if (node.parent.kind === 155 || node.parent.kind === 156) { + var callExpression = node.parent; + if (node.kind === 24 || + node.kind === 16) { + var list = getChildListThatStartsWithOpenerToken(callExpression, node, sourceFile); + var isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos; + ts.Debug.assert(list !== undefined); + return { + kind: isTypeArgList ? 0 : 1, + invocation: callExpression, + argumentsSpan: getApplicableSpanForArguments(list), + argumentIndex: 0, + argumentCount: getCommaBasedArgCount(list) + }; + } + var listItemInfo = ts.findListItemInfo(node); + if (listItemInfo) { + var list = listItemInfo.list; + var isTypeArgList = callExpression.typeArguments && callExpression.typeArguments.pos === list.pos; + var argumentIndex = (listItemInfo.listItemIndex + 1) >> 1; + return { + kind: isTypeArgList ? 0 : 1, + invocation: callExpression, + argumentsSpan: getApplicableSpanForArguments(list), + argumentIndex: argumentIndex, + argumentCount: getCommaBasedArgCount(list) + }; + } + } + else if (node.kind === 10 && node.parent.kind === 157) { + if (ts.isInsideTemplateLiteral(node, position)) { + return getArgumentListInfoForTemplate(node.parent, 0); + } + } + else if (node.kind === 11 && node.parent.parent.kind === 157) { + var templateExpression = node.parent; + var tagExpression = templateExpression.parent; + ts.Debug.assert(templateExpression.kind === 169); + var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; + return getArgumentListInfoForTemplate(tagExpression, argumentIndex); + } + else if (node.parent.kind === 173 && node.parent.parent.parent.kind === 157) { + var templateSpan = node.parent; + var templateExpression = templateSpan.parent; + var tagExpression = templateExpression.parent; + ts.Debug.assert(templateExpression.kind === 169); + if (node.kind === 13 && !ts.isInsideTemplateLiteral(node, position)) { + return undefined; + } + var spanIndex = templateExpression.templateSpans.indexOf(templateSpan); + var argumentIndex = getArgumentIndexForTemplatePiece(spanIndex, node); + return getArgumentListInfoForTemplate(tagExpression, argumentIndex); + } + return undefined; + } + function getCommaBasedArgCount(argumentsList) { + return argumentsList.getChildCount() === 0 ? 0 : 1 + ts.countWhere(argumentsList.getChildren(), function (arg) { return arg.kind === 23; }); + } + function getArgumentIndexForTemplatePiece(spanIndex, node) { + ts.Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node."); + if (ts.isTemplateLiteralKind(node.kind)) { + if (ts.isInsideTemplateLiteral(node, position)) { + return 0; + } + return spanIndex + 2; + } + return spanIndex + 1; + } + function getArgumentListInfoForTemplate(tagExpression, argumentIndex) { + var argumentCount = tagExpression.template.kind === 10 ? 1 : tagExpression.template.templateSpans.length + 1; + return { + kind: 2, + invocation: tagExpression, + argumentsSpan: getApplicableSpanForTaggedTemplate(tagExpression), + argumentIndex: argumentIndex, + argumentCount: argumentCount + }; + } + function getApplicableSpanForArguments(argumentsList) { + var applicableSpanStart = argumentsList.getFullStart(); + var applicableSpanEnd = ts.skipTrivia(sourceFile.text, argumentsList.getEnd(), false); + return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); + } + function getApplicableSpanForTaggedTemplate(taggedTemplate) { + var template = taggedTemplate.template; + var applicableSpanStart = template.getStart(); + var applicableSpanEnd = template.getEnd(); + if (template.kind === 169) { + var lastSpan = ts.lastOrUndefined(template.templateSpans); + if (lastSpan.literal.getFullWidth() === 0) { + applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); + } + } + return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); + } + function getContainingArgumentInfo(node) { + for (var n = node; n.kind !== 220; n = n.parent) { + if (ts.isFunctionBlock(n)) { + return undefined; + } + if (n.pos < n.parent.pos || n.end > n.parent.end) { + ts.Debug.fail("Node of kind " + n.kind + " is not a subspan of its parent of kind " + n.parent.kind); + } + var argumentInfo = getImmediatelyContainingArgumentInfo(n); + if (argumentInfo) { + return argumentInfo; + } + } + return undefined; + } + function getChildListThatStartsWithOpenerToken(parent, openerToken, sourceFile) { + var children = parent.getChildren(sourceFile); + var indexOfOpenerToken = children.indexOf(openerToken); + ts.Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1); + return children[indexOfOpenerToken + 1]; + } + function selectBestInvalidOverloadIndex(candidates, argumentCount) { + var maxParamsSignatureIndex = -1; + var maxParams = -1; + for (var i = 0; i < candidates.length; i++) { + var candidate = candidates[i]; + if (candidate.hasRestParameter || candidate.parameters.length >= argumentCount) { + return i; + } + if (candidate.parameters.length > maxParams) { + maxParams = candidate.parameters.length; + maxParamsSignatureIndex = i; + } + } + return maxParamsSignatureIndex; + } + function createSignatureHelpItems(candidates, bestSignature, argumentListInfo) { + var applicableSpan = argumentListInfo.argumentsSpan; + var isTypeParameterList = argumentListInfo.kind === 0; + var invocation = argumentListInfo.invocation; + var callTarget = ts.getInvokedExpression(invocation); + var callTargetSymbol = typeInfoResolver.getSymbolAtLocation(callTarget); + var callTargetDisplayParts = callTargetSymbol && ts.symbolToDisplayParts(typeInfoResolver, callTargetSymbol, undefined, undefined); + var items = ts.map(candidates, function (candidateSignature) { + var signatureHelpParameters; + var prefixDisplayParts = []; + var suffixDisplayParts = []; + if (callTargetDisplayParts) { + prefixDisplayParts.push.apply(prefixDisplayParts, callTargetDisplayParts); + } + if (isTypeParameterList) { + prefixDisplayParts.push(ts.punctuationPart(24)); + var typeParameters = candidateSignature.typeParameters; + signatureHelpParameters = typeParameters && typeParameters.length > 0 ? ts.map(typeParameters, createSignatureHelpParameterForTypeParameter) : emptyArray; + suffixDisplayParts.push(ts.punctuationPart(25)); + var parameterParts = ts.mapToDisplayParts(function (writer) { + return typeInfoResolver.getSymbolDisplayBuilder().buildDisplayForParametersAndDelimiters(candidateSignature.parameters, writer, invocation); + }); + suffixDisplayParts.push.apply(suffixDisplayParts, parameterParts); + } + else { + var typeParameterParts = ts.mapToDisplayParts(function (writer) { + return typeInfoResolver.getSymbolDisplayBuilder().buildDisplayForTypeParametersAndDelimiters(candidateSignature.typeParameters, writer, invocation); + }); + prefixDisplayParts.push.apply(prefixDisplayParts, typeParameterParts); + prefixDisplayParts.push(ts.punctuationPart(16)); + var parameters = candidateSignature.parameters; + signatureHelpParameters = parameters.length > 0 ? ts.map(parameters, createSignatureHelpParameterForParameter) : emptyArray; + suffixDisplayParts.push(ts.punctuationPart(17)); + } + var returnTypeParts = ts.mapToDisplayParts(function (writer) { + return typeInfoResolver.getSymbolDisplayBuilder().buildReturnTypeDisplay(candidateSignature, writer, invocation); + }); + suffixDisplayParts.push.apply(suffixDisplayParts, returnTypeParts); + return { + isVariadic: candidateSignature.hasRestParameter, + prefixDisplayParts: prefixDisplayParts, + suffixDisplayParts: suffixDisplayParts, + separatorDisplayParts: [ts.punctuationPart(23), ts.spacePart()], + parameters: signatureHelpParameters, + documentation: candidateSignature.getDocumentationComment() + }; + }); + var argumentIndex = argumentListInfo.argumentIndex; + var argumentCount = argumentListInfo.argumentCount; + var selectedItemIndex = candidates.indexOf(bestSignature); + if (selectedItemIndex < 0) { + selectedItemIndex = selectBestInvalidOverloadIndex(candidates, argumentCount); + } + return { + items: items, + applicableSpan: applicableSpan, + selectedItemIndex: selectedItemIndex, + argumentIndex: argumentIndex, + argumentCount: argumentCount + }; + function createSignatureHelpParameterForParameter(parameter) { + var displayParts = ts.mapToDisplayParts(function (writer) { + return typeInfoResolver.getSymbolDisplayBuilder().buildParameterDisplay(parameter, writer, invocation); + }); + var isOptional = ts.hasQuestionToken(parameter.valueDeclaration); + return { + name: parameter.name, + documentation: parameter.getDocumentationComment(), + displayParts: displayParts, + isOptional: isOptional + }; + } + function createSignatureHelpParameterForTypeParameter(typeParameter) { + var displayParts = ts.mapToDisplayParts(function (writer) { + return typeInfoResolver.getSymbolDisplayBuilder().buildTypeParameterDisplay(typeParameter, writer, invocation); + }); + return { + name: typeParameter.symbol.name, + documentation: emptyArray, + displayParts: displayParts, + isOptional: false + }; + } + } + } + SignatureHelp.getSignatureHelpItems = getSignatureHelpItems; + })(SignatureHelp = ts.SignatureHelp || (ts.SignatureHelp = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + function getEndLinePosition(line, sourceFile) { + ts.Debug.assert(line >= 0); + var lineStarts = sourceFile.getLineStarts(); + var lineIndex = line; + if (lineIndex + 1 === lineStarts.length) { + return sourceFile.text.length - 1; + } + else { + var start = lineStarts[lineIndex]; + var pos = lineStarts[lineIndex + 1] - 1; + ts.Debug.assert(ts.isLineBreak(sourceFile.text.charCodeAt(pos))); + while (start <= pos && ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { + pos--; + } + return pos; + } + } + ts.getEndLinePosition = getEndLinePosition; + function getLineStartPositionForPosition(position, sourceFile) { + var lineStarts = sourceFile.getLineStarts(); + var line = sourceFile.getLineAndCharacterOfPosition(position).line; + return lineStarts[line]; + } + ts.getLineStartPositionForPosition = getLineStartPositionForPosition; + function rangeContainsRange(r1, r2) { + return startEndContainsRange(r1.pos, r1.end, r2); + } + ts.rangeContainsRange = rangeContainsRange; + function startEndContainsRange(start, end, range) { + return start <= range.pos && end >= range.end; + } + ts.startEndContainsRange = startEndContainsRange; + function rangeContainsStartEnd(range, start, end) { + return range.pos <= start && range.end >= end; + } + ts.rangeContainsStartEnd = rangeContainsStartEnd; + function rangeOverlapsWithStartEnd(r1, start, end) { + return startEndOverlapsWithStartEnd(r1.pos, r1.end, start, end); + } + ts.rangeOverlapsWithStartEnd = rangeOverlapsWithStartEnd; + function startEndOverlapsWithStartEnd(start1, end1, start2, end2) { + var start = Math.max(start1, start2); + var end = Math.min(end1, end2); + return start < end; + } + ts.startEndOverlapsWithStartEnd = startEndOverlapsWithStartEnd; + function findListItemInfo(node) { + var list = findContainingList(node); + if (!list) { + return undefined; + } + var children = list.getChildren(); + var listItemIndex = ts.indexOf(children, node); + return { + listItemIndex: listItemIndex, + list: list + }; + } + ts.findListItemInfo = findListItemInfo; + function findChildOfKind(n, kind, sourceFile) { + return ts.forEach(n.getChildren(sourceFile), function (c) { return c.kind === kind && c; }); + } + ts.findChildOfKind = findChildOfKind; + function findContainingList(node) { + var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { + if (c.kind === 221 && c.pos <= node.pos && c.end >= node.end) { + return c; + } + }); + return syntaxList; + } + ts.findContainingList = findContainingList; + function getTouchingWord(sourceFile, position) { + return getTouchingToken(sourceFile, position, function (n) { return isWord(n.kind); }); + } + ts.getTouchingWord = getTouchingWord; + function getTouchingPropertyName(sourceFile, position) { + return getTouchingToken(sourceFile, position, function (n) { return isPropertyName(n.kind); }); + } + ts.getTouchingPropertyName = getTouchingPropertyName; + function getTouchingToken(sourceFile, position, includeItemAtEndPosition) { + return getTokenAtPositionWorker(sourceFile, position, false, includeItemAtEndPosition); + } + ts.getTouchingToken = getTouchingToken; + function getTokenAtPosition(sourceFile, position) { + return getTokenAtPositionWorker(sourceFile, position, true, undefined); + } + ts.getTokenAtPosition = getTokenAtPosition; + function getTokenAtPositionWorker(sourceFile, position, allowPositionInLeadingTrivia, includeItemAtEndPosition) { + var current = sourceFile; + outer: while (true) { + if (isToken(current)) { + return current; + } + for (var i = 0, n = current.getChildCount(sourceFile); i < n; i++) { + var child = current.getChildAt(i); + var start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile); + if (start <= position) { + var end = child.getEnd(); + if (position < end || (position === end && child.kind === 1)) { + current = child; + continue outer; + } + else if (includeItemAtEndPosition && end === position) { + var previousToken = findPrecedingToken(position, sourceFile, child); + if (previousToken && includeItemAtEndPosition(previousToken)) { + return previousToken; + } + } + } + } + return current; + } + } + function findTokenOnLeftOfPosition(file, position) { + var tokenAtPosition = getTokenAtPosition(file, position); + if (isToken(tokenAtPosition) && position > tokenAtPosition.getStart(file) && position < tokenAtPosition.getEnd()) { + return tokenAtPosition; + } + return findPrecedingToken(position, file); + } + ts.findTokenOnLeftOfPosition = findTokenOnLeftOfPosition; + function findNextToken(previousToken, parent) { + return find(parent); + function find(n) { + if (isToken(n) && n.pos === previousToken.end) { + return n; + } + var children = n.getChildren(); + for (var i = 0, len = children.length; i < len; ++i) { + var child = children[i]; + var shouldDiveInChildNode = (child.pos <= previousToken.pos && child.end > previousToken.end) || + (child.pos === previousToken.end); + if (shouldDiveInChildNode && nodeHasTokens(child)) { + return find(child); + } + } + return undefined; + } + } + ts.findNextToken = findNextToken; + function findPrecedingToken(position, sourceFile, startNode) { + return find(startNode || sourceFile); + function findRightmostToken(n) { + if (isToken(n)) { + return n; + } + var children = n.getChildren(); + var candidate = findRightmostChildNodeWithTokens(children, children.length); + return candidate && findRightmostToken(candidate); + } + function find(n) { + if (isToken(n)) { + return n; + } + var children = n.getChildren(); + for (var i = 0, len = children.length; i < len; ++i) { + var child = children[i]; + if (nodeHasTokens(child)) { + if (position <= child.end) { + if (child.getStart(sourceFile) >= position) { + var candidate = findRightmostChildNodeWithTokens(children, i); + return candidate && findRightmostToken(candidate); + } + else { + return find(child); + } + } + } + } + ts.Debug.assert(startNode !== undefined || n.kind === 220); + if (children.length) { + var candidate = findRightmostChildNodeWithTokens(children, children.length); + return candidate && findRightmostToken(candidate); + } + } + function findRightmostChildNodeWithTokens(children, exclusiveStartPosition) { + for (var i = exclusiveStartPosition - 1; i >= 0; --i) { + if (nodeHasTokens(children[i])) { + return children[i]; + } + } + } + } + ts.findPrecedingToken = findPrecedingToken; + function nodeHasTokens(n) { + return n.getWidth() !== 0; + } + function getNodeModifiers(node) { + var flags = ts.getCombinedNodeFlags(node); + var result = []; + if (flags & 32) + result.push(ts.ScriptElementKindModifier.privateMemberModifier); + if (flags & 64) + result.push(ts.ScriptElementKindModifier.protectedMemberModifier); + if (flags & 16) + result.push(ts.ScriptElementKindModifier.publicMemberModifier); + if (flags & 128) + result.push(ts.ScriptElementKindModifier.staticModifier); + if (flags & 1) + result.push(ts.ScriptElementKindModifier.exportedModifier); + if (ts.isInAmbientContext(node)) + result.push(ts.ScriptElementKindModifier.ambientModifier); + return result.length > 0 ? result.join(',') : ts.ScriptElementKindModifier.none; + } + ts.getNodeModifiers = getNodeModifiers; + function getTypeArgumentOrTypeParameterList(node) { + if (node.kind === 139 || node.kind === 155) { + return node.typeArguments; + } + if (ts.isAnyFunction(node) || node.kind === 196 || node.kind === 197) { + return node.typeParameters; + } + return undefined; + } + ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; + function isToken(n) { + return n.kind >= 0 && n.kind <= 124; + } + ts.isToken = isToken; + function isWord(kind) { + return kind === 64 || ts.isKeyword(kind); + } + function isPropertyName(kind) { + return kind === 8 || kind === 7 || isWord(kind); + } + function isComment(kind) { + return kind === 2 || kind === 3; + } + ts.isComment = isComment; + function isPunctuation(kind) { + return 14 <= kind && kind <= 63; + } + ts.isPunctuation = isPunctuation; + function isInsideTemplateLiteral(node, position) { + return ts.isTemplateLiteralKind(node.kind) && (node.getStart() < position && position < node.getEnd()) || (!!node.isUnterminated && position === node.getEnd()); + } + ts.isInsideTemplateLiteral = isInsideTemplateLiteral; + function compareDataObjects(dst, src) { + for (var e in dst) { + if (typeof dst[e] === "object") { + if (!compareDataObjects(dst[e], src[e])) { + return false; + } + } + else if (typeof dst[e] !== "function") { + if (dst[e] !== src[e]) { + return false; + } + } + } + return true; + } + ts.compareDataObjects = compareDataObjects; +})(ts || (ts = {})); +var ts; +(function (ts) { + function isFirstDeclarationOfSymbolParameter(symbol) { + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 128; + } + ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; + var displayPartWriter = getDisplayPartWriter(); + function getDisplayPartWriter() { + var displayParts; + var lineStart; + var indent; + resetWriter(); + return { + displayParts: function () { return displayParts; }, + writeKeyword: function (text) { return writeKind(text, 5); }, + writeOperator: function (text) { return writeKind(text, 12); }, + writePunctuation: function (text) { return writeKind(text, 15); }, + writeSpace: function (text) { return writeKind(text, 16); }, + writeStringLiteral: function (text) { return writeKind(text, 8); }, + writeParameter: function (text) { return writeKind(text, 13); }, + writeSymbol: writeSymbol, + writeLine: writeLine, + increaseIndent: function () { indent++; }, + decreaseIndent: function () { indent--; }, + clear: resetWriter, + trackSymbol: function () { } + }; + function writeIndent() { + if (lineStart) { + var indentString = ts.getIndentString(indent); + if (indentString) { + displayParts.push(displayPart(indentString, 16)); + } + lineStart = false; + } + } + function writeKind(text, kind) { + writeIndent(); + displayParts.push(displayPart(text, kind)); + } + function writeSymbol(text, symbol) { + writeIndent(); + displayParts.push(symbolPart(text, symbol)); + } + function writeLine() { + displayParts.push(lineBreakPart()); + lineStart = true; + } + function resetWriter() { + displayParts = []; + lineStart = true; + indent = 0; + } + } + function symbolPart(text, symbol) { + return displayPart(text, displayPartKind(symbol), symbol); + function displayPartKind(symbol) { + var flags = symbol.flags; + if (flags & 3) { + return isFirstDeclarationOfSymbolParameter(symbol) ? 13 : 9; + } + else if (flags & 4) { + return 14; + } + else if (flags & 32768) { + return 14; + } + else if (flags & 65536) { + return 14; + } + else if (flags & 8) { + return 19; + } + else if (flags & 16) { + return 20; + } + else if (flags & 32) { + return 1; + } + else if (flags & 64) { + return 4; + } + else if (flags & 384) { + return 2; + } + else if (flags & 1536) { + return 11; + } + else if (flags & 8192) { + return 10; + } + else if (flags & 262144) { + return 18; + } + else if (flags & 524288) { + return 0; + } + else if (flags & 8388608) { + return 0; + } + return 17; + } + } + ts.symbolPart = symbolPart; + function displayPart(text, kind, symbol) { + return { + text: text, + kind: ts.SymbolDisplayPartKind[kind] + }; + } + ts.displayPart = displayPart; + function spacePart() { + return displayPart(" ", 16); + } + ts.spacePart = spacePart; + function keywordPart(kind) { + return displayPart(ts.tokenToString(kind), 5); + } + ts.keywordPart = keywordPart; + function punctuationPart(kind) { + return displayPart(ts.tokenToString(kind), 15); + } + ts.punctuationPart = punctuationPart; + function operatorPart(kind) { + return displayPart(ts.tokenToString(kind), 12); + } + ts.operatorPart = operatorPart; + function textPart(text) { + return displayPart(text, 17); + } + ts.textPart = textPart; + function lineBreakPart() { + return displayPart("\n", 6); + } + ts.lineBreakPart = lineBreakPart; + function mapToDisplayParts(writeDisplayParts) { + writeDisplayParts(displayPartWriter); + var result = displayPartWriter.displayParts(); + displayPartWriter.clear(); + return result; + } + ts.mapToDisplayParts = mapToDisplayParts; + function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags) { + return mapToDisplayParts(function (writer) { + typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags); + }); + } + ts.typeToDisplayParts = typeToDisplayParts; + function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags) { + return mapToDisplayParts(function (writer) { + typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags); + }); + } + ts.symbolToDisplayParts = symbolToDisplayParts; + function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags) { + return mapToDisplayParts(function (writer) { + typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags); + }); + } + ts.signatureToDisplayParts = signatureToDisplayParts; +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var scanner = ts.createScanner(2, false); + function getFormattingScanner(sourceFile, startPos, endPos) { + scanner.setText(sourceFile.text); + scanner.setTextPos(startPos); + var wasNewLine = true; + var leadingTrivia; + var trailingTrivia; + var savedPos; + var lastScanAction; + var lastTokenInfo; + return { + advance: advance, + readTokenInfo: readTokenInfo, + isOnToken: isOnToken, + lastTrailingTriviaWasNewLine: function () { return wasNewLine; }, + close: function () { + lastTokenInfo = undefined; + scanner.setText(undefined); + } + }; + function advance() { + lastTokenInfo = undefined; + var isStarted = scanner.getStartPos() !== startPos; + if (isStarted) { + if (trailingTrivia) { + ts.Debug.assert(trailingTrivia.length !== 0); + wasNewLine = trailingTrivia[trailingTrivia.length - 1].kind === 4; + } + else { + wasNewLine = false; + } + } + leadingTrivia = undefined; + trailingTrivia = undefined; + if (!isStarted) { + scanner.scan(); + } + var t; + var pos = scanner.getStartPos(); + while (pos < endPos) { + var t = scanner.getToken(); + if (!ts.isTrivia(t)) { + break; + } + scanner.scan(); + var item = { + pos: pos, + end: scanner.getStartPos(), + kind: t + }; + pos = scanner.getStartPos(); + if (!leadingTrivia) { + leadingTrivia = []; + } + leadingTrivia.push(item); + } + savedPos = scanner.getStartPos(); + } + function shouldRescanGreaterThanToken(node) { + if (node) { + switch (node.kind) { + case 27: + case 59: + case 60: + case 42: + case 41: + return true; + } + } + return false; + } + function shouldRescanSlashToken(container) { + return container.kind === 9; + } + function shouldRescanTemplateToken(container) { + return container.kind === 12 || + container.kind === 13; + } + function startsWithSlashToken(t) { + return t === 36 || t === 56; + } + function readTokenInfo(n) { + if (!isOnToken()) { + return { + leadingTrivia: leadingTrivia, + trailingTrivia: undefined, + token: undefined + }; + } + var expectedScanAction = shouldRescanGreaterThanToken(n) ? 1 : shouldRescanSlashToken(n) ? 2 : shouldRescanTemplateToken(n) ? 3 : 0; + if (lastTokenInfo && expectedScanAction === lastScanAction) { + return fixTokenKind(lastTokenInfo, n); + } + if (scanner.getStartPos() !== savedPos) { + ts.Debug.assert(lastTokenInfo !== undefined); + scanner.setTextPos(savedPos); + scanner.scan(); + } + var currentToken = scanner.getToken(); + if (expectedScanAction === 1 && currentToken === 25) { + currentToken = scanner.reScanGreaterToken(); + ts.Debug.assert(n.kind === currentToken); + lastScanAction = 1; + } + else if (expectedScanAction === 2 && startsWithSlashToken(currentToken)) { + currentToken = scanner.reScanSlashToken(); + ts.Debug.assert(n.kind === currentToken); + lastScanAction = 2; + } + else if (expectedScanAction === 3 && currentToken === 15) { + currentToken = scanner.reScanTemplateToken(); + lastScanAction = 3; + } + else { + lastScanAction = 0; + } + var token = { + pos: scanner.getStartPos(), + end: scanner.getTextPos(), + kind: currentToken + }; + if (trailingTrivia) { + trailingTrivia = undefined; + } + while (scanner.getStartPos() < endPos) { + currentToken = scanner.scan(); + if (!ts.isTrivia(currentToken)) { + break; + } + var trivia = { + pos: scanner.getStartPos(), + end: scanner.getTextPos(), + kind: currentToken + }; + if (!trailingTrivia) { + trailingTrivia = []; + } + trailingTrivia.push(trivia); + if (currentToken === 4) { + scanner.scan(); + break; + } + } + lastTokenInfo = { + leadingTrivia: leadingTrivia, + trailingTrivia: trailingTrivia, + token: token + }; + return fixTokenKind(lastTokenInfo, n); + } + function isOnToken() { + var current = (lastTokenInfo && lastTokenInfo.token.kind) || scanner.getToken(); + var startPos = (lastTokenInfo && lastTokenInfo.token.pos) || scanner.getStartPos(); + return startPos < endPos && current !== 1 && !ts.isTrivia(current); + } + function fixTokenKind(tokenInfo, container) { + if (ts.isToken(container) && tokenInfo.token.kind !== container.kind) { + tokenInfo.token.kind = container.kind; + } + return tokenInfo; + } + } + formatting.getFormattingScanner = getFormattingScanner; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var FormattingContext = (function () { + function FormattingContext(sourceFile, formattingRequestKind) { + this.sourceFile = sourceFile; + this.formattingRequestKind = formattingRequestKind; + } + FormattingContext.prototype.updateContext = function (currentRange, currentTokenParent, nextRange, nextTokenParent, commonParent) { + ts.Debug.assert(currentRange !== undefined, "currentTokenSpan is null"); + ts.Debug.assert(currentTokenParent !== undefined, "currentTokenParent is null"); + ts.Debug.assert(nextRange !== undefined, "nextTokenSpan is null"); + ts.Debug.assert(nextTokenParent !== undefined, "nextTokenParent is null"); + ts.Debug.assert(commonParent !== undefined, "commonParent is null"); + this.currentTokenSpan = currentRange; + this.currentTokenParent = currentTokenParent; + this.nextTokenSpan = nextRange; + this.nextTokenParent = nextTokenParent; + this.contextNode = commonParent; + this.contextNodeAllOnSameLine = undefined; + this.nextNodeAllOnSameLine = undefined; + this.tokensAreOnSameLine = undefined; + this.contextNodeBlockIsOnOneLine = undefined; + this.nextNodeBlockIsOnOneLine = undefined; + }; + FormattingContext.prototype.ContextNodeAllOnSameLine = function () { + if (this.contextNodeAllOnSameLine === undefined) { + this.contextNodeAllOnSameLine = this.NodeIsOnOneLine(this.contextNode); + } + return this.contextNodeAllOnSameLine; + }; + FormattingContext.prototype.NextNodeAllOnSameLine = function () { + if (this.nextNodeAllOnSameLine === undefined) { + this.nextNodeAllOnSameLine = this.NodeIsOnOneLine(this.nextTokenParent); + } + return this.nextNodeAllOnSameLine; + }; + FormattingContext.prototype.TokensAreOnSameLine = function () { + 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); + } + return this.tokensAreOnSameLine; + }; + FormattingContext.prototype.ContextNodeBlockIsOnOneLine = function () { + if (this.contextNodeBlockIsOnOneLine === undefined) { + this.contextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.contextNode); + } + return this.contextNodeBlockIsOnOneLine; + }; + FormattingContext.prototype.NextNodeBlockIsOnOneLine = function () { + if (this.nextNodeBlockIsOnOneLine === undefined) { + this.nextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.nextTokenParent); + } + return this.nextNodeBlockIsOnOneLine; + }; + 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; + }; + FormattingContext.prototype.BlockIsOnOneLine = function (node) { + var openBrace = ts.findChildOfKind(node, 14, this.sourceFile); + var closeBrace = ts.findChildOfKind(node, 15, this.sourceFile); + if (openBrace && closeBrace) { + var startLine = this.sourceFile.getLineAndCharacterOfPosition(openBrace.getEnd()).line; + var endLine = this.sourceFile.getLineAndCharacterOfPosition(closeBrace.getStart(this.sourceFile)).line; + return startLine === endLine; + } + return false; + }; + return FormattingContext; + })(); + formatting.FormattingContext = FormattingContext; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var Rule = (function () { + function Rule(Descriptor, Operation, Flag) { + if (Flag === void 0) { Flag = 0; } + this.Descriptor = Descriptor; + this.Operation = Operation; + this.Flag = Flag; + } + Rule.prototype.toString = function () { + return "[desc=" + this.Descriptor + "," + + "operation=" + this.Operation + "," + + "flag=" + this.Flag + "]"; + }; + return Rule; + })(); + formatting.Rule = Rule; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var RuleDescriptor = (function () { + function RuleDescriptor(LeftTokenRange, RightTokenRange) { + this.LeftTokenRange = LeftTokenRange; + this.RightTokenRange = RightTokenRange; + } + RuleDescriptor.prototype.toString = function () { + return "[leftRange=" + this.LeftTokenRange + "," + + "rightRange=" + this.RightTokenRange + "]"; + }; + RuleDescriptor.create1 = function (left, right) { + return RuleDescriptor.create4(formatting.Shared.TokenRange.FromToken(left), formatting.Shared.TokenRange.FromToken(right)); + }; + RuleDescriptor.create2 = function (left, right) { + return RuleDescriptor.create4(left, formatting.Shared.TokenRange.FromToken(right)); + }; + RuleDescriptor.create3 = function (left, right) { + return RuleDescriptor.create4(formatting.Shared.TokenRange.FromToken(left), right); + }; + RuleDescriptor.create4 = function (left, right) { + return new RuleDescriptor(left, right); + }; + return RuleDescriptor; + })(); + formatting.RuleDescriptor = RuleDescriptor; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var RuleOperation = (function () { + function RuleOperation() { + this.Context = null; + this.Action = null; + } + RuleOperation.prototype.toString = function () { + return "[context=" + this.Context + "," + + "action=" + this.Action + "]"; + }; + RuleOperation.create1 = function (action) { + return RuleOperation.create2(formatting.RuleOperationContext.Any, action); + }; + RuleOperation.create2 = function (context, action) { + var result = new RuleOperation(); + result.Context = context; + result.Action = action; + return result; + }; + return RuleOperation; + })(); + formatting.RuleOperation = RuleOperation; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var RuleOperationContext = (function () { + function RuleOperationContext() { + var funcs = []; + for (var _i = 0; _i < arguments.length; _i++) { + funcs[_i - 0] = arguments[_i]; + } + this.customContextChecks = funcs; + } + RuleOperationContext.prototype.IsAny = function () { + return this == RuleOperationContext.Any; + }; + RuleOperationContext.prototype.InContext = function (context) { + if (this.IsAny()) { + return true; + } + for (var i = 0, len = this.customContextChecks.length; i < len; i++) { + if (!this.customContextChecks[i](context)) { + return false; + } + } + return true; + }; + RuleOperationContext.Any = new RuleOperationContext(); + return RuleOperationContext; + })(); + formatting.RuleOperationContext = RuleOperationContext; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var Rules = (function () { + function Rules() { + this.IgnoreBeforeComment = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.Comments), formatting.RuleOperation.create1(1)); + this.IgnoreAfterLineComment = new formatting.Rule(formatting.RuleDescriptor.create3(2, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create1(1)); + this.NoSpaceBeforeSemicolon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeColon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 51), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceBeforeQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.SpaceAfterColon = new formatting.Rule(formatting.RuleDescriptor.create3(51, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2)); + this.SpaceAfterQuestionMarkInConditionalOperator = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsConditionalOperatorContext), 2)); + this.NoSpaceAfterQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterSemicolon = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsAfterCodeBlockContext), 2)); + this.SpaceBetweenCloseBraceAndElse = new formatting.Rule(formatting.RuleDescriptor.create1(15, 75), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceBetweenCloseBraceAndWhile = new formatting.Rule(formatting.RuleDescriptor.create1(15, 99), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15, formatting.Shared.TokenRange.FromTokens([17, 19, 23, 22])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeDot = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 20), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterDot = new formatting.Rule(formatting.RuleDescriptor.create3(20, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 18), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterOpenBracket = new formatting.Rule(formatting.RuleDescriptor.create3(18, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 19), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.FunctionOpenBraceLeftTokenRange = formatting.Shared.TokenRange.AnyIncludingMultilineComments; + this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.TypeScriptOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([64, 3]); + this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.ControlOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([17, 3, 74, 95, 80, 75]); + this.SpaceBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.SpaceAfterOpenBrace = new formatting.Rule(formatting.RuleDescriptor.create3(14, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2)); + this.SpaceBeforeCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSingleLineBlockContext), 2)); + this.NoSpaceBetweenEmptyBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectContext), 8)); + this.NewLineAfterOpenBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create3(14, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4)); + this.NewLineBeforeCloseBraceInBlockContext = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.AnyIncludingMultilineComments, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsMultilineBlockContext), 4)); + this.NoSpaceAfterUnaryPrefixOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.UnaryPrefixOperators, formatting.Shared.TokenRange.UnaryPrefixExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceAfterUnaryPreincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(38, formatting.Shared.TokenRange.UnaryPreincrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterUnaryPredecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create3(39, formatting.Shared.TokenRange.UnaryPredecrementExpressions), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeUnaryPostincrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostincrementExpressions, 38), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeUnaryPostdecrementOperator = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.UnaryPostdecrementExpressions, 39), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterPostincrementWhenFollowedByAdd = new formatting.Rule(formatting.RuleDescriptor.create1(38, 33), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterAddWhenFollowedByUnaryPlus = new formatting.Rule(formatting.RuleDescriptor.create1(33, 33), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterAddWhenFollowedByPreincrement = new formatting.Rule(formatting.RuleDescriptor.create1(33, 38), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterPostdecrementWhenFollowedBySubtract = new formatting.Rule(formatting.RuleDescriptor.create1(39, 34), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterSubtractWhenFollowedByUnaryMinus = new formatting.Rule(formatting.RuleDescriptor.create1(34, 34), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterSubtractWhenFollowedByPredecrement = new formatting.Rule(formatting.RuleDescriptor.create1(34, 39), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.NoSpaceBeforeComma = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 23), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([97, 93, 87, 73, 89, 96]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterLetConstInVariableDeclaration = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([105, 69]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), 2)); + this.NoSpaceBeforeOpenParenInFuncCall = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), 8)); + this.SpaceAfterFunctionInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create3(82, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.NoSpaceBeforeOpenParenInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionDeclContext), 8)); + this.SpaceAfterVoidOperator = new formatting.Rule(formatting.RuleDescriptor.create3(98, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsVoidOpContext), 2)); + this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(89, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([17, 74, 75, 66]), 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([95, 80]), 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116, 120]), 64), 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, 118]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([68, 115, 76, 77, 78, 116, 103, 84, 104, 117, 107, 109, 120, 110]), 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([78, 103])), 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)); + this.NoSpaceAfterEllipsis = new formatting.Rule(formatting.RuleDescriptor.create1(21, 64), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterOptionalParameters = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.FromTokens([17, 23])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceBeforeOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.TypeNames, 24), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceBetweenCloseParenAndAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create1(17, 24), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceAfterOpenAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(24, formatting.Shared.TokenRange.TypeNames), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceBeforeCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 25), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceAfterCloseAngularBracket = new formatting.Rule(formatting.RuleDescriptor.create3(25, formatting.Shared.TokenRange.FromTokens([16, 18, 25, 23])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsTypeArgumentOrParameterContext), 8)); + this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new formatting.Rule(formatting.RuleDescriptor.create1(14, 15), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsObjectTypeContext), 8)); + this.HighPriorityCommonRules = + [ + this.IgnoreBeforeComment, this.IgnoreAfterLineComment, + this.NoSpaceBeforeColon, this.SpaceAfterColon, this.NoSpaceBeforeQuestionMark, this.SpaceAfterQuestionMarkInConditionalOperator, + this.NoSpaceAfterQuestionMark, + this.NoSpaceBeforeDot, this.NoSpaceAfterDot, + this.NoSpaceAfterUnaryPrefixOperator, + this.NoSpaceAfterUnaryPreincrementOperator, this.NoSpaceAfterUnaryPredecrementOperator, + this.NoSpaceBeforeUnaryPostincrementOperator, this.NoSpaceBeforeUnaryPostdecrementOperator, + this.SpaceAfterPostincrementWhenFollowedByAdd, + this.SpaceAfterAddWhenFollowedByUnaryPlus, this.SpaceAfterAddWhenFollowedByPreincrement, + this.SpaceAfterPostdecrementWhenFollowedBySubtract, + this.SpaceAfterSubtractWhenFollowedByUnaryMinus, this.SpaceAfterSubtractWhenFollowedByPredecrement, + this.NoSpaceAfterCloseBrace, + this.SpaceAfterOpenBrace, this.SpaceBeforeCloseBrace, this.NewLineBeforeCloseBraceInBlockContext, + this.SpaceAfterCloseBrace, this.SpaceBetweenCloseBraceAndElse, this.SpaceBetweenCloseBraceAndWhile, this.NoSpaceBetweenEmptyBraceBrackets, + this.SpaceAfterFunctionInFuncDecl, this.NewLineAfterOpenBraceInBlockContext, this.SpaceAfterGetSetInMember, + this.NoSpaceBetweenReturnAndSemicolon, + this.SpaceAfterCertainKeywords, + this.SpaceAfterLetConstInVariableDeclaration, + this.NoSpaceBeforeOpenParenInFuncCall, + this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator, + this.SpaceAfterVoidOperator, + this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport, + this.SpaceAfterCertainTypeScriptKeywords, this.SpaceBeforeCertainTypeScriptKeywords, + this.SpaceAfterModuleName, + this.SpaceAfterArrow, + this.NoSpaceAfterEllipsis, + this.NoSpaceAfterOptionalParameters, + this.NoSpaceBetweenEmptyInterfaceBraceBrackets, + this.NoSpaceBeforeOpenAngularBracket, + this.NoSpaceBetweenCloseParenAndAngularBracket, + this.NoSpaceAfterOpenAngularBracket, + this.NoSpaceBeforeCloseAngularBracket, + this.NoSpaceAfterCloseAngularBracket + ]; + this.LowPriorityCommonRules = + [ + this.NoSpaceBeforeSemicolon, + this.SpaceBeforeOpenBraceInControl, this.SpaceBeforeOpenBraceInFunction, this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock, + this.NoSpaceBeforeComma, + this.NoSpaceBeforeOpenBracket, this.NoSpaceAfterOpenBracket, + this.NoSpaceBeforeCloseBracket, this.NoSpaceAfterCloseBracket, + this.SpaceAfterSemicolon, + this.NoSpaceBeforeOpenParenInFuncDecl, + this.SpaceBetweenStatements, this.SpaceAfterTryFinally + ]; + this.SpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(23, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceAfterComma = new formatting.Rule(formatting.RuleDescriptor.create3(23, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.SpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); + this.NoSpaceBeforeBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.Any, formatting.Shared.TokenRange.BinaryOperators), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 8)); + this.NoSpaceAfterBinaryOperator = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.BinaryOperators, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 8)); + this.SpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 2)); + this.NoSpaceAfterKeywordInControl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Keywords, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext), 8)); + this.NewLineBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeMultilineBlockContext), 4), 1); + this.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsBeforeMultilineBlockContext), 4), 1); + this.NewLineBeforeOpenBraceInControl = new formatting.Rule(formatting.RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsControlDeclContext, Rules.IsBeforeMultilineBlockContext), 4), 1); + this.SpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), 2)); + this.NoSpaceAfterSemicolonInFor = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsForContext), 8)); + this.SpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(16, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.NoSpaceBetweenParens = new formatting.Rule(formatting.RuleDescriptor.create1(16, 17), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceAfterOpenParen = new formatting.Rule(formatting.RuleDescriptor.create3(16, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.NoSpaceBeforeCloseParen = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 17), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(82, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.NoSpaceAfterAnonymousFunctionKeyword = new formatting.Rule(formatting.RuleDescriptor.create1(82, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 8)); + } + Rules.prototype.getRuleName = function (rule) { + var o = this; + for (var name in o) { + if (o[name] === rule) { + return name; + } + } + throw new Error("Unknown rule"); + }; + Rules.IsForContext = function (context) { + return context.contextNode.kind === 181; + }; + Rules.IsNotForContext = function (context) { + return !Rules.IsForContext(context); + }; + Rules.IsBinaryOpContext = function (context) { + switch (context.contextNode.kind) { + case 167: + case 168: + return true; + case 202: + case 193: + case 128: + case 219: + case 130: + case 129: + return context.currentTokenSpan.kind === 52 || context.nextTokenSpan.kind === 52; + case 182: + return context.currentTokenSpan.kind === 85 || context.nextTokenSpan.kind === 85; + case 183: + return context.currentTokenSpan.kind === 124 || context.nextTokenSpan.kind === 124; + case 150: + return context.currentTokenSpan.kind === 52 || context.nextTokenSpan.kind === 52; + } + return false; + }; + Rules.IsNotBinaryOpContext = function (context) { + return !Rules.IsBinaryOpContext(context); + }; + Rules.IsConditionalOperatorContext = function (context) { + return context.contextNode.kind === 168; + }; + Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { + return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context); + }; + Rules.IsBeforeMultilineBlockContext = function (context) { + return Rules.IsBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine()); + }; + Rules.IsMultilineBlockContext = function (context) { + return Rules.IsBlockContext(context) && !(context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine()); + }; + Rules.IsSingleLineBlockContext = function (context) { + return Rules.IsBlockContext(context) && (context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine()); + }; + Rules.IsBlockContext = function (context) { + return Rules.NodeIsBlockContext(context.contextNode); + }; + Rules.IsBeforeBlockContext = function (context) { + return Rules.NodeIsBlockContext(context.nextTokenParent); + }; + Rules.NodeIsBlockContext = function (node) { + if (Rules.NodeIsTypeScriptDeclWithBlockContext(node)) { + return true; + } + switch (node.kind) { + case 174: + case 188: + case 152: + case 201: + return true; + } + return false; + }; + Rules.IsFunctionDeclContext = function (context) { + switch (context.contextNode.kind) { + case 195: + case 132: + case 131: + case 134: + case 135: + case 136: + case 160: + case 133: + case 161: + case 197: + return true; + } + return false; + }; + Rules.IsTypeScriptDeclWithBlockContext = function (context) { + return Rules.NodeIsTypeScriptDeclWithBlockContext(context.contextNode); + }; + Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { + switch (node.kind) { + case 196: + case 197: + case 199: + case 143: + case 200: + return true; + } + return false; + }; + Rules.IsAfterCodeBlockContext = function (context) { + switch (context.currentTokenParent.kind) { + case 196: + case 200: + case 199: + case 174: + case 216: + case 201: + case 188: + return true; + } + return false; + }; + Rules.IsControlDeclContext = function (context) { + switch (context.contextNode.kind) { + case 178: + case 188: + case 181: + case 182: + case 183: + case 180: + case 191: + case 179: + case 187: + case 216: + return true; + default: + return false; + } + }; + Rules.IsObjectContext = function (context) { + return context.contextNode.kind === 152; + }; + Rules.IsFunctionCallContext = function (context) { + return context.contextNode.kind === 155; + }; + Rules.IsNewContext = function (context) { + return context.contextNode.kind === 156; + }; + Rules.IsFunctionCallOrNewContext = function (context) { + return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); + }; + Rules.IsPreviousTokenNotComma = function (context) { + return context.currentTokenSpan.kind !== 23; + }; + Rules.IsSameLineTokenContext = function (context) { + return context.TokensAreOnSameLine(); + }; + Rules.IsStartOfVariableDeclarationList = function (context) { + return context.currentTokenParent.kind === 194 && + context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; + }; + Rules.IsNotFormatOnEnter = function (context) { + return context.formattingRequestKind != 2; + }; + Rules.IsModuleDeclContext = function (context) { + return context.contextNode.kind === 200; + }; + Rules.IsObjectTypeContext = function (context) { + return context.contextNode.kind === 143; + }; + Rules.IsTypeArgumentOrParameter = function (token, parent) { + if (token.kind !== 24 && token.kind !== 25) { + return false; + } + switch (parent.kind) { + case 139: + case 196: + case 197: + case 195: + case 160: + case 161: + case 132: + case 131: + case 136: + case 137: + case 155: + case 156: + return true; + default: + return false; + } + }; + Rules.IsTypeArgumentOrParameterContext = function (context) { + return Rules.IsTypeArgumentOrParameter(context.currentTokenSpan, context.currentTokenParent) || + Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); + }; + Rules.IsVoidOpContext = function (context) { + return context.currentTokenSpan.kind === 98 && context.currentTokenParent.kind === 164; + }; + return Rules; + })(); + formatting.Rules = Rules; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var RulesMap = (function () { + function RulesMap() { + this.map = []; + this.mapRowLength = 0; + } + RulesMap.create = function (rules) { + var result = new RulesMap(); + result.Initialize(rules); + return result; + }; + RulesMap.prototype.Initialize = function (rules) { + this.mapRowLength = 124 + 1; + this.map = new Array(this.mapRowLength * this.mapRowLength); + var rulesBucketConstructionStateList = new Array(this.map.length); + this.FillRules(rules, rulesBucketConstructionStateList); + return this.map; + }; + RulesMap.prototype.FillRules = function (rules, rulesBucketConstructionStateList) { + var _this = this; + rules.forEach(function (rule) { + _this.FillRule(rule, rulesBucketConstructionStateList); + }); + }; + RulesMap.prototype.GetRuleBucketIndex = function (row, column) { + var rulesBucketIndex = (row * this.mapRowLength) + column; + return rulesBucketIndex; + }; + 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; + 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) { + rulesBucket = _this.map[rulesBucketIndex] = new RulesBucket(); + } + rulesBucket.AddRule(rule, specificRule, rulesBucketConstructionStateList, rulesBucketIndex); + }); + }); + }; + RulesMap.prototype.GetRule = function (context) { + var bucketIndex = this.GetRuleBucketIndex(context.currentTokenSpan.kind, context.nextTokenSpan.kind); + var bucket = this.map[bucketIndex]; + if (bucket != null) { + for (var i = 0, len = bucket.Rules().length; i < len; i++) { + var rule = bucket.Rules()[i]; + if (rule.Operation.Context.InContext(context)) + return rule; + } + } + return null; + }; + return RulesMap; + })(); + formatting.RulesMap = RulesMap; + var MaskBitSize = 5; + var Mask = 0x1f; + (function (RulesPosition) { + RulesPosition[RulesPosition["IgnoreRulesSpecific"] = 0] = "IgnoreRulesSpecific"; + RulesPosition[RulesPosition["IgnoreRulesAny"] = MaskBitSize * 1] = "IgnoreRulesAny"; + RulesPosition[RulesPosition["ContextRulesSpecific"] = MaskBitSize * 2] = "ContextRulesSpecific"; + RulesPosition[RulesPosition["ContextRulesAny"] = MaskBitSize * 3] = "ContextRulesAny"; + RulesPosition[RulesPosition["NoContextRulesSpecific"] = MaskBitSize * 4] = "NoContextRulesSpecific"; + RulesPosition[RulesPosition["NoContextRulesAny"] = MaskBitSize * 5] = "NoContextRulesAny"; + })(formatting.RulesPosition || (formatting.RulesPosition = {})); + var RulesPosition = formatting.RulesPosition; + var RulesBucketConstructionState = (function () { + function RulesBucketConstructionState() { + this.rulesInsertionIndexBitmap = 0; + } + RulesBucketConstructionState.prototype.GetInsertionIndex = function (maskPosition) { + var index = 0; + var pos = 0; + var indexBitmap = this.rulesInsertionIndexBitmap; + while (pos <= maskPosition) { + index += (indexBitmap & Mask); + indexBitmap >>= MaskBitSize; + pos += MaskBitSize; + } + return index; + }; + 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."); + var temp = this.rulesInsertionIndexBitmap & ~(Mask << maskPosition); + temp |= value << maskPosition; + this.rulesInsertionIndexBitmap = temp; + }; + return RulesBucketConstructionState; + })(); + formatting.RulesBucketConstructionState = RulesBucketConstructionState; + var RulesBucket = (function () { + function RulesBucket() { + this.rules = []; + } + RulesBucket.prototype.Rules = function () { + return this.rules; + }; + RulesBucket.prototype.AddRule = function (rule, specificTokens, constructionState, rulesBucketIndex) { + var position; + if (rule.Operation.Action == 1) { + position = specificTokens ? 0 : RulesPosition.IgnoreRulesAny; + } + else if (!rule.Operation.Context.IsAny()) { + position = specificTokens ? RulesPosition.ContextRulesSpecific : RulesPosition.ContextRulesAny; + } + else { + position = specificTokens ? RulesPosition.NoContextRulesSpecific : RulesPosition.NoContextRulesAny; + } + var state = constructionState[rulesBucketIndex]; + if (state === undefined) { + state = constructionState[rulesBucketIndex] = new RulesBucketConstructionState(); + } + var index = state.GetInsertionIndex(position); + this.rules.splice(index, 0, rule); + state.IncreaseInsertionIndex(position); + }; + return RulesBucket; + })(); + formatting.RulesBucket = RulesBucket; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var Shared; + (function (Shared) { + var TokenRangeAccess = (function () { + function TokenRangeAccess(from, to, except) { + this.tokens = []; + for (var token = from; token <= to; token++) { + if (except.indexOf(token) < 0) { + this.tokens.push(token); + } + } + } + TokenRangeAccess.prototype.GetTokens = function () { + return this.tokens; + }; + TokenRangeAccess.prototype.Contains = function (token) { + return this.tokens.indexOf(token) >= 0; + }; + return TokenRangeAccess; + })(); + Shared.TokenRangeAccess = TokenRangeAccess; + var TokenValuesAccess = (function () { + function TokenValuesAccess(tks) { + this.tokens = tks && tks.length ? tks : []; + } + TokenValuesAccess.prototype.GetTokens = function () { + return this.tokens; + }; + TokenValuesAccess.prototype.Contains = function (token) { + return this.tokens.indexOf(token) >= 0; + }; + return TokenValuesAccess; + })(); + Shared.TokenValuesAccess = TokenValuesAccess; + var TokenSingleValueAccess = (function () { + function TokenSingleValueAccess(token) { + this.token = token; + } + TokenSingleValueAccess.prototype.GetTokens = function () { + return [this.token]; + }; + TokenSingleValueAccess.prototype.Contains = function (tokenValue) { + return tokenValue == this.token; + }; + return TokenSingleValueAccess; + })(); + Shared.TokenSingleValueAccess = TokenSingleValueAccess; + var TokenAllAccess = (function () { + function TokenAllAccess() { + } + TokenAllAccess.prototype.GetTokens = function () { + var result = []; + for (var token = 0; token <= 124; token++) { + result.push(token); + } + return result; + }; + TokenAllAccess.prototype.Contains = function (tokenValue) { + return true; + }; + TokenAllAccess.prototype.toString = function () { + return "[allTokens]"; + }; + return TokenAllAccess; + })(); + Shared.TokenAllAccess = TokenAllAccess; + var TokenRange = (function () { + function TokenRange(tokenAccess) { + this.tokenAccess = tokenAccess; + } + TokenRange.FromToken = function (token) { + return new TokenRange(new TokenSingleValueAccess(token)); + }; + TokenRange.FromTokens = function (tokens) { + return new TokenRange(new TokenValuesAccess(tokens)); + }; + TokenRange.FromRange = function (f, to, except) { + if (except === void 0) { except = []; } + return new TokenRange(new TokenRangeAccess(f, to, except)); + }; + TokenRange.AllTokens = function () { + return new TokenRange(new TokenAllAccess()); + }; + TokenRange.prototype.GetTokens = function () { + return this.tokenAccess.GetTokens(); + }; + TokenRange.prototype.Contains = function (token) { + return this.tokenAccess.Contains(token); + }; + TokenRange.prototype.toString = function () { + return this.tokenAccess.toString(); + }; + TokenRange.Any = TokenRange.AllTokens(); + TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3])); + TokenRange.Keywords = TokenRange.FromRange(65, 124); + TokenRange.BinaryOperators = TokenRange.FromRange(24, 63); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([85, 86, 124]); + TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38, 39, 47, 46]); + TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7, 64, 16, 18, 14, 92, 87]); + TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([64, 16, 92, 87]); + TokenRange.UnaryPostincrementExpressions = TokenRange.FromTokens([64, 17, 19, 87]); + TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([64, 16, 92, 87]); + TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([64, 17, 19, 87]); + TokenRange.Comments = TokenRange.FromTokens([2, 3]); + TokenRange.TypeNames = TokenRange.FromTokens([64, 119, 121, 113, 122, 98, 112]); + return TokenRange; + })(); + Shared.TokenRange = TokenRange; + })(Shared = formatting.Shared || (formatting.Shared = {})); + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var RulesProvider = (function () { + function RulesProvider() { + this.globalRules = new formatting.Rules(); + } + RulesProvider.prototype.getRuleName = function (rule) { + return this.globalRules.getRuleName(rule); + }; + RulesProvider.prototype.getRuleByName = function (name) { + return this.globalRules[name]; + }; + RulesProvider.prototype.getRulesMap = function () { + return this.rulesMap; + }; + RulesProvider.prototype.ensureUpToDate = function (options) { + if (this.options == null || !ts.compareDataObjects(this.options, options)) { + var activeRules = this.createActiveRules(options); + var rulesMap = formatting.RulesMap.create(activeRules); + this.activeRules = activeRules; + this.rulesMap = rulesMap; + this.options = ts.clone(options); + } + }; + RulesProvider.prototype.createActiveRules = function (options) { + var rules = this.globalRules.HighPriorityCommonRules.slice(0); + if (options.InsertSpaceAfterCommaDelimiter) { + rules.push(this.globalRules.SpaceAfterComma); + } + else { + rules.push(this.globalRules.NoSpaceAfterComma); + } + if (options.InsertSpaceAfterFunctionKeywordForAnonymousFunctions) { + rules.push(this.globalRules.SpaceAfterAnonymousFunctionKeyword); + } + else { + rules.push(this.globalRules.NoSpaceAfterAnonymousFunctionKeyword); + } + if (options.InsertSpaceAfterKeywordsInControlFlowStatements) { + rules.push(this.globalRules.SpaceAfterKeywordInControl); + } + else { + rules.push(this.globalRules.NoSpaceAfterKeywordInControl); + } + if (options.InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis) { + rules.push(this.globalRules.SpaceAfterOpenParen); + rules.push(this.globalRules.SpaceBeforeCloseParen); + rules.push(this.globalRules.NoSpaceBetweenParens); + } + else { + rules.push(this.globalRules.NoSpaceAfterOpenParen); + rules.push(this.globalRules.NoSpaceBeforeCloseParen); + rules.push(this.globalRules.NoSpaceBetweenParens); + } + if (options.InsertSpaceAfterSemicolonInForStatements) { + rules.push(this.globalRules.SpaceAfterSemicolonInFor); + } + else { + rules.push(this.globalRules.NoSpaceAfterSemicolonInFor); + } + if (options.InsertSpaceBeforeAndAfterBinaryOperators) { + rules.push(this.globalRules.SpaceBeforeBinaryOperator); + rules.push(this.globalRules.SpaceAfterBinaryOperator); + } + else { + rules.push(this.globalRules.NoSpaceBeforeBinaryOperator); + rules.push(this.globalRules.NoSpaceAfterBinaryOperator); + } + if (options.PlaceOpenBraceOnNewLineForControlBlocks) { + rules.push(this.globalRules.NewLineBeforeOpenBraceInControl); + } + if (options.PlaceOpenBraceOnNewLineForFunctions) { + rules.push(this.globalRules.NewLineBeforeOpenBraceInFunction); + rules.push(this.globalRules.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock); + } + rules = rules.concat(this.globalRules.LowPriorityCommonRules); + return rules; + }; + return RulesProvider; + })(); + formatting.RulesProvider = RulesProvider; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + function formatOnEnter(position, sourceFile, rulesProvider, options) { + var line = sourceFile.getLineAndCharacterOfPosition(position).line; + if (line === 0) { + return []; + } + var span = { + pos: ts.getStartPositionOfLine(line - 1, sourceFile), + end: ts.getEndLinePosition(line, sourceFile) + 1 + }; + return formatSpan(span, sourceFile, options, rulesProvider, 2); + } + formatting.formatOnEnter = formatOnEnter; + function formatOnSemicolon(position, sourceFile, rulesProvider, options) { + return formatOutermostParent(position, 22, sourceFile, options, rulesProvider, 3); + } + formatting.formatOnSemicolon = formatOnSemicolon; + function formatOnClosingCurly(position, sourceFile, rulesProvider, options) { + return formatOutermostParent(position, 15, sourceFile, options, rulesProvider, 4); + } + formatting.formatOnClosingCurly = formatOnClosingCurly; + function formatDocument(sourceFile, rulesProvider, options) { + var span = { + pos: 0, + end: sourceFile.text.length + }; + return formatSpan(span, sourceFile, options, rulesProvider, 0); + } + formatting.formatDocument = formatDocument; + function formatSelection(start, end, sourceFile, rulesProvider, options) { + var span = { + pos: ts.getLineStartPositionForPosition(start, sourceFile), + end: end + }; + return formatSpan(span, sourceFile, options, rulesProvider, 1); + } + formatting.formatSelection = formatSelection; + function formatOutermostParent(position, expectedLastToken, sourceFile, options, rulesProvider, requestKind) { + var parent = findOutermostParent(position, expectedLastToken, sourceFile); + if (!parent) { + return []; + } + var span = { + pos: ts.getLineStartPositionForPosition(parent.getStart(sourceFile), sourceFile), + end: parent.end + }; + return formatSpan(span, sourceFile, options, rulesProvider, requestKind); + } + function findOutermostParent(position, expectedTokenKind, sourceFile) { + var precedingToken = ts.findPrecedingToken(position, sourceFile); + if (!precedingToken || + precedingToken.kind !== expectedTokenKind || + position !== precedingToken.getEnd()) { + return undefined; + } + var current = precedingToken; + while (current && + current.parent && + current.parent.end === precedingToken.end && + !isListElement(current.parent, current)) { + current = current.parent; + } + return current; + } + function isListElement(parent, node) { + switch (parent.kind) { + case 196: + case 197: + return ts.rangeContainsRange(parent.members, node); + case 200: + var body = parent.body; + return body && body.kind === 174 && ts.rangeContainsRange(body.statements, node); + case 220: + case 174: + case 201: + return ts.rangeContainsRange(parent.statements, node); + case 216: + return ts.rangeContainsRange(parent.block.statements, node); + } + return false; + } + function findEnclosingNode(range, sourceFile) { + return find(sourceFile); + function find(n) { + var candidate = ts.forEachChild(n, function (c) { return ts.startEndContainsRange(c.getStart(sourceFile), c.end, range) && c; }); + if (candidate) { + var result = find(candidate); + if (result) { + return result; + } + } + return n; + } + } + function prepareRangeContainsErrorFunction(errors, originalRange) { + if (!errors.length) { + return rangeHasNoErrors; + } + var sorted = errors.filter(function (d) { return ts.rangeOverlapsWithStartEnd(originalRange, d.start, d.start + d.length); }).sort(function (e1, e2) { return e1.start - e2.start; }); + if (!sorted.length) { + return rangeHasNoErrors; + } + var index = 0; + return function (r) { + while (true) { + if (index >= sorted.length) { + return false; + } + var error = sorted[index]; + if (r.end <= error.start) { + return false; + } + if (ts.startEndOverlapsWithStartEnd(r.pos, r.end, error.start, error.start + error.length)) { + return true; + } + index++; + } + }; + function rangeHasNoErrors(r) { + return false; + } + } + function getScanStartPosition(enclosingNode, originalRange, sourceFile) { + var start = enclosingNode.getStart(sourceFile); + if (start === originalRange.pos && enclosingNode.end === originalRange.end) { + return start; + } + var precedingToken = ts.findPrecedingToken(originalRange.pos, sourceFile); + if (!precedingToken) { + return enclosingNode.pos; + } + if (precedingToken.end >= originalRange.pos) { + return enclosingNode.pos; + } + return precedingToken.end; + } + function getOwnOrInheritedDelta(n, options, sourceFile) { + var previousLine = -1; + var childKind = 0; + while (n) { + var line = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line; + if (previousLine !== -1 && line !== previousLine) { + break; + } + if (formatting.SmartIndenter.shouldIndentChildNode(n.kind, childKind)) { + return options.IndentSize; + } + previousLine = line; + childKind = n.kind; + n = n.parent; + } + return 0; + } + function formatSpan(originalRange, sourceFile, options, rulesProvider, requestKind) { + var rangeContainsError = prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange); + var formattingContext = new formatting.FormattingContext(sourceFile, requestKind); + var enclosingNode = findEnclosingNode(originalRange, sourceFile); + var formattingScanner = formatting.getFormattingScanner(sourceFile, getScanStartPosition(enclosingNode, originalRange, sourceFile), originalRange.end); + var initialIndentation = formatting.SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, options); + var previousRangeHasError; + var previousRange; + var previousParent; + var previousRangeStartLine; + var edits = []; + formattingScanner.advance(); + if (formattingScanner.isOnToken()) { + var startLine = sourceFile.getLineAndCharacterOfPosition(enclosingNode.getStart(sourceFile)).line; + var delta = getOwnOrInheritedDelta(enclosingNode, options, sourceFile); + processNode(enclosingNode, enclosingNode, startLine, initialIndentation, delta); + } + formattingScanner.close(); + return edits; + function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range, inheritedIndentation) { + if (ts.rangeOverlapsWithStartEnd(range, startPos, endPos)) { + if (inheritedIndentation !== -1) { + return inheritedIndentation; + } + } + else { + var startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line; + var startLinePosition = ts.getLineStartPositionForPosition(startPos, sourceFile); + var column = formatting.SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, startPos, sourceFile, options); + if (startLine !== parentStartLine || startPos === column) { + return column; + } + } + return -1; + } + function computeIndentation(node, startLine, inheritedIndentation, parent, parentDynamicIndentation, effectiveParentStartLine) { + var indentation = inheritedIndentation; + if (indentation === -1) { + if (isSomeBlock(node.kind)) { + if (isSomeBlock(parent.kind) || + parent.kind === 220 || + parent.kind === 213 || + parent.kind === 214) { + indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); + } + else { + indentation = parentDynamicIndentation.getIndentation(); + } + } + else { + if (formatting.SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent, node, startLine, sourceFile)) { + indentation = parentDynamicIndentation.getIndentation(); + } + else { + indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); + } + } + } + var delta = formatting.SmartIndenter.shouldIndentChildNode(node.kind, 0) ? options.IndentSize : 0; + if (effectiveParentStartLine === startLine) { + indentation = parentDynamicIndentation.getIndentation(); + delta = Math.min(options.IndentSize, parentDynamicIndentation.getDelta() + delta); + } + return { + indentation: indentation, + delta: delta + }; + } + function getDynamicIndentation(node, nodeStartLine, indentation, delta) { + return { + getIndentationForComment: function (kind) { + switch (kind) { + case 15: + case 19: + return indentation + delta; + } + return indentation; + }, + getIndentationForToken: function (line, kind) { + switch (kind) { + case 14: + case 15: + case 18: + case 19: + case 75: + case 99: + return indentation; + default: + return nodeStartLine !== line ? indentation + delta : indentation; + } + }, + getIndentation: function () { return indentation; }, + getDelta: function () { return delta; }, + recomputeIndentation: function (lineAdded) { + if (node.parent && formatting.SmartIndenter.shouldIndentChildNode(node.parent.kind, node.kind)) { + if (lineAdded) { + indentation += options.IndentSize; + } + else { + indentation -= options.IndentSize; + } + if (formatting.SmartIndenter.shouldIndentChildNode(node.kind, 0)) { + delta = options.IndentSize; + } + else { + delta = 0; + } + } + } + }; + } + function processNode(node, contextNode, nodeStartLine, indentation, delta) { + if (!ts.rangeOverlapsWithStartEnd(originalRange, node.getStart(sourceFile), node.getEnd())) { + return; + } + var nodeDynamicIndentation = getDynamicIndentation(node, nodeStartLine, indentation, delta); + var childContextNode = contextNode; + ts.forEachChild(node, function (child) { + processChildNode(child, -1, node, nodeDynamicIndentation, nodeStartLine, false); + }, function (nodes) { + processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation); + }); + while (formattingScanner.isOnToken()) { + var tokenInfo = formattingScanner.readTokenInfo(node); + if (tokenInfo.token.end > node.end) { + break; + } + consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation); + } + function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, isListItem) { + var childStartPos = child.getStart(sourceFile); + var childStart = sourceFile.getLineAndCharacterOfPosition(childStartPos); + var childIndentationAmount = -1; + if (isListItem) { + childIndentationAmount = tryComputeIndentationForListItem(childStartPos, child.end, parentStartLine, originalRange, inheritedIndentation); + if (childIndentationAmount !== -1) { + inheritedIndentation = childIndentationAmount; + } + } + if (!ts.rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) { + return inheritedIndentation; + } + if (child.getFullWidth() === 0) { + return inheritedIndentation; + } + while (formattingScanner.isOnToken()) { + var tokenInfo = formattingScanner.readTokenInfo(node); + if (tokenInfo.token.end > childStartPos) { + break; + } + consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); + } + if (!formattingScanner.isOnToken()) { + return inheritedIndentation; + } + if (ts.isToken(child)) { + var tokenInfo = formattingScanner.readTokenInfo(child); + ts.Debug.assert(tokenInfo.token.end === child.end); + consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation); + return inheritedIndentation; + } + var childIndentation = computeIndentation(child, childStart.line, childIndentationAmount, node, parentDynamicIndentation, parentStartLine); + processNode(child, childContextNode, childStart.line, childIndentation.indentation, childIndentation.delta); + childContextNode = node; + return inheritedIndentation; + } + function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) { + var listStartToken = getOpenTokenForList(parent, nodes); + var listEndToken = getCloseTokenForOpenToken(listStartToken); + var listDynamicIndentation = parentDynamicIndentation; + var startLine = parentStartLine; + if (listStartToken !== 0) { + while (formattingScanner.isOnToken()) { + var tokenInfo = formattingScanner.readTokenInfo(parent); + if (tokenInfo.token.end > nodes.pos) { + break; + } + else if (tokenInfo.token.kind === listStartToken) { + startLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line; + var indentation = computeIndentation(tokenInfo.token, startLine, -1, parent, parentDynamicIndentation, startLine); + listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentation.indentation, indentation.delta); + consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); + } + else { + consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation); + } + } + } + var inheritedIndentation = -1; + for (var i = 0, len = nodes.length; i < len; ++i) { + inheritedIndentation = processChildNode(nodes[i], inheritedIndentation, node, listDynamicIndentation, startLine, true); + } + if (listEndToken !== 0) { + if (formattingScanner.isOnToken()) { + var tokenInfo = formattingScanner.readTokenInfo(parent); + if (tokenInfo.token.kind === listEndToken && ts.rangeContainsRange(parent, tokenInfo.token)) { + consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation); + } + } + } + } + function consumeTokenAndAdvanceScanner(currentTokenInfo, parent, dynamicIndentation) { + ts.Debug.assert(ts.rangeContainsRange(parent, currentTokenInfo.token)); + var lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine(); + var indentToken = false; + if (currentTokenInfo.leadingTrivia) { + processTrivia(currentTokenInfo.leadingTrivia, parent, childContextNode, dynamicIndentation); + } + var lineAdded; + var isTokenInRange = ts.rangeContainsRange(originalRange, currentTokenInfo.token); + var tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos); + if (isTokenInRange) { + var rangeHasError = rangeContainsError(currentTokenInfo.token); + var prevStartLine = previousRangeStartLine; + lineAdded = processRange(currentTokenInfo.token, tokenStart, parent, childContextNode, dynamicIndentation); + if (rangeHasError) { + indentToken = false; + } + else { + if (lineAdded !== undefined) { + indentToken = lineAdded; + } + else { + indentToken = lastTriviaWasNewLine && tokenStart.line !== prevStartLine; + } + } + } + if (currentTokenInfo.trailingTrivia) { + processTrivia(currentTokenInfo.trailingTrivia, parent, childContextNode, dynamicIndentation); + } + if (indentToken) { + var indentNextTokenOrTrivia = true; + if (currentTokenInfo.leadingTrivia) { + for (var i = 0, len = currentTokenInfo.leadingTrivia.length; i < len; ++i) { + var triviaItem = currentTokenInfo.leadingTrivia[i]; + if (!ts.rangeContainsRange(originalRange, triviaItem)) { + continue; + } + var triviaStartLine = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos).line; + switch (triviaItem.kind) { + case 3: + var commentIndentation = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind); + indentMultilineComment(triviaItem, commentIndentation, !indentNextTokenOrTrivia); + indentNextTokenOrTrivia = false; + break; + case 2: + if (indentNextTokenOrTrivia) { + var commentIndentation = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind); + insertIndentation(triviaItem.pos, commentIndentation, false); + indentNextTokenOrTrivia = false; + } + break; + case 4: + indentNextTokenOrTrivia = true; + break; + } + } + } + if (isTokenInRange && !rangeContainsError(currentTokenInfo.token)) { + var tokenIndentation = dynamicIndentation.getIndentationForToken(tokenStart.line, currentTokenInfo.token.kind); + insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAdded); + } + } + formattingScanner.advance(); + childContextNode = parent; + } + } + function processTrivia(trivia, parent, contextNode, dynamicIndentation) { + for (var i = 0, len = trivia.length; i < len; ++i) { + var triviaItem = trivia[i]; + if (ts.isComment(triviaItem.kind) && ts.rangeContainsRange(originalRange, triviaItem)) { + var triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos); + processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation); + } + } + } + function processRange(range, rangeStart, parent, contextNode, dynamicIndentation) { + var rangeHasError = rangeContainsError(range); + var lineAdded; + if (!rangeHasError && !previousRangeHasError) { + if (!previousRange) { + var originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos); + trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line); + } + else { + lineAdded = + processPair(range, rangeStart.line, parent, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation); + } + } + previousRange = range; + previousParent = parent; + previousRangeStartLine = rangeStart.line; + previousRangeHasError = rangeHasError; + return lineAdded; + } + function processPair(currentItem, currentStartLine, currentParent, previousItem, previousStartLine, previousParent, contextNode, dynamicIndentation) { + formattingContext.updateContext(previousItem, previousParent, currentItem, currentParent, contextNode); + var rule = rulesProvider.getRulesMap().GetRule(formattingContext); + var trimTrailingWhitespaces; + var lineAdded; + if (rule) { + applyRuleEdits(rule, previousItem, previousStartLine, currentItem, currentStartLine); + if (rule.Operation.Action & (2 | 8) && currentStartLine !== previousStartLine) { + lineAdded = false; + if (currentParent.getStart(sourceFile) === currentItem.pos) { + dynamicIndentation.recomputeIndentation(false); + } + } + else if (rule.Operation.Action & 4 && currentStartLine === previousStartLine) { + lineAdded = true; + if (currentParent.getStart(sourceFile) === currentItem.pos) { + dynamicIndentation.recomputeIndentation(true); + } + } + trimTrailingWhitespaces = + (rule.Operation.Action & (4 | 2)) && + rule.Flag !== 1; + } + else { + trimTrailingWhitespaces = true; + } + if (currentStartLine !== previousStartLine && trimTrailingWhitespaces) { + trimTrailingWhitespacesForLines(previousStartLine, currentStartLine, previousItem); + } + return lineAdded; + } + function insertIndentation(pos, indentation, lineAdded) { + var indentationString = getIndentationString(indentation, options); + if (lineAdded) { + recordReplace(pos, 0, indentationString); + } + else { + var tokenStart = sourceFile.getLineAndCharacterOfPosition(pos); + if (indentation !== tokenStart.character) { + var startLinePosition = ts.getStartPositionOfLine(tokenStart.line, sourceFile); + recordReplace(startLinePosition, tokenStart.character, indentationString); + } + } + } + function indentMultilineComment(commentRange, indentation, firstLineIsIndented) { + var startLine = sourceFile.getLineAndCharacterOfPosition(commentRange.pos).line; + var endLine = sourceFile.getLineAndCharacterOfPosition(commentRange.end).line; + if (startLine === endLine) { + if (!firstLineIsIndented) { + insertIndentation(commentRange.pos, indentation, false); + } + return; + } + else { + var parts = []; + var startPos = commentRange.pos; + for (var line = startLine; line < endLine; ++line) { + var endOfLine = ts.getEndLinePosition(line, sourceFile); + parts.push({ pos: startPos, end: endOfLine }); + startPos = ts.getStartPositionOfLine(line + 1, sourceFile); + } + parts.push({ pos: startPos, end: commentRange.end }); + } + var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); + var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].pos, sourceFile, options); + if (indentation === nonWhitespaceColumnInFirstPart.column) { + return; + } + var startIndex = 0; + if (firstLineIsIndented) { + startIndex = 1; + startLine++; + } + var delta = indentation - nonWhitespaceColumnInFirstPart.column; + for (var i = startIndex, len = parts.length; i < len; ++i, ++startLine) { + var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); + var nonWhitespaceCharacterAndColumn = i === 0 ? nonWhitespaceColumnInFirstPart : formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(parts[i].pos, parts[i].end, sourceFile, options); + var newIndentation = nonWhitespaceCharacterAndColumn.column + delta; + if (newIndentation > 0) { + var indentationString = getIndentationString(newIndentation, options); + recordReplace(startLinePos, nonWhitespaceCharacterAndColumn.character, indentationString); + } + else { + recordDelete(startLinePos, nonWhitespaceCharacterAndColumn.character); + } + } + } + function trimTrailingWhitespacesForLines(line1, line2, range) { + for (var line = line1; line < line2; ++line) { + var lineStartPosition = ts.getStartPositionOfLine(line, sourceFile); + var lineEndPosition = ts.getEndLinePosition(line, sourceFile); + if (range && ts.isComment(range.kind) && range.pos <= lineEndPosition && range.end > lineEndPosition) { + continue; + } + var pos = lineEndPosition; + while (pos >= lineStartPosition && ts.isWhiteSpace(sourceFile.text.charCodeAt(pos))) { + pos--; + } + if (pos !== lineEndPosition) { + ts.Debug.assert(pos === lineStartPosition || !ts.isWhiteSpace(sourceFile.text.charCodeAt(pos))); + recordDelete(pos + 1, lineEndPosition - pos); + } + } + } + function newTextChange(start, len, newText) { + return { span: ts.createTextSpan(start, len), newText: newText }; + } + function recordDelete(start, len) { + if (len) { + edits.push(newTextChange(start, len, "")); + } + } + function recordReplace(start, len, newText) { + if (len || newText) { + edits.push(newTextChange(start, len, newText)); + } + } + function applyRuleEdits(rule, previousRange, previousStartLine, currentRange, currentStartLine) { + var between; + switch (rule.Operation.Action) { + case 1: + return; + case 8: + if (previousRange.end !== currentRange.pos) { + recordDelete(previousRange.end, currentRange.pos - previousRange.end); + } + break; + case 4: + if (rule.Flag !== 1 && previousStartLine !== currentStartLine) { + return; + } + var lineDelta = currentStartLine - previousStartLine; + if (lineDelta !== 1) { + recordReplace(previousRange.end, currentRange.pos - previousRange.end, options.NewLineCharacter); + } + break; + case 2: + if (rule.Flag !== 1 && previousStartLine !== currentStartLine) { + return; + } + var posDelta = currentRange.pos - previousRange.end; + if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange.end) !== 32) { + recordReplace(previousRange.end, currentRange.pos - previousRange.end, " "); + } + break; + } + } + } + function isSomeBlock(kind) { + switch (kind) { + case 174: + case 201: + return true; + } + return false; + } + function getOpenTokenForList(node, list) { + switch (node.kind) { + case 133: + case 195: + case 160: + case 132: + case 131: + case 161: + if (node.typeParameters === list) { + return 24; + } + else if (node.parameters === list) { + return 16; + } + break; + case 155: + case 156: + if (node.typeArguments === list) { + return 24; + } + else if (node.arguments === list) { + return 16; + } + break; + case 139: + if (node.typeArguments === list) { + return 24; + } + } + return 0; + } + function getCloseTokenForOpenToken(kind) { + switch (kind) { + case 16: + return 17; + case 24: + return 25; + } + return 0; + } + var internedTabsIndentation; + var internedSpacesIndentation; + function getIndentationString(indentation, options) { + if (!options.ConvertTabsToSpaces) { + var tabs = Math.floor(indentation / options.TabSize); + var spaces = indentation - tabs * options.TabSize; + var tabString; + if (!internedTabsIndentation) { + internedTabsIndentation = []; + } + if (internedTabsIndentation[tabs] === undefined) { + internedTabsIndentation[tabs] = tabString = repeat('\t', tabs); + } + else { + tabString = internedTabsIndentation[tabs]; + } + return spaces ? tabString + repeat(" ", spaces) : tabString; + } + else { + var spacesString; + var quotient = Math.floor(indentation / options.IndentSize); + var remainder = indentation % options.IndentSize; + if (!internedSpacesIndentation) { + internedSpacesIndentation = []; + } + if (internedSpacesIndentation[quotient] === undefined) { + spacesString = repeat(" ", options.IndentSize * quotient); + internedSpacesIndentation[quotient] = spacesString; + } + else { + spacesString = internedSpacesIndentation[quotient]; + } + return remainder ? spacesString + repeat(" ", remainder) : spacesString; + } + function repeat(value, count) { + var s = ""; + for (var i = 0; i < count; ++i) { + s += value; + } + return s; + } + } + formatting.getIndentationString = getIndentationString; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var SmartIndenter; + (function (SmartIndenter) { + function getIndentation(position, sourceFile, options) { + if (position > sourceFile.text.length) { + return 0; + } + var precedingToken = ts.findPrecedingToken(position, sourceFile); + if (!precedingToken) { + return 0; + } + var precedingTokenIsLiteral = precedingToken.kind === 8 || + precedingToken.kind === 9 || + precedingToken.kind === 10 || + precedingToken.kind === 11 || + precedingToken.kind === 12 || + precedingToken.kind === 13; + if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) { + return 0; + } + var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; + if (precedingToken.kind === 23 && precedingToken.parent.kind !== 167) { + var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); + if (actualIndentation !== -1) { + return actualIndentation; + } + } + var previous; + var current = precedingToken; + var currentStart; + var indentationDelta; + while (current) { + if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(current.kind, previous ? previous.kind : 0)) { + currentStart = getStartLineAndCharacterForNode(current, sourceFile); + if (nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile)) { + indentationDelta = 0; + } + else { + indentationDelta = lineAtPosition !== currentStart.line ? options.IndentSize : 0; + } + break; + } + var actualIndentation = getActualIndentationForListItem(current, sourceFile, options); + if (actualIndentation !== -1) { + return actualIndentation; + } + previous = current; + current = current.parent; + } + if (!current) { + return 0; + } + return getIndentationForNodeWorker(current, currentStart, undefined, indentationDelta, sourceFile, options); + } + SmartIndenter.getIndentation = getIndentation; + function getIndentationForNode(n, ignoreActualIndentationRange, sourceFile, options) { + var start = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); + return getIndentationForNodeWorker(n, start, ignoreActualIndentationRange, 0, sourceFile, options); + } + SmartIndenter.getIndentationForNode = getIndentationForNode; + function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, options) { + var parent = current.parent; + var parentStart; + while (parent) { + var useActualIndentation = true; + if (ignoreActualIndentationRange) { + var start = current.getStart(sourceFile); + useActualIndentation = start < ignoreActualIndentationRange.pos || start > ignoreActualIndentationRange.end; + } + if (useActualIndentation) { + var actualIndentation = getActualIndentationForListItem(current, sourceFile, options); + if (actualIndentation !== -1) { + return actualIndentation + indentationDelta; + } + } + parentStart = getParentStart(parent, current, sourceFile); + var parentAndChildShareLine = parentStart.line === currentStart.line || + childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStart.line, sourceFile); + if (useActualIndentation) { + var actualIndentation = getActualIndentationForNode(current, parent, currentStart, parentAndChildShareLine, sourceFile, options); + if (actualIndentation !== -1) { + return actualIndentation + indentationDelta; + } + } + if (shouldIndentChildNode(parent.kind, current.kind) && !parentAndChildShareLine) { + indentationDelta += options.IndentSize; + } + current = parent; + currentStart = parentStart; + parent = current.parent; + } + return indentationDelta; + } + function getParentStart(parent, child, sourceFile) { + var containingList = getContainingList(child, sourceFile); + if (containingList) { + return sourceFile.getLineAndCharacterOfPosition(containingList.pos); + } + return sourceFile.getLineAndCharacterOfPosition(parent.getStart(sourceFile)); + } + function getActualIndentationForListItemBeforeComma(commaToken, sourceFile, options) { + var commaItemInfo = ts.findListItemInfo(commaToken); + ts.Debug.assert(commaItemInfo && commaItemInfo.listItemIndex > 0); + return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options); + } + function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) { + var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && + (parent.kind === 220 || !parentAndChildShareLine); + if (!useActualIndentation) { + return -1; + } + return findColumnForFirstNonWhitespaceCharacterInLine(currentLineAndChar, sourceFile, options); + } + function nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile) { + var nextToken = ts.findNextToken(precedingToken, current); + if (!nextToken) { + return false; + } + if (nextToken.kind === 14) { + return true; + } + else if (nextToken.kind === 15) { + var nextTokenStartLine = getStartLineAndCharacterForNode(nextToken, sourceFile).line; + return lineAtPosition === nextTokenStartLine; + } + return false; + } + function getStartLineAndCharacterForNode(n, sourceFile) { + return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); + } + function positionBelongsToNode(candidate, position, sourceFile) { + return candidate.end > position || !isCompletedNode(candidate, sourceFile); + } + function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { + if (parent.kind === 178 && parent.elseStatement === child) { + var elseKeyword = ts.findChildOfKind(parent, 75, sourceFile); + ts.Debug.assert(elseKeyword !== undefined); + var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; + return elseKeywordStartLine === childStartLine; + } + return false; + } + SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement = childStartsOnTheSameLineWithElseInIfStatement; + function getContainingList(node, sourceFile) { + if (node.parent) { + switch (node.parent.kind) { + case 139: + if (node.parent.typeArguments && + ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { + return node.parent.typeArguments; + } + break; + case 152: + return node.parent.properties; + case 151: + return node.parent.elements; + case 195: + case 160: + case 161: + case 132: + case 131: + case 136: + case 137: + var start = node.getStart(sourceFile); + if (node.parent.typeParameters && + ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { + return node.parent.typeParameters; + } + if (ts.rangeContainsStartEnd(node.parent.parameters, start, node.getEnd())) { + return node.parent.parameters; + } + break; + case 156: + case 155: + var start = node.getStart(sourceFile); + if (node.parent.typeArguments && + ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { + return node.parent.typeArguments; + } + if (node.parent.arguments && + ts.rangeContainsStartEnd(node.parent.arguments, start, node.getEnd())) { + return node.parent.arguments; + } + break; + } + } + return undefined; + } + function getActualIndentationForListItem(node, sourceFile, options) { + var containingList = getContainingList(node, sourceFile); + return containingList ? getActualIndentationFromList(containingList) : -1; + function getActualIndentationFromList(list) { + var index = ts.indexOf(list, node); + return index !== -1 ? deriveActualIndentationFromList(list, index, sourceFile, options) : -1; + } + } + function deriveActualIndentationFromList(list, index, sourceFile, options) { + ts.Debug.assert(index >= 0 && index < list.length); + var node = list[index]; + var lineAndCharacter = getStartLineAndCharacterForNode(node, sourceFile); + for (var i = index - 1; i >= 0; --i) { + if (list[i].kind === 23) { + continue; + } + var prevEndLine = sourceFile.getLineAndCharacterOfPosition(list[i].end).line; + if (prevEndLine !== lineAndCharacter.line) { + return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options); + } + lineAndCharacter = getStartLineAndCharacterForNode(list[i], sourceFile); + } + return -1; + } + function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options) { + var lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0); + return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options); + } + function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) { + var character = 0; + var column = 0; + for (var pos = startPos; pos < endPos; ++pos) { + var ch = sourceFile.text.charCodeAt(pos); + if (!ts.isWhiteSpace(ch)) { + break; + } + if (ch === 9) { + column += options.TabSize + (column % options.TabSize); + } + else { + column++; + } + character++; + } + return { column: column, character: character }; + } + SmartIndenter.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn; + function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) { + return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column; + } + SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; + function nodeContentIsAlwaysIndented(kind) { + switch (kind) { + case 196: + case 197: + case 199: + case 151: + case 174: + case 201: + case 152: + case 143: + case 188: + case 214: + case 213: + case 159: + case 155: + case 156: + case 175: + case 193: + case 208: + case 186: + case 168: + return true; + } + return false; + } + function shouldIndentChildNode(parent, child) { + if (nodeContentIsAlwaysIndented(parent)) { + return true; + } + switch (parent) { + case 179: + case 180: + case 182: + case 183: + case 181: + case 178: + case 195: + case 160: + case 132: + case 131: + case 161: + case 133: + case 134: + case 135: + return child !== 174; + default: + return false; + } + } + SmartIndenter.shouldIndentChildNode = shouldIndentChildNode; + function nodeEndsWith(n, expectedLastToken, sourceFile) { + var children = n.getChildren(sourceFile); + if (children.length) { + var last = children[children.length - 1]; + if (last.kind === expectedLastToken) { + return true; + } + else if (last.kind === 22 && children.length !== 1) { + return children[children.length - 2].kind === expectedLastToken; + } + } + return false; + } + function isCompletedNode(n, sourceFile) { + if (n.getFullWidth() === 0) { + return false; + } + switch (n.kind) { + case 196: + case 197: + case 199: + case 152: + case 174: + case 201: + case 188: + return nodeEndsWith(n, 15, sourceFile); + case 216: + return isCompletedNode(n.block, sourceFile); + case 159: + case 136: + case 155: + case 137: + return nodeEndsWith(n, 17, sourceFile); + case 195: + case 160: + case 132: + case 131: + case 161: + return !n.body || isCompletedNode(n.body, sourceFile); + case 200: + return n.body && isCompletedNode(n.body, sourceFile); + case 178: + if (n.elseStatement) { + return isCompletedNode(n.elseStatement, sourceFile); + } + return isCompletedNode(n.thenStatement, sourceFile); + case 177: + return isCompletedNode(n.expression, sourceFile); + case 151: + return nodeEndsWith(n, 19, sourceFile); + case 213: + case 214: + return false; + case 180: + return isCompletedNode(n.statement, sourceFile); + case 179: + var hasWhileKeyword = ts.findChildOfKind(n, 99, sourceFile); + if (hasWhileKeyword) { + return nodeEndsWith(n, 17, sourceFile); + } + return isCompletedNode(n.statement, sourceFile); + default: + return true; + } + } + })(SmartIndenter = formatting.SmartIndenter || (formatting.SmartIndenter = {})); + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +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 ts; +(function (ts) { + ts.servicesVersion = "0.4"; + var ScriptSnapshot; + (function (ScriptSnapshot) { + var StringScriptSnapshot = (function () { + function StringScriptSnapshot(text) { + this.text = text; + this._lineStartPositions = undefined; + } + StringScriptSnapshot.prototype.getText = function (start, end) { + return this.text.substring(start, end); + }; + StringScriptSnapshot.prototype.getLength = function () { + return this.text.length; + }; + StringScriptSnapshot.prototype.getChangeRange = function (oldSnapshot) { + return undefined; + }; + return StringScriptSnapshot; + })(); + function fromString(text) { + return new StringScriptSnapshot(text); + } + ScriptSnapshot.fromString = fromString; + })(ScriptSnapshot = ts.ScriptSnapshot || (ts.ScriptSnapshot = {})); + var scanner = ts.createScanner(2, true); + var emptyArray = []; + function createNode(kind, pos, end, flags, parent) { + var node = new (ts.getNodeConstructor(kind))(); + node.pos = pos; + node.end = end; + node.flags = flags; + node.parent = parent; + return node; + } + var NodeObject = (function () { + function NodeObject() { + } + NodeObject.prototype.getSourceFile = function () { + return ts.getSourceFileOfNode(this); + }; + NodeObject.prototype.getStart = function (sourceFile) { + return ts.getTokenPosOfNode(this, sourceFile); + }; + NodeObject.prototype.getFullStart = function () { + return this.pos; + }; + NodeObject.prototype.getEnd = function () { + return this.end; + }; + NodeObject.prototype.getWidth = function (sourceFile) { + return this.getEnd() - this.getStart(sourceFile); + }; + NodeObject.prototype.getFullWidth = function () { + return this.end - this.getFullStart(); + }; + NodeObject.prototype.getLeadingTriviaWidth = function (sourceFile) { + return this.getStart(sourceFile) - this.pos; + }; + NodeObject.prototype.getFullText = function (sourceFile) { + return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end); + }; + NodeObject.prototype.getText = function (sourceFile) { + return (sourceFile || this.getSourceFile()).text.substring(this.getStart(), this.getEnd()); + }; + NodeObject.prototype.addSyntheticNodes = function (nodes, pos, end) { + scanner.setTextPos(pos); + while (pos < end) { + var token = scanner.scan(); + var textPos = scanner.getTextPos(); + nodes.push(createNode(token, pos, textPos, 512, this)); + pos = textPos; + } + return pos; + }; + NodeObject.prototype.createSyntaxList = function (nodes) { + var list = createNode(221, nodes.pos, nodes.end, 512, this); + list._children = []; + var pos = nodes.pos; + for (var i = 0, len = nodes.length; i < len; i++) { + var node = nodes[i]; + if (pos < node.pos) { + pos = this.addSyntheticNodes(list._children, pos, node.pos); + } + list._children.push(node); + pos = node.end; + } + if (pos < nodes.end) { + this.addSyntheticNodes(list._children, pos, nodes.end); + } + return list; + }; + NodeObject.prototype.createChildren = function (sourceFile) { + var _this = this; + if (this.kind >= 125) { + scanner.setText((sourceFile || this.getSourceFile()).text); + var children = []; + var pos = this.pos; + var processNode = function (node) { + if (pos < node.pos) { + pos = _this.addSyntheticNodes(children, pos, node.pos); + } + children.push(node); + pos = node.end; + }; + var processNodes = function (nodes) { + if (pos < nodes.pos) { + pos = _this.addSyntheticNodes(children, pos, nodes.pos); + } + children.push(_this.createSyntaxList(nodes)); + pos = nodes.end; + }; + ts.forEachChild(this, processNode, processNodes); + if (pos < this.end) { + this.addSyntheticNodes(children, pos, this.end); + } + scanner.setText(undefined); + } + this._children = children || emptyArray; + }; + NodeObject.prototype.getChildCount = function (sourceFile) { + if (!this._children) + this.createChildren(sourceFile); + return this._children.length; + }; + NodeObject.prototype.getChildAt = function (index, sourceFile) { + if (!this._children) + this.createChildren(sourceFile); + return this._children[index]; + }; + NodeObject.prototype.getChildren = function (sourceFile) { + if (!this._children) + this.createChildren(sourceFile); + return this._children; + }; + NodeObject.prototype.getFirstToken = function (sourceFile) { + var children = this.getChildren(); + for (var i = 0; i < children.length; i++) { + var child = children[i]; + if (child.kind < 125) { + return child; + } + return child.getFirstToken(sourceFile); + } + }; + NodeObject.prototype.getLastToken = function (sourceFile) { + var children = this.getChildren(sourceFile); + for (var i = children.length - 1; i >= 0; i--) { + var child = children[i]; + if (child.kind < 125) { + return child; + } + return child.getLastToken(sourceFile); + } + }; + return NodeObject; + })(); + var SymbolObject = (function () { + function SymbolObject(flags, name) { + this.flags = flags; + this.name = name; + } + SymbolObject.prototype.getFlags = function () { + return this.flags; + }; + SymbolObject.prototype.getName = function () { + return this.name; + }; + SymbolObject.prototype.getDeclarations = function () { + return this.declarations; + }; + SymbolObject.prototype.getDocumentationComment = function () { + if (this.documentationComment === undefined) { + this.documentationComment = getJsDocCommentsFromDeclarations(this.declarations, this.name, !(this.flags & 4)); + } + return this.documentationComment; + }; + return SymbolObject; + })(); + function getJsDocCommentsFromDeclarations(declarations, name, canUseParsedParamTagComments) { + var documentationComment = []; + var docComments = getJsDocCommentsSeparatedByNewLines(); + ts.forEach(docComments, function (docComment) { + if (documentationComment.length) { + documentationComment.push(ts.lineBreakPart()); + } + documentationComment.push(docComment); + }); + return documentationComment; + function getJsDocCommentsSeparatedByNewLines() { + var paramTag = "@param"; + var jsDocCommentParts = []; + ts.forEach(declarations, function (declaration, indexOfDeclaration) { + if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { + var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); + if (canUseParsedParamTagComments && declaration.kind === 128) { + ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); + if (cleanedParamJsDocComment) { + jsDocCommentParts.push.apply(jsDocCommentParts, cleanedParamJsDocComment); + } + }); + } + if (declaration.kind === 200 && declaration.body.kind === 200) { + return; + } + while (declaration.kind === 200 && declaration.parent.kind === 200) { + declaration = declaration.parent; + } + ts.forEach(getJsDocCommentTextRange(declaration.kind === 193 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); + if (cleanedJsDocComment) { + jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); + } + }); + } + }); + return jsDocCommentParts; + function getJsDocCommentTextRange(node, sourceFile) { + return ts.map(ts.getJsDocComments(node, sourceFile), function (jsDocComment) { + return { + pos: jsDocComment.pos + "/*".length, + end: jsDocComment.end - "*/".length + }; + }); + } + function consumeWhiteSpacesOnTheLine(pos, end, sourceFile, maxSpacesToRemove) { + if (maxSpacesToRemove !== undefined) { + end = Math.min(end, pos + maxSpacesToRemove); + } + for (; pos < end; pos++) { + var ch = sourceFile.text.charCodeAt(pos); + if (!ts.isWhiteSpace(ch) || ts.isLineBreak(ch)) { + return pos; + } + } + return end; + } + function consumeLineBreaks(pos, end, sourceFile) { + while (pos < end && ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { + pos++; + } + return pos; + } + function isName(pos, end, sourceFile, name) { + return pos + name.length < end && + sourceFile.text.substr(pos, name.length) === name && + (ts.isWhiteSpace(sourceFile.text.charCodeAt(pos + name.length)) || + ts.isLineBreak(sourceFile.text.charCodeAt(pos + name.length))); + } + function isParamTag(pos, end, sourceFile) { + return isName(pos, end, sourceFile, paramTag); + } + function pushDocCommentLineText(docComments, text, blankLineCount) { + while (blankLineCount--) + docComments.push(ts.textPart("")); + docComments.push(ts.textPart(text)); + } + function getCleanedJsDocComment(pos, end, sourceFile) { + var spacesToRemoveAfterAsterisk; + var docComments = []; + var blankLineCount = 0; + var isInParamTag = false; + while (pos < end) { + var docCommentTextOfLine = ""; + pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile); + if (pos < end && sourceFile.text.charCodeAt(pos) === 42) { + var lineStartPos = pos + 1; + pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, spacesToRemoveAfterAsterisk); + if (spacesToRemoveAfterAsterisk === undefined && pos < end && !ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { + spacesToRemoveAfterAsterisk = pos - lineStartPos; + } + } + else if (spacesToRemoveAfterAsterisk === undefined) { + spacesToRemoveAfterAsterisk = 0; + } + while (pos < end && !ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { + var ch = sourceFile.text.charAt(pos); + if (ch === "@") { + if (isParamTag(pos, end, sourceFile)) { + isInParamTag = true; + pos += paramTag.length; + continue; + } + else { + isInParamTag = false; + } + } + if (!isInParamTag) { + docCommentTextOfLine += ch; + } + pos++; + } + pos = consumeLineBreaks(pos, end, sourceFile); + if (docCommentTextOfLine) { + pushDocCommentLineText(docComments, docCommentTextOfLine, blankLineCount); + blankLineCount = 0; + } + else if (!isInParamTag && docComments.length) { + blankLineCount++; + } + } + return docComments; + } + function getCleanedParamJsDocComment(pos, end, sourceFile) { + var paramHelpStringMargin; + var paramDocComments = []; + while (pos < end) { + if (isParamTag(pos, end, sourceFile)) { + var blankLineCount = 0; + var recordedParamTag = false; + pos = consumeWhiteSpaces(pos + paramTag.length); + if (pos >= end) { + break; + } + if (sourceFile.text.charCodeAt(pos) === 123) { + pos++; + for (var curlies = 1; pos < end; pos++) { + var charCode = sourceFile.text.charCodeAt(pos); + if (charCode === 123) { + curlies++; + continue; + } + if (charCode === 125) { + curlies--; + if (curlies === 0) { + pos++; + break; + } + else { + continue; + } + } + if (charCode === 64) { + break; + } + } + pos = consumeWhiteSpaces(pos); + if (pos >= end) { + break; + } + } + if (isName(pos, end, sourceFile, name)) { + pos = consumeWhiteSpaces(pos + name.length); + if (pos >= end) { + break; + } + var paramHelpString = ""; + var firstLineParamHelpStringPos = pos; + while (pos < end) { + var ch = sourceFile.text.charCodeAt(pos); + if (ts.isLineBreak(ch)) { + if (paramHelpString) { + pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount); + paramHelpString = ""; + blankLineCount = 0; + recordedParamTag = true; + } + else if (recordedParamTag) { + blankLineCount++; + } + setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos); + continue; + } + if (ch === 64) { + break; + } + paramHelpString += sourceFile.text.charAt(pos); + pos++; + } + if (paramHelpString) { + pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount); + } + paramHelpStringMargin = undefined; + } + if (sourceFile.text.charCodeAt(pos) === 64) { + continue; + } + } + pos++; + } + return paramDocComments; + function consumeWhiteSpaces(pos) { + while (pos < end && ts.isWhiteSpace(sourceFile.text.charCodeAt(pos))) { + pos++; + } + return pos; + } + function setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos) { + pos = consumeLineBreaks(pos, end, sourceFile); + if (pos >= end) { + return; + } + if (paramHelpStringMargin === undefined) { + paramHelpStringMargin = sourceFile.getLineAndCharacterOfPosition(firstLineParamHelpStringPos).character; + } + var startOfLinePos = pos; + pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile, paramHelpStringMargin); + if (pos >= end) { + return; + } + var consumedSpaces = pos - startOfLinePos; + if (consumedSpaces < paramHelpStringMargin) { + var ch = sourceFile.text.charCodeAt(pos); + if (ch === 42) { + pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, paramHelpStringMargin - consumedSpaces - 1); + } + } + } + } + } + } + var TypeObject = (function () { + function TypeObject(checker, flags) { + this.checker = checker; + this.flags = flags; + } + TypeObject.prototype.getFlags = function () { + return this.flags; + }; + TypeObject.prototype.getSymbol = function () { + return this.symbol; + }; + TypeObject.prototype.getProperties = function () { + return this.checker.getPropertiesOfType(this); + }; + TypeObject.prototype.getProperty = function (propertyName) { + return this.checker.getPropertyOfType(this, propertyName); + }; + TypeObject.prototype.getApparentProperties = function () { + return this.checker.getAugmentedPropertiesOfType(this); + }; + TypeObject.prototype.getCallSignatures = function () { + return this.checker.getSignaturesOfType(this, 0); + }; + TypeObject.prototype.getConstructSignatures = function () { + return this.checker.getSignaturesOfType(this, 1); + }; + TypeObject.prototype.getStringIndexType = function () { + return this.checker.getIndexTypeOfType(this, 0); + }; + TypeObject.prototype.getNumberIndexType = function () { + return this.checker.getIndexTypeOfType(this, 1); + }; + return TypeObject; + })(); + var SignatureObject = (function () { + function SignatureObject(checker) { + this.checker = checker; + } + SignatureObject.prototype.getDeclaration = function () { + return this.declaration; + }; + SignatureObject.prototype.getTypeParameters = function () { + return this.typeParameters; + }; + SignatureObject.prototype.getParameters = function () { + return this.parameters; + }; + SignatureObject.prototype.getReturnType = function () { + return this.checker.getReturnTypeOfSignature(this); + }; + SignatureObject.prototype.getDocumentationComment = function () { + if (this.documentationComment === undefined) { + this.documentationComment = this.declaration ? getJsDocCommentsFromDeclarations([this.declaration], undefined, false) : []; + } + return this.documentationComment; + }; + return SignatureObject; + })(); + var SourceFileObject = (function (_super) { + __extends(SourceFileObject, _super); + function SourceFileObject() { + _super.apply(this, arguments); + } + SourceFileObject.prototype.update = function (newText, textChangeRange) { + return ts.updateSourceFile(this, newText, textChangeRange); + }; + SourceFileObject.prototype.getLineAndCharacterOfPosition = function (position) { + return ts.getLineAndCharacterOfPosition(this, position); + }; + SourceFileObject.prototype.getLineStarts = function () { + return ts.getLineStarts(this); + }; + SourceFileObject.prototype.getPositionOfLineAndCharacter = function (line, character) { + return ts.getPositionOfLineAndCharacter(this, line, character); + }; + SourceFileObject.prototype.getNamedDeclarations = function () { + if (!this.namedDeclarations) { + var sourceFile = this; + var namedDeclarations = []; + ts.forEachChild(sourceFile, function visit(node) { + switch (node.kind) { + case 195: + case 132: + case 131: + var functionDeclaration = node; + if (functionDeclaration.name && functionDeclaration.name.getFullWidth() > 0) { + var lastDeclaration = namedDeclarations.length > 0 ? namedDeclarations[namedDeclarations.length - 1] : undefined; + if (lastDeclaration && functionDeclaration.symbol === lastDeclaration.symbol) { + if (functionDeclaration.body && !lastDeclaration.body) { + namedDeclarations[namedDeclarations.length - 1] = functionDeclaration; + } + } + else { + namedDeclarations.push(functionDeclaration); + } + ts.forEachChild(node, visit); + } + break; + case 196: + case 197: + case 198: + case 199: + case 200: + case 202: + case 134: + case 135: + case 143: + if (node.name) { + namedDeclarations.push(node); + } + case 133: + case 175: + case 194: + case 148: + case 149: + case 201: + ts.forEachChild(node, visit); + break; + case 174: + if (ts.isFunctionBlock(node)) { + ts.forEachChild(node, visit); + } + break; + case 128: + if (!(node.flags & 112)) { + break; + } + case 193: + case 150: + if (ts.isBindingPattern(node.name)) { + ts.forEachChild(node.name, visit); + break; + } + case 219: + case 130: + case 129: + namedDeclarations.push(node); + break; + } + }); + this.namedDeclarations = namedDeclarations; + } + return this.namedDeclarations; + }; + return SourceFileObject; + })(NodeObject); + var TextChange = (function () { + function TextChange() { + } + return TextChange; + })(); + ts.TextChange = TextChange; + (function (SymbolDisplayPartKind) { + SymbolDisplayPartKind[SymbolDisplayPartKind["aliasName"] = 0] = "aliasName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["className"] = 1] = "className"; + SymbolDisplayPartKind[SymbolDisplayPartKind["enumName"] = 2] = "enumName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["fieldName"] = 3] = "fieldName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["interfaceName"] = 4] = "interfaceName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["keyword"] = 5] = "keyword"; + SymbolDisplayPartKind[SymbolDisplayPartKind["lineBreak"] = 6] = "lineBreak"; + SymbolDisplayPartKind[SymbolDisplayPartKind["numericLiteral"] = 7] = "numericLiteral"; + SymbolDisplayPartKind[SymbolDisplayPartKind["stringLiteral"] = 8] = "stringLiteral"; + SymbolDisplayPartKind[SymbolDisplayPartKind["localName"] = 9] = "localName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["methodName"] = 10] = "methodName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["moduleName"] = 11] = "moduleName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["operator"] = 12] = "operator"; + SymbolDisplayPartKind[SymbolDisplayPartKind["parameterName"] = 13] = "parameterName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["propertyName"] = 14] = "propertyName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["punctuation"] = 15] = "punctuation"; + SymbolDisplayPartKind[SymbolDisplayPartKind["space"] = 16] = "space"; + SymbolDisplayPartKind[SymbolDisplayPartKind["text"] = 17] = "text"; + SymbolDisplayPartKind[SymbolDisplayPartKind["typeParameterName"] = 18] = "typeParameterName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["enumMemberName"] = 19] = "enumMemberName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["functionName"] = 20] = "functionName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["regularExpressionLiteral"] = 21] = "regularExpressionLiteral"; + })(ts.SymbolDisplayPartKind || (ts.SymbolDisplayPartKind = {})); + var SymbolDisplayPartKind = ts.SymbolDisplayPartKind; + (function (TokenClass) { + TokenClass[TokenClass["Punctuation"] = 0] = "Punctuation"; + TokenClass[TokenClass["Keyword"] = 1] = "Keyword"; + TokenClass[TokenClass["Operator"] = 2] = "Operator"; + TokenClass[TokenClass["Comment"] = 3] = "Comment"; + TokenClass[TokenClass["Whitespace"] = 4] = "Whitespace"; + TokenClass[TokenClass["Identifier"] = 5] = "Identifier"; + TokenClass[TokenClass["NumberLiteral"] = 6] = "NumberLiteral"; + TokenClass[TokenClass["StringLiteral"] = 7] = "StringLiteral"; + TokenClass[TokenClass["RegExpLiteral"] = 8] = "RegExpLiteral"; + })(ts.TokenClass || (ts.TokenClass = {})); + var TokenClass = ts.TokenClass; + var ScriptElementKind = (function () { + function ScriptElementKind() { + } + ScriptElementKind.unknown = ""; + ScriptElementKind.keyword = "keyword"; + ScriptElementKind.scriptElement = "script"; + ScriptElementKind.moduleElement = "module"; + ScriptElementKind.classElement = "class"; + ScriptElementKind.interfaceElement = "interface"; + ScriptElementKind.typeElement = "type"; + ScriptElementKind.enumElement = "enum"; + ScriptElementKind.variableElement = "var"; + ScriptElementKind.localVariableElement = "local var"; + ScriptElementKind.functionElement = "function"; + ScriptElementKind.localFunctionElement = "local function"; + ScriptElementKind.memberFunctionElement = "method"; + ScriptElementKind.memberGetAccessorElement = "getter"; + ScriptElementKind.memberSetAccessorElement = "setter"; + ScriptElementKind.memberVariableElement = "property"; + ScriptElementKind.constructorImplementationElement = "constructor"; + ScriptElementKind.callSignatureElement = "call"; + ScriptElementKind.indexSignatureElement = "index"; + ScriptElementKind.constructSignatureElement = "construct"; + ScriptElementKind.parameterElement = "parameter"; + ScriptElementKind.typeParameterElement = "type parameter"; + ScriptElementKind.primitiveType = "primitive type"; + ScriptElementKind.label = "label"; + ScriptElementKind.alias = "alias"; + ScriptElementKind.constElement = "const"; + ScriptElementKind.letElement = "let"; + return ScriptElementKind; + })(); + ts.ScriptElementKind = ScriptElementKind; + var ScriptElementKindModifier = (function () { + function ScriptElementKindModifier() { + } + ScriptElementKindModifier.none = ""; + ScriptElementKindModifier.publicMemberModifier = "public"; + ScriptElementKindModifier.privateMemberModifier = "private"; + ScriptElementKindModifier.protectedMemberModifier = "protected"; + ScriptElementKindModifier.exportedModifier = "export"; + ScriptElementKindModifier.ambientModifier = "declare"; + ScriptElementKindModifier.staticModifier = "static"; + return ScriptElementKindModifier; + })(); + ts.ScriptElementKindModifier = ScriptElementKindModifier; + var ClassificationTypeNames = (function () { + function ClassificationTypeNames() { + } + ClassificationTypeNames.comment = "comment"; + ClassificationTypeNames.identifier = "identifier"; + ClassificationTypeNames.keyword = "keyword"; + ClassificationTypeNames.numericLiteral = "number"; + ClassificationTypeNames.operator = "operator"; + ClassificationTypeNames.stringLiteral = "string"; + ClassificationTypeNames.whiteSpace = "whitespace"; + ClassificationTypeNames.text = "text"; + ClassificationTypeNames.punctuation = "punctuation"; + ClassificationTypeNames.className = "class name"; + ClassificationTypeNames.enumName = "enum name"; + ClassificationTypeNames.interfaceName = "interface name"; + ClassificationTypeNames.moduleName = "module name"; + ClassificationTypeNames.typeParameterName = "type parameter name"; + ClassificationTypeNames.typeAlias = "type alias name"; + return ClassificationTypeNames; + })(); + ts.ClassificationTypeNames = ClassificationTypeNames; + function displayPartsToString(displayParts) { + if (displayParts) { + return ts.map(displayParts, function (displayPart) { return displayPart.text; }).join(""); + } + return ""; + } + ts.displayPartsToString = displayPartsToString; + function isLocalVariableOrFunction(symbol) { + if (symbol.parent) { + return false; + } + return ts.forEach(symbol.declarations, function (declaration) { + if (declaration.kind === 160) { + return true; + } + if (declaration.kind !== 193 && declaration.kind !== 195) { + return false; + } + for (var parent = declaration.parent; !ts.isFunctionBlock(parent); parent = parent.parent) { + if (parent.kind === 220 || parent.kind === 201) { + return false; + } + } + return true; + }); + } + function getDefaultCompilerOptions() { + return { + target: 1, + module: 0 + }; + } + ts.getDefaultCompilerOptions = getDefaultCompilerOptions; + var OperationCanceledException = (function () { + function OperationCanceledException() { + } + return OperationCanceledException; + })(); + ts.OperationCanceledException = OperationCanceledException; + var CancellationTokenObject = (function () { + function CancellationTokenObject(cancellationToken) { + this.cancellationToken = cancellationToken; + } + CancellationTokenObject.prototype.isCancellationRequested = function () { + return this.cancellationToken && this.cancellationToken.isCancellationRequested(); + }; + CancellationTokenObject.prototype.throwIfCancellationRequested = function () { + if (this.isCancellationRequested()) { + throw new OperationCanceledException(); + } + }; + CancellationTokenObject.None = new CancellationTokenObject(null); + return CancellationTokenObject; + })(); + ts.CancellationTokenObject = CancellationTokenObject; + var HostCache = (function () { + function HostCache(host) { + this.host = host; + this.fileNameToEntry = {}; + var rootFileNames = host.getScriptFileNames(); + for (var i = 0, n = rootFileNames.length; i < n; i++) { + this.createEntry(rootFileNames[i]); + } + this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions(); + } + HostCache.prototype.compilationSettings = function () { + return this._compilationSettings; + }; + HostCache.prototype.createEntry = function (fileName) { + var entry; + var scriptSnapshot = this.host.getScriptSnapshot(fileName); + if (scriptSnapshot) { + entry = { + hostFileName: fileName, + version: this.host.getScriptVersion(fileName), + scriptSnapshot: scriptSnapshot + }; + } + return this.fileNameToEntry[ts.normalizeSlashes(fileName)] = entry; + }; + HostCache.prototype.getEntry = function (fileName) { + return ts.lookUp(this.fileNameToEntry, ts.normalizeSlashes(fileName)); + }; + HostCache.prototype.contains = function (fileName) { + return ts.hasProperty(this.fileNameToEntry, ts.normalizeSlashes(fileName)); + }; + HostCache.prototype.getOrCreateEntry = function (fileName) { + if (this.contains(fileName)) { + return this.getEntry(fileName); + } + return this.createEntry(fileName); + }; + HostCache.prototype.getRootFileNames = function () { + var _this = this; + var fileNames = []; + ts.forEachKey(this.fileNameToEntry, function (key) { + if (ts.hasProperty(_this.fileNameToEntry, key) && _this.fileNameToEntry[key]) + fileNames.push(key); + }); + return fileNames; + }; + HostCache.prototype.getVersion = function (fileName) { + var file = this.getEntry(fileName); + return file && file.version; + }; + HostCache.prototype.getScriptSnapshot = function (fileName) { + var file = this.getEntry(fileName); + return file && file.scriptSnapshot; + }; + return HostCache; + })(); + var SyntaxTreeCache = (function () { + function SyntaxTreeCache(host) { + this.host = host; + } + SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { + var scriptSnapshot = this.host.getScriptSnapshot(fileName); + if (!scriptSnapshot) { + throw new Error("Could not find file: '" + fileName + "'."); + } + var version = this.host.getScriptVersion(fileName); + var sourceFile; + if (this.currentFileName !== fileName) { + sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 2, version, true); + } + else if (this.currentFileVersion !== version) { + var editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot); + sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange); + } + if (sourceFile) { + this.currentFileVersion = version; + this.currentFileName = fileName; + this.currentFileScriptSnapshot = scriptSnapshot; + this.currentSourceFile = sourceFile; + } + return this.currentSourceFile; + }; + return SyntaxTreeCache; + })(); + function setSourceFileFields(sourceFile, scriptSnapshot, version) { + sourceFile.version = version; + sourceFile.scriptSnapshot = scriptSnapshot; + } + function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTarget, version, setNodeParents) { + var sourceFile = ts.createSourceFile(fileName, scriptSnapshot.getText(0, scriptSnapshot.getLength()), scriptTarget, setNodeParents); + setSourceFileFields(sourceFile, scriptSnapshot, version); + sourceFile.nameTable = sourceFile.identifiers; + return sourceFile; + } + ts.createLanguageServiceSourceFile = createLanguageServiceSourceFile; + ts.disableIncrementalParsing = false; + function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks) { + if (textChangeRange) { + if (version !== sourceFile.version) { + if (!ts.disableIncrementalParsing) { + var newSourceFile = ts.updateSourceFile(sourceFile, scriptSnapshot.getText(0, scriptSnapshot.getLength()), textChangeRange, aggressiveChecks); + setSourceFileFields(newSourceFile, scriptSnapshot, version); + newSourceFile.nameTable = undefined; + return newSourceFile; + } + } + } + return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, sourceFile.languageVersion, version, true); + } + ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; + function createDocumentRegistry() { + var buckets = {}; + function getKeyFromCompilationSettings(settings) { + return "_" + settings.target; + } + function getBucketForCompilationSettings(settings, createIfMissing) { + var key = getKeyFromCompilationSettings(settings); + var bucket = ts.lookUp(buckets, key); + if (!bucket && createIfMissing) { + buckets[key] = bucket = {}; + } + return bucket; + } + function reportStats() { + var bucketInfoArray = Object.keys(buckets).filter(function (name) { return name && name.charAt(0) === '_'; }).map(function (name) { + var entries = ts.lookUp(buckets, name); + var sourceFiles = []; + for (var i in entries) { + var entry = entries[i]; + sourceFiles.push({ + name: i, + refCount: entry.refCount, + references: entry.owners.slice(0) + }); + } + sourceFiles.sort(function (x, y) { return y.refCount - x.refCount; }); + return { + bucket: name, + sourceFiles: sourceFiles + }; + }); + return JSON.stringify(bucketInfoArray, null, 2); + } + function acquireDocument(fileName, compilationSettings, scriptSnapshot, version) { + var bucket = getBucketForCompilationSettings(compilationSettings, true); + var entry = ts.lookUp(bucket, fileName); + if (!entry) { + var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false); + bucket[fileName] = entry = { + sourceFile: sourceFile, + refCount: 0, + owners: [] + }; + } + entry.refCount++; + return entry.sourceFile; + } + function updateDocument(sourceFile, fileName, compilationSettings, scriptSnapshot, version, textChangeRange) { + var bucket = getBucketForCompilationSettings(compilationSettings, false); + ts.Debug.assert(bucket !== undefined); + var entry = ts.lookUp(bucket, fileName); + ts.Debug.assert(entry !== undefined); + entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version, textChangeRange); + return entry.sourceFile; + } + function releaseDocument(fileName, compilationSettings) { + var bucket = getBucketForCompilationSettings(compilationSettings, false); + ts.Debug.assert(bucket !== undefined); + var entry = ts.lookUp(bucket, fileName); + entry.refCount--; + ts.Debug.assert(entry.refCount >= 0); + if (entry.refCount === 0) { + delete bucket[fileName]; + } + } + return { + acquireDocument: acquireDocument, + updateDocument: updateDocument, + releaseDocument: releaseDocument, + reportStats: reportStats + }; + } + ts.createDocumentRegistry = createDocumentRegistry; + function preProcessFile(sourceText, readImportFiles) { + if (readImportFiles === void 0) { readImportFiles = true; } + var referencedFiles = []; + var importedFiles = []; + var isNoDefaultLib = false; + function processTripleSlashDirectives() { + var commentRanges = ts.getLeadingCommentRanges(sourceText, 0); + ts.forEach(commentRanges, function (commentRange) { + var comment = sourceText.substring(commentRange.pos, commentRange.end); + var referencePathMatchResult = ts.getFileReferenceFromReferencePath(comment, commentRange); + if (referencePathMatchResult) { + isNoDefaultLib = referencePathMatchResult.isNoDefaultLib; + var fileReference = referencePathMatchResult.fileReference; + if (fileReference) { + referencedFiles.push(fileReference); + } + } + }); + } + function processImport() { + scanner.setText(sourceText); + var token = scanner.scan(); + while (token !== 1) { + if (token === 84) { + token = scanner.scan(); + if (token === 64) { + token = scanner.scan(); + if (token === 52) { + token = scanner.scan(); + if (token === 118) { + token = scanner.scan(); + if (token === 16) { + token = scanner.scan(); + if (token === 8) { + var importPath = scanner.getTokenValue(); + var pos = scanner.getTokenPos(); + importedFiles.push({ + fileName: importPath, + pos: pos, + end: pos + importPath.length + }); + } + } + } + } + } + } + token = scanner.scan(); + } + scanner.setText(undefined); + } + if (readImportFiles) { + processImport(); + } + processTripleSlashDirectives(); + return { referencedFiles: referencedFiles, importedFiles: importedFiles, isLibFile: isNoDefaultLib }; + } + ts.preProcessFile = preProcessFile; + function getTargetLabel(referenceNode, labelName) { + while (referenceNode) { + if (referenceNode.kind === 189 && referenceNode.label.text === labelName) { + return referenceNode.label; + } + referenceNode = referenceNode.parent; + } + return undefined; + } + function isJumpStatementTarget(node) { + return node.kind === 64 && + (node.parent.kind === 185 || node.parent.kind === 184) && + node.parent.label === node; + } + function isLabelOfLabeledStatement(node) { + return node.kind === 64 && + node.parent.kind === 189 && + node.parent.label === node; + } + function isLabeledBy(node, labelName) { + for (var owner = node.parent; owner.kind === 189; owner = owner.parent) { + if (owner.label.text === labelName) { + return true; + } + } + return false; + } + function isLabelName(node) { + return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); + } + function isRightSideOfQualifiedName(node) { + return node.parent.kind === 125 && node.parent.right === node; + } + function isRightSideOfPropertyAccess(node) { + return node && node.parent && node.parent.kind === 153 && node.parent.name === node; + } + function isCallExpressionTarget(node) { + if (isRightSideOfPropertyAccess(node)) { + node = node.parent; + } + return node && node.parent && node.parent.kind === 155 && node.parent.expression === node; + } + function isNewExpressionTarget(node) { + if (isRightSideOfPropertyAccess(node)) { + node = node.parent; + } + return node && node.parent && node.parent.kind === 156 && node.parent.expression === node; + } + function isNameOfModuleDeclaration(node) { + return node.parent.kind === 200 && node.parent.name === node; + } + function isNameOfFunctionDeclaration(node) { + return node.kind === 64 && + ts.isAnyFunction(node.parent) && node.parent.name === node; + } + function isNameOfPropertyAssignment(node) { + return (node.kind === 64 || node.kind === 8 || node.kind === 7) && + (node.parent.kind === 217 || node.parent.kind === 218) && node.parent.name === node; + } + function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { + if (node.kind === 8 || node.kind === 7) { + switch (node.parent.kind) { + case 130: + case 129: + case 217: + case 219: + case 132: + case 131: + case 134: + case 135: + case 200: + return node.parent.name === node; + case 154: + return node.parent.argumentExpression === node; + } + } + return false; + } + function isNameOfExternalModuleImportOrDeclaration(node) { + if (node.kind === 8) { + return isNameOfModuleDeclaration(node) || + (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node); + } + return false; + } + function isInsideComment(sourceFile, token, position) { + return position <= token.getStart(sourceFile) && + (isInsideCommentRange(ts.getTrailingCommentRanges(sourceFile.text, token.getFullStart())) || + isInsideCommentRange(ts.getLeadingCommentRanges(sourceFile.text, token.getFullStart()))); + function isInsideCommentRange(comments) { + return ts.forEach(comments, function (comment) { + if (comment.pos < position && position < comment.end) { + return true; + } + else if (position === comment.end) { + var text = sourceFile.text; + var width = comment.end - comment.pos; + if (width <= 2 || text.charCodeAt(comment.pos + 1) === 47) { + return true; + } + else { + return !(text.charCodeAt(comment.end - 1) === 47 && + text.charCodeAt(comment.end - 2) === 42); + } + } + return false; + }); + } + } + var keywordCompletions = []; + for (var i = 65; i <= 124; i++) { + keywordCompletions.push({ + name: ts.tokenToString(i), + kind: ScriptElementKind.keyword, + kindModifiers: ScriptElementKindModifier.none + }); + } + function getContainerNode(node) { + while (true) { + node = node.parent; + if (!node) { + return undefined; + } + switch (node.kind) { + case 220: + case 132: + case 131: + case 195: + case 160: + case 134: + case 135: + case 196: + case 197: + case 199: + case 200: + return node; + } + } + } + ts.getContainerNode = getContainerNode; + function getNodeKind(node) { + switch (node.kind) { + case 200: return ScriptElementKind.moduleElement; + case 196: return ScriptElementKind.classElement; + case 197: return ScriptElementKind.interfaceElement; + case 198: return ScriptElementKind.typeElement; + case 199: return ScriptElementKind.enumElement; + case 193: + return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; + case 195: return ScriptElementKind.functionElement; + case 134: return ScriptElementKind.memberGetAccessorElement; + case 135: return ScriptElementKind.memberSetAccessorElement; + case 132: + case 131: + return ScriptElementKind.memberFunctionElement; + case 130: + case 129: + return ScriptElementKind.memberVariableElement; + case 138: return ScriptElementKind.indexSignatureElement; + case 137: return ScriptElementKind.constructSignatureElement; + case 136: return ScriptElementKind.callSignatureElement; + case 133: return ScriptElementKind.constructorImplementationElement; + case 127: return ScriptElementKind.typeParameterElement; + case 219: return ScriptElementKind.variableElement; + case 128: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; + } + return ScriptElementKind.unknown; + } + ts.getNodeKind = getNodeKind; + function createLanguageService(host, documentRegistry) { + if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(); } + var syntaxTreeCache = new SyntaxTreeCache(host); + var ruleProvider; + var program; + var typeInfoResolver; + var useCaseSensitivefileNames = false; + var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken()); + var activeCompletionSession; + if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) { + ts.localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages(); + } + function log(message) { + if (host.log) { + host.log(message); + } + } + function getCanonicalFileName(fileName) { + return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); + } + function getValidSourceFile(fileName) { + fileName = ts.normalizeSlashes(fileName); + var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); + if (!sourceFile) { + throw new Error("Could not find file: '" + fileName + "'."); + } + return sourceFile; + } + function getRuleProvider(options) { + if (!ruleProvider) { + ruleProvider = new ts.formatting.RulesProvider(); + } + ruleProvider.ensureUpToDate(options); + return ruleProvider; + } + function synchronizeHostData() { + var hostCache = new HostCache(host); + if (programUpToDate()) { + return; + } + var oldSettings = program && program.getCompilerOptions(); + var newSettings = hostCache.compilationSettings(); + var changesInCompilationSettingsAffectSyntax = oldSettings && oldSettings.target !== newSettings.target; + var newProgram = ts.createProgram(hostCache.getRootFileNames(), newSettings, { + getSourceFile: getOrCreateSourceFile, + getCancellationToken: function () { return cancellationToken; }, + getCanonicalFileName: function (fileName) { return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); }, + useCaseSensitiveFileNames: function () { return useCaseSensitivefileNames; }, + getNewLine: function () { return host.getNewLine ? host.getNewLine() : "\r\n"; }, + getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); }, + writeFile: function (fileName, data, writeByteOrderMark) { }, + getCurrentDirectory: function () { return host.getCurrentDirectory(); } + }); + if (program) { + var oldSourceFiles = program.getSourceFiles(); + for (var i = 0, n = oldSourceFiles.length; i < n; i++) { + var fileName = oldSourceFiles[i].fileName; + if (!newProgram.getSourceFile(fileName) || changesInCompilationSettingsAffectSyntax) { + documentRegistry.releaseDocument(fileName, oldSettings); + } + } + } + program = newProgram; + typeInfoResolver = program.getTypeChecker(); + return; + function getOrCreateSourceFile(fileName) { + var hostFileInformation = hostCache.getOrCreateEntry(fileName); + if (!hostFileInformation) { + return undefined; + } + if (!changesInCompilationSettingsAffectSyntax) { + var oldSourceFile = program && program.getSourceFile(fileName); + if (oldSourceFile) { + if (sourceFileUpToDate(oldSourceFile)) { + return oldSourceFile; + } + var textChangeRange = hostFileInformation.scriptSnapshot.getChangeRange(oldSourceFile.scriptSnapshot); + return documentRegistry.updateDocument(oldSourceFile, fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version, textChangeRange); + } + } + return documentRegistry.acquireDocument(fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version); + } + function sourceFileUpToDate(sourceFile) { + return sourceFile && sourceFile.version === hostCache.getVersion(sourceFile.fileName); + } + function programUpToDate() { + if (!program) { + return false; + } + var rootFileNames = hostCache.getRootFileNames(); + if (program.getSourceFiles().length !== rootFileNames.length) { + return false; + } + for (var i = 0, n = rootFileNames.length; i < n; i++) { + if (!sourceFileUpToDate(program.getSourceFile(rootFileNames[i]))) { + return false; + } + } + return ts.compareDataObjects(program.getCompilerOptions(), hostCache.compilationSettings()); + } + } + function getProgram() { + synchronizeHostData(); + return program; + } + function cleanupSemanticCache() { + if (program) { + typeInfoResolver = program.getTypeChecker(); + } + } + function dispose() { + if (program) { + ts.forEach(program.getSourceFiles(), function (f) { documentRegistry.releaseDocument(f.fileName, program.getCompilerOptions()); }); + } + } + function getSyntacticDiagnostics(fileName) { + synchronizeHostData(); + return program.getSyntacticDiagnostics(getValidSourceFile(fileName)); + } + function getSemanticDiagnostics(fileName) { + synchronizeHostData(); + var targetSourceFile = getValidSourceFile(fileName); + var semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile); + if (!program.getCompilerOptions().declaration) { + return semanticDiagnostics; + } + var declarationDiagnostics = program.getDeclarationDiagnostics(targetSourceFile); + return semanticDiagnostics.concat(declarationDiagnostics); + } + function getCompilerOptionsDiagnostics() { + synchronizeHostData(); + return program.getGlobalDiagnostics(); + } + function getValidCompletionEntryDisplayName(symbol, target) { + var displayName = symbol.getName(); + if (displayName && displayName.length > 0) { + var firstCharCode = displayName.charCodeAt(0); + if ((symbol.flags & 1536) && (firstCharCode === 39 || firstCharCode === 34)) { + return undefined; + } + if (displayName && displayName.length >= 2 && firstCharCode === displayName.charCodeAt(displayName.length - 1) && + (firstCharCode === 39 || firstCharCode === 34)) { + displayName = displayName.substring(1, displayName.length - 1); + } + var isValid = ts.isIdentifierStart(displayName.charCodeAt(0), target); + for (var i = 1, n = displayName.length; isValid && i < n; i++) { + isValid = ts.isIdentifierPart(displayName.charCodeAt(i), target); + } + if (isValid) { + return ts.unescapeIdentifier(displayName); + } + } + return undefined; + } + function createCompletionEntry(symbol, typeChecker, location) { + var displayName = getValidCompletionEntryDisplayName(symbol, program.getCompilerOptions().target); + if (!displayName) { + return undefined; + } + return { + name: displayName, + kind: getSymbolKind(symbol, typeChecker, location), + kindModifiers: getSymbolModifiers(symbol) + }; + } + function getCompletionsAtPosition(fileName, position) { + synchronizeHostData(); + var syntacticStart = new Date().getTime(); + var sourceFile = getValidSourceFile(fileName); + var start = new Date().getTime(); + var currentToken = ts.getTokenAtPosition(sourceFile, position); + log("getCompletionsAtPosition: Get current token: " + (new Date().getTime() - start)); + var start = new Date().getTime(); + var insideComment = isInsideComment(sourceFile, currentToken, position); + log("getCompletionsAtPosition: Is inside comment: " + (new Date().getTime() - start)); + if (insideComment) { + log("Returning an empty list because completion was inside a comment."); + return undefined; + } + var start = new Date().getTime(); + var previousToken = ts.findPrecedingToken(position, sourceFile); + log("getCompletionsAtPosition: Get previous token 1: " + (new Date().getTime() - start)); + if (previousToken && position <= previousToken.end && previousToken.kind === 64) { + var start = new Date().getTime(); + previousToken = ts.findPrecedingToken(previousToken.pos, sourceFile); + log("getCompletionsAtPosition: Get previous token 2: " + (new Date().getTime() - start)); + } + if (previousToken && isCompletionListBlocker(previousToken)) { + log("Returning an empty list because completion was requested in an invalid position."); + return undefined; + } + var node; + var isRightOfDot; + if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 153) { + node = previousToken.parent.expression; + isRightOfDot = true; + } + else if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 125) { + node = previousToken.parent.left; + isRightOfDot = true; + } + else { + node = currentToken; + isRightOfDot = false; + } + activeCompletionSession = { + fileName: fileName, + position: position, + entries: [], + symbols: {}, + typeChecker: typeInfoResolver + }; + log("getCompletionsAtPosition: Syntactic work: " + (new Date().getTime() - syntacticStart)); + var location = ts.getTouchingPropertyName(sourceFile, position); + var semanticStart = new Date().getTime(); + if (isRightOfDot) { + var symbols = []; + var isMemberCompletion = true; + var isNewIdentifierLocation = false; + if (node.kind === 64 || node.kind === 125 || node.kind === 153) { + var symbol = typeInfoResolver.getSymbolAtLocation(node); + if (symbol && symbol.flags & 8388608) { + symbol = typeInfoResolver.getAliasedSymbol(symbol); + } + if (symbol && symbol.flags & 1952) { + ts.forEachValue(symbol.exports, function (symbol) { + if (typeInfoResolver.isValidPropertyAccess((node.parent), symbol.name)) { + symbols.push(symbol); + } + }); + } + } + var type = typeInfoResolver.getTypeAtLocation(node); + if (type) { + ts.forEach(type.getApparentProperties(), function (symbol) { + if (typeInfoResolver.isValidPropertyAccess((node.parent), symbol.name)) { + symbols.push(symbol); + } + }); + } + getCompletionEntriesFromSymbols(symbols, activeCompletionSession); + } + else { + var containingObjectLiteral = getContainingObjectLiteralApplicableForCompletion(previousToken); + if (containingObjectLiteral) { + isMemberCompletion = true; + isNewIdentifierLocation = true; + var contextualType = typeInfoResolver.getContextualType(containingObjectLiteral); + if (!contextualType) { + return undefined; + } + var contextualTypeMembers = typeInfoResolver.getPropertiesOfType(contextualType); + if (contextualTypeMembers && contextualTypeMembers.length > 0) { + var filteredMembers = filterContextualMembersList(contextualTypeMembers, containingObjectLiteral.properties); + getCompletionEntriesFromSymbols(filteredMembers, activeCompletionSession); + } + } + else { + isMemberCompletion = false; + isNewIdentifierLocation = isNewIdentifierDefinitionLocation(previousToken); + var symbolMeanings = 793056 | 107455 | 1536 | 8388608; + var symbols = typeInfoResolver.getSymbolsInScope(node, symbolMeanings); + getCompletionEntriesFromSymbols(symbols, activeCompletionSession); + } + } + if (!isMemberCompletion) { + Array.prototype.push.apply(activeCompletionSession.entries, keywordCompletions); + } + log("getCompletionsAtPosition: Semantic work: " + (new Date().getTime() - semanticStart)); + return { + isMemberCompletion: isMemberCompletion, + isNewIdentifierLocation: isNewIdentifierLocation, + isBuilder: isNewIdentifierDefinitionLocation, + entries: activeCompletionSession.entries + }; + function getCompletionEntriesFromSymbols(symbols, session) { + var start = new Date().getTime(); + ts.forEach(symbols, function (symbol) { + var entry = createCompletionEntry(symbol, session.typeChecker, location); + if (entry) { + var id = ts.escapeIdentifier(entry.name); + if (!ts.lookUp(session.symbols, id)) { + session.entries.push(entry); + session.symbols[id] = symbol; + } + } + }); + log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (new Date().getTime() - start)); + } + function isCompletionListBlocker(previousToken) { + var start = new Date().getTime(); + var result = isInStringOrRegularExpressionOrTemplateLiteral(previousToken) || + isIdentifierDefinitionLocation(previousToken) || + isRightOfIllegalDot(previousToken); + log("getCompletionsAtPosition: isCompletionListBlocker: " + (new Date().getTime() - start)); + return result; + } + function isNewIdentifierDefinitionLocation(previousToken) { + if (previousToken) { + var containingNodeKind = previousToken.parent.kind; + switch (previousToken.kind) { + case 23: + return containingNodeKind === 155 || containingNodeKind === 133 || containingNodeKind === 156 || containingNodeKind === 151 || containingNodeKind === 167; + case 16: + return containingNodeKind === 155 || containingNodeKind === 133 || containingNodeKind === 156 || containingNodeKind === 159; + case 18: + return containingNodeKind === 151; + case 117: + return true; + case 20: + return containingNodeKind === 200; + case 14: + return containingNodeKind === 196; + case 52: + return containingNodeKind === 193 || containingNodeKind === 167; + case 11: + return containingNodeKind === 169; + case 12: + return containingNodeKind === 173; + case 109: + case 107: + case 108: + return containingNodeKind === 130; + } + switch (previousToken.getText()) { + case "public": + case "protected": + case "private": + return true; + } + } + return false; + } + function isInStringOrRegularExpressionOrTemplateLiteral(previousToken) { + if (previousToken.kind === 8 || previousToken.kind === 9 || ts.isTemplateLiteralKind(previousToken.kind)) { + var start = previousToken.getStart(); + var end = previousToken.getEnd(); + if (start < position && position < end) { + return true; + } + else if (position === end) { + return !!previousToken.isUnterminated; + } + } + return false; + } + function getContainingObjectLiteralApplicableForCompletion(previousToken) { + if (previousToken) { + var parent = previousToken.parent; + switch (previousToken.kind) { + case 14: + case 23: + if (parent && parent.kind === 152) { + return parent; + } + break; + } + } + return undefined; + } + function isFunction(kind) { + switch (kind) { + case 160: + case 161: + case 195: + case 132: + case 131: + case 134: + case 135: + case 136: + case 137: + case 138: + return true; + } + return false; + } + function isIdentifierDefinitionLocation(previousToken) { + if (previousToken) { + var containingNodeKind = previousToken.parent.kind; + switch (previousToken.kind) { + case 23: + return containingNodeKind === 193 || + containingNodeKind === 194 || + containingNodeKind === 175 || + containingNodeKind === 199 || + isFunction(containingNodeKind) || + containingNodeKind === 196 || + containingNodeKind === 195 || + containingNodeKind === 197 || + containingNodeKind === 149 || + containingNodeKind === 148; + case 20: + return containingNodeKind === 149; + case 18: + return containingNodeKind === 149; + case 16: + return containingNodeKind === 216 || + isFunction(containingNodeKind); + case 14: + return containingNodeKind === 199 || + containingNodeKind === 197 || + containingNodeKind === 143 || + containingNodeKind === 148; + case 22: + return containingNodeKind === 129 && + (previousToken.parent.parent.kind === 197 || + previousToken.parent.parent.kind === 143); + case 24: + return containingNodeKind === 196 || + containingNodeKind === 195 || + containingNodeKind === 197 || + isFunction(containingNodeKind); + case 110: + return containingNodeKind === 130; + case 21: + return containingNodeKind === 128 || + containingNodeKind === 133 || + (previousToken.parent.parent.kind === 149); + case 109: + case 107: + case 108: + return containingNodeKind === 128; + case 68: + case 76: + case 104: + case 82: + case 97: + case 116: + case 120: + case 84: + case 105: + case 69: + case 111: + return true; + } + switch (previousToken.getText()) { + case "class": + case "interface": + case "enum": + case "function": + case "var": + case "static": + case "let": + case "const": + case "yield": + return true; + } + } + return false; + } + function isRightOfIllegalDot(previousToken) { + if (previousToken && previousToken.kind === 7) { + var text = previousToken.getFullText(); + return text.charAt(text.length - 1) === "."; + } + return false; + } + function filterContextualMembersList(contextualMemberSymbols, existingMembers) { + if (!existingMembers || existingMembers.length === 0) { + return contextualMemberSymbols; + } + var existingMemberNames = {}; + ts.forEach(existingMembers, function (m) { + if (m.kind !== 217 && m.kind !== 218) { + return; + } + if (m.getStart() <= position && position <= m.getEnd()) { + return; + } + existingMemberNames[m.name.text] = true; + }); + var filteredMembers = []; + ts.forEach(contextualMemberSymbols, function (s) { + if (!existingMemberNames[s.name]) { + filteredMembers.push(s); + } + }); + return filteredMembers; + } + } + function getCompletionEntryDetails(fileName, position, entryName) { + var sourceFile = getValidSourceFile(fileName); + var session = activeCompletionSession; + if (!session || session.fileName !== fileName || session.position !== position) { + return undefined; + } + var symbol = ts.lookUp(activeCompletionSession.symbols, ts.escapeIdentifier(entryName)); + if (symbol) { + var location = ts.getTouchingPropertyName(sourceFile, position); + var completionEntry = createCompletionEntry(symbol, session.typeChecker, location); + ts.Debug.assert(session.typeChecker.getTypeOfSymbolAtLocation(symbol, location) !== undefined, "Could not find type for symbol"); + var displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getValidSourceFile(fileName), location, session.typeChecker, location, 7); + return { + name: entryName, + kind: displayPartsDocumentationsAndSymbolKind.symbolKind, + kindModifiers: completionEntry.kindModifiers, + displayParts: displayPartsDocumentationsAndSymbolKind.displayParts, + documentation: displayPartsDocumentationsAndSymbolKind.documentation + }; + } + else { + return { + name: entryName, + kind: ScriptElementKind.keyword, + kindModifiers: ScriptElementKindModifier.none, + displayParts: [ts.displayPart(entryName, 5)], + documentation: undefined + }; + } + } + function getSymbolKind(symbol, typeResolver, location) { + var flags = symbol.getFlags(); + if (flags & 32) + return ScriptElementKind.classElement; + if (flags & 384) + return ScriptElementKind.enumElement; + if (flags & 524288) + return ScriptElementKind.typeElement; + if (flags & 64) + return ScriptElementKind.interfaceElement; + if (flags & 262144) + return ScriptElementKind.typeParameterElement; + var result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, flags, typeResolver, location); + if (result === ScriptElementKind.unknown) { + if (flags & 262144) + return ScriptElementKind.typeParameterElement; + if (flags & 8) + return ScriptElementKind.variableElement; + if (flags & 8388608) + return ScriptElementKind.alias; + if (flags & 1536) + return ScriptElementKind.moduleElement; + } + return result; + } + function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, flags, typeResolver, location) { + if (typeResolver.isUndefinedSymbol(symbol)) { + return ScriptElementKind.variableElement; + } + if (typeResolver.isArgumentsSymbol(symbol)) { + return ScriptElementKind.localVariableElement; + } + if (flags & 3) { + if (ts.isFirstDeclarationOfSymbolParameter(symbol)) { + return ScriptElementKind.parameterElement; + } + else if (symbol.valueDeclaration && ts.isConst(symbol.valueDeclaration)) { + return ScriptElementKind.constElement; + } + else if (ts.forEach(symbol.declarations, ts.isLet)) { + return ScriptElementKind.letElement; + } + return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement; + } + if (flags & 16) + return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localFunctionElement : ScriptElementKind.functionElement; + if (flags & 32768) + return ScriptElementKind.memberGetAccessorElement; + if (flags & 65536) + return ScriptElementKind.memberSetAccessorElement; + if (flags & 8192) + return ScriptElementKind.memberFunctionElement; + if (flags & 16384) + return ScriptElementKind.constructorImplementationElement; + if (flags & 4) { + if (flags & 268435456) { + var unionPropertyKind = ts.forEach(typeInfoResolver.getRootSymbols(symbol), function (rootSymbol) { + var rootSymbolFlags = rootSymbol.getFlags(); + if (rootSymbolFlags & (98308 | 3)) { + return ScriptElementKind.memberVariableElement; + } + ts.Debug.assert(!!(rootSymbolFlags & 8192)); + }); + if (!unionPropertyKind) { + var typeOfUnionProperty = typeInfoResolver.getTypeOfSymbolAtLocation(symbol, location); + if (typeOfUnionProperty.getCallSignatures().length) { + return ScriptElementKind.memberFunctionElement; + } + return ScriptElementKind.memberVariableElement; + } + return unionPropertyKind; + } + return ScriptElementKind.memberVariableElement; + } + return ScriptElementKind.unknown; + } + function getTypeKind(type) { + var flags = type.getFlags(); + if (flags & 128) + return ScriptElementKind.enumElement; + if (flags & 1024) + return ScriptElementKind.classElement; + if (flags & 2048) + return ScriptElementKind.interfaceElement; + if (flags & 512) + return ScriptElementKind.typeParameterElement; + if (flags & 1048703) + return ScriptElementKind.primitiveType; + if (flags & 256) + return ScriptElementKind.primitiveType; + return ScriptElementKind.unknown; + } + function getSymbolModifiers(symbol) { + return symbol && symbol.declarations && symbol.declarations.length > 0 ? ts.getNodeModifiers(symbol.declarations[0]) : ScriptElementKindModifier.none; + } + function getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, sourceFile, enclosingDeclaration, typeResolver, location, semanticMeaning) { + if (semanticMeaning === void 0) { semanticMeaning = getMeaningFromLocation(location); } + var displayParts = []; + var documentation; + var symbolFlags = symbol.flags; + var symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, symbolFlags, typeResolver, location); + var hasAddedSymbolInfo; + if (symbolKind !== ScriptElementKind.unknown || symbolFlags & 32 || symbolFlags & 8388608) { + if (symbolKind === ScriptElementKind.memberGetAccessorElement || symbolKind === ScriptElementKind.memberSetAccessorElement) { + symbolKind = ScriptElementKind.memberVariableElement; + } + var type = typeResolver.getTypeOfSymbolAtLocation(symbol, location); + if (type) { + if (location.parent && location.parent.kind === 153) { + var right = location.parent.name; + if (right === location || (right && right.getFullWidth() === 0)) { + location = location.parent; + } + } + var callExpression; + if (location.kind === 155 || location.kind === 156) { + callExpression = location; + } + else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { + callExpression = location.parent; + } + if (callExpression) { + var candidateSignatures = []; + signature = typeResolver.getResolvedSignature(callExpression, candidateSignatures); + if (!signature && candidateSignatures.length) { + signature = candidateSignatures[0]; + } + var useConstructSignatures = callExpression.kind === 156 || callExpression.expression.kind === 90; + var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); + if (!ts.contains(allSignatures, signature.target || signature)) { + signature = allSignatures.length ? allSignatures[0] : undefined; + } + if (signature) { + if (useConstructSignatures && (symbolFlags & 32)) { + symbolKind = ScriptElementKind.constructorImplementationElement; + addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); + } + else if (symbolFlags & 8388608) { + symbolKind = ScriptElementKind.alias; + displayParts.push(ts.punctuationPart(16)); + displayParts.push(ts.textPart(symbolKind)); + displayParts.push(ts.punctuationPart(17)); + displayParts.push(ts.spacePart()); + if (useConstructSignatures) { + displayParts.push(ts.keywordPart(87)); + displayParts.push(ts.spacePart()); + } + addFullSymbolName(symbol); + } + else { + addPrefixForAnyFunctionOrVar(symbol, symbolKind); + } + switch (symbolKind) { + case ScriptElementKind.memberVariableElement: + case ScriptElementKind.variableElement: + case ScriptElementKind.constElement: + case ScriptElementKind.letElement: + case ScriptElementKind.parameterElement: + case ScriptElementKind.localVariableElement: + displayParts.push(ts.punctuationPart(51)); + displayParts.push(ts.spacePart()); + if (useConstructSignatures) { + displayParts.push(ts.keywordPart(87)); + displayParts.push(ts.spacePart()); + } + if (!(type.flags & 32768)) { + displayParts.push.apply(displayParts, ts.symbolToDisplayParts(typeResolver, type.symbol, enclosingDeclaration, undefined, 1)); + } + addSignatureDisplayParts(signature, allSignatures, 8); + break; + default: + addSignatureDisplayParts(signature, allSignatures); + } + hasAddedSymbolInfo = true; + } + } + else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304)) || + (location.kind === 114 && location.parent.kind === 133)) { + var signature; + var functionDeclaration = location.parent; + var allSignatures = functionDeclaration.kind === 133 ? type.getConstructSignatures() : type.getCallSignatures(); + if (!typeResolver.isImplementationOfOverload(functionDeclaration)) { + signature = typeResolver.getSignatureFromDeclaration(functionDeclaration); + } + else { + signature = allSignatures[0]; + } + if (functionDeclaration.kind === 133) { + symbolKind = ScriptElementKind.constructorImplementationElement; + addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); + } + else { + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 136 && + !(type.symbol.flags & 2048 || type.symbol.flags & 4096) ? type.symbol : symbol, symbolKind); + } + addSignatureDisplayParts(signature, allSignatures); + hasAddedSymbolInfo = true; + } + } + } + if (symbolFlags & 32 && !hasAddedSymbolInfo) { + displayParts.push(ts.keywordPart(68)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + writeTypeParametersOfSymbol(symbol, sourceFile); + } + if ((symbolFlags & 64) && (semanticMeaning & 2)) { + addNewLineIfDisplayPartsExist(); + displayParts.push(ts.keywordPart(104)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + writeTypeParametersOfSymbol(symbol, sourceFile); + } + if (symbolFlags & 524288) { + addNewLineIfDisplayPartsExist(); + displayParts.push(ts.keywordPart(123)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(52)); + displayParts.push(ts.spacePart()); + displayParts.push.apply(displayParts, ts.typeToDisplayParts(typeResolver, typeResolver.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration)); + } + if (symbolFlags & 384) { + addNewLineIfDisplayPartsExist(); + if (ts.forEach(symbol.declarations, ts.isConstEnumDeclaration)) { + displayParts.push(ts.keywordPart(69)); + displayParts.push(ts.spacePart()); + } + displayParts.push(ts.keywordPart(76)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + } + if (symbolFlags & 1536) { + addNewLineIfDisplayPartsExist(); + displayParts.push(ts.keywordPart(117)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + } + if ((symbolFlags & 262144) && (semanticMeaning & 2)) { + addNewLineIfDisplayPartsExist(); + displayParts.push(ts.punctuationPart(16)); + displayParts.push(ts.textPart("type parameter")); + displayParts.push(ts.punctuationPart(17)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + displayParts.push(ts.spacePart()); + displayParts.push(ts.keywordPart(85)); + displayParts.push(ts.spacePart()); + if (symbol.parent) { + addFullSymbolName(symbol.parent, enclosingDeclaration); + writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration); + } + else { + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 127).parent; + var signature = typeResolver.getSignatureFromDeclaration(signatureDeclaration); + if (signatureDeclaration.kind === 137) { + displayParts.push(ts.keywordPart(87)); + displayParts.push(ts.spacePart()); + } + else if (signatureDeclaration.kind !== 136 && signatureDeclaration.name) { + addFullSymbolName(signatureDeclaration.symbol); + } + displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeResolver, signature, sourceFile, 32)); + } + } + if (symbolFlags & 8) { + addPrefixForAnyFunctionOrVar(symbol, "enum member"); + var declaration = symbol.declarations[0]; + if (declaration.kind === 219) { + var constantValue = typeResolver.getConstantValue(declaration); + if (constantValue !== undefined) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(52)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.displayPart(constantValue.toString(), 7)); + } + } + } + if (symbolFlags & 8388608) { + addNewLineIfDisplayPartsExist(); + displayParts.push(ts.keywordPart(84)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + ts.forEach(symbol.declarations, function (declaration) { + if (declaration.kind === 202) { + var importEqualsDeclaration = declaration; + if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(52)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.keywordPart(118)); + displayParts.push(ts.punctuationPart(16)); + displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), 8)); + displayParts.push(ts.punctuationPart(17)); + } + else { + var internalAliasSymbol = typeResolver.getSymbolAtLocation(importEqualsDeclaration.moduleReference); + if (internalAliasSymbol) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(52)); + displayParts.push(ts.spacePart()); + addFullSymbolName(internalAliasSymbol, enclosingDeclaration); + } + } + return true; + } + }); + } + if (!hasAddedSymbolInfo) { + if (symbolKind !== ScriptElementKind.unknown) { + if (type) { + addPrefixForAnyFunctionOrVar(symbol, symbolKind); + if (symbolKind === ScriptElementKind.memberVariableElement || + symbolFlags & 3 || + symbolKind === ScriptElementKind.localVariableElement) { + displayParts.push(ts.punctuationPart(51)); + displayParts.push(ts.spacePart()); + if (type.symbol && type.symbol.flags & 262144) { + var typeParameterParts = ts.mapToDisplayParts(function (writer) { + typeResolver.getSymbolDisplayBuilder().buildTypeParameterDisplay(type, writer, enclosingDeclaration); + }); + displayParts.push.apply(displayParts, typeParameterParts); + } + else { + displayParts.push.apply(displayParts, ts.typeToDisplayParts(typeResolver, type, enclosingDeclaration)); + } + } + else if (symbolFlags & 16 || + symbolFlags & 8192 || + symbolFlags & 16384 || + symbolFlags & 131072 || + symbolFlags & 98304 || + symbolKind === ScriptElementKind.memberFunctionElement) { + var allSignatures = type.getCallSignatures(); + addSignatureDisplayParts(allSignatures[0], allSignatures); + } + } + } + else { + symbolKind = getSymbolKind(symbol, typeResolver, location); + } + } + if (!documentation) { + documentation = symbol.getDocumentationComment(); + } + return { displayParts: displayParts, documentation: documentation, symbolKind: symbolKind }; + function addNewLineIfDisplayPartsExist() { + if (displayParts.length) { + displayParts.push(ts.lineBreakPart()); + } + } + function addFullSymbolName(symbol, enclosingDeclaration) { + var fullSymbolDisplayParts = ts.symbolToDisplayParts(typeResolver, symbol, enclosingDeclaration || sourceFile, undefined, 1 | 2); + displayParts.push.apply(displayParts, fullSymbolDisplayParts); + } + function addPrefixForAnyFunctionOrVar(symbol, symbolKind) { + addNewLineIfDisplayPartsExist(); + if (symbolKind) { + displayParts.push(ts.punctuationPart(16)); + displayParts.push(ts.textPart(symbolKind)); + displayParts.push(ts.punctuationPart(17)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + } + } + function addSignatureDisplayParts(signature, allSignatures, flags) { + displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeResolver, signature, enclosingDeclaration, flags | 32)); + if (allSignatures.length > 1) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.punctuationPart(16)); + displayParts.push(ts.operatorPart(33)); + displayParts.push(ts.displayPart((allSignatures.length - 1).toString(), 7)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.textPart(allSignatures.length === 2 ? "overload" : "overloads")); + displayParts.push(ts.punctuationPart(17)); + } + documentation = signature.getDocumentationComment(); + } + function writeTypeParametersOfSymbol(symbol, enclosingDeclaration) { + var typeParameterParts = ts.mapToDisplayParts(function (writer) { + typeResolver.getSymbolDisplayBuilder().buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration); + }); + displayParts.push.apply(displayParts, typeParameterParts); + } + } + function getQuickInfoAtPosition(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, position); + if (!node) { + return undefined; + } + var symbol = typeInfoResolver.getSymbolAtLocation(node); + if (!symbol) { + switch (node.kind) { + case 64: + case 153: + case 125: + case 92: + case 90: + var type = typeInfoResolver.getTypeAtLocation(node); + if (type) { + return { + kind: ScriptElementKind.unknown, + kindModifiers: ScriptElementKindModifier.none, + textSpan: ts.createTextSpan(node.getStart(), node.getWidth()), + displayParts: ts.typeToDisplayParts(typeInfoResolver, type, getContainerNode(node)), + documentation: type.symbol ? type.symbol.getDocumentationComment() : undefined + }; + } + } + return undefined; + } + var displayPartsDocumentationsAndKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, sourceFile, getContainerNode(node), typeInfoResolver, node); + return { + kind: displayPartsDocumentationsAndKind.symbolKind, + kindModifiers: getSymbolModifiers(symbol), + textSpan: ts.createTextSpan(node.getStart(), node.getWidth()), + displayParts: displayPartsDocumentationsAndKind.displayParts, + documentation: displayPartsDocumentationsAndKind.documentation + }; + } + function getDefinitionAtPosition(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, position); + if (!node) { + return undefined; + } + if (isJumpStatementTarget(node)) { + var labelName = node.text; + var label = getTargetLabel(node.parent, node.text); + return label ? [getDefinitionInfo(label, ScriptElementKind.label, labelName, undefined)] : undefined; + } + var comment = ts.forEach(sourceFile.referencedFiles, function (r) { return (r.pos <= position && position < r.end) ? r : undefined; }); + if (comment) { + var referenceFile = ts.tryResolveScriptReference(program, sourceFile, comment); + if (referenceFile) { + return [{ + fileName: referenceFile.fileName, + textSpan: ts.createTextSpanFromBounds(0, 0), + kind: ScriptElementKind.scriptElement, + name: comment.fileName, + containerName: undefined, + containerKind: undefined + }]; + } + return undefined; + } + var symbol = typeInfoResolver.getSymbolAtLocation(node); + if (!symbol) { + return undefined; + } + var result = []; + if (node.parent.kind === 218) { + var shorthandSymbol = typeInfoResolver.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); + var shorthandDeclarations = shorthandSymbol.getDeclarations(); + var shorthandSymbolKind = getSymbolKind(shorthandSymbol, typeInfoResolver, node); + var shorthandSymbolName = typeInfoResolver.symbolToString(shorthandSymbol); + var shorthandContainerName = typeInfoResolver.symbolToString(symbol.parent, node); + ts.forEach(shorthandDeclarations, function (declaration) { + result.push(getDefinitionInfo(declaration, shorthandSymbolKind, shorthandSymbolName, shorthandContainerName)); + }); + return result; + } + var declarations = symbol.getDeclarations(); + var symbolName = typeInfoResolver.symbolToString(symbol); + var symbolKind = getSymbolKind(symbol, typeInfoResolver, node); + var containerSymbol = symbol.parent; + var containerName = containerSymbol ? typeInfoResolver.symbolToString(containerSymbol, node) : ""; + if (!tryAddConstructSignature(symbol, node, symbolKind, symbolName, containerName, result) && + !tryAddCallSignature(symbol, node, symbolKind, symbolName, containerName, result)) { + ts.forEach(declarations, function (declaration) { + result.push(getDefinitionInfo(declaration, symbolKind, symbolName, containerName)); + }); + } + return result; + function getDefinitionInfo(node, symbolKind, symbolName, containerName) { + return { + fileName: node.getSourceFile().fileName, + textSpan: ts.createTextSpanFromBounds(node.getStart(), node.getEnd()), + kind: symbolKind, + name: symbolName, + containerKind: undefined, + containerName: containerName + }; + } + function tryAddSignature(signatureDeclarations, selectConstructors, symbolKind, symbolName, containerName, result) { + var declarations = []; + var definition; + ts.forEach(signatureDeclarations, function (d) { + if ((selectConstructors && d.kind === 133) || + (!selectConstructors && (d.kind === 195 || d.kind === 132 || d.kind === 131))) { + declarations.push(d); + if (d.body) + definition = d; + } + }); + if (definition) { + result.push(getDefinitionInfo(definition, symbolKind, symbolName, containerName)); + return true; + } + else if (declarations.length) { + result.push(getDefinitionInfo(declarations[declarations.length - 1], symbolKind, symbolName, containerName)); + return true; + } + return false; + } + function tryAddConstructSignature(symbol, location, symbolKind, symbolName, containerName, result) { + if (isNewExpressionTarget(location) || location.kind === 114) { + if (symbol.flags & 32) { + var classDeclaration = symbol.getDeclarations()[0]; + ts.Debug.assert(classDeclaration && classDeclaration.kind === 196); + return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); + } + } + return false; + } + function tryAddCallSignature(symbol, location, symbolKind, symbolName, containerName, result) { + if (isCallExpressionTarget(location) || isNewExpressionTarget(location) || isNameOfFunctionDeclaration(location)) { + return tryAddSignature(symbol.declarations, false, symbolKind, symbolName, containerName, result); + } + return false; + } + } + function getOccurrencesAtPosition(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingWord(sourceFile, position); + if (!node) { + return undefined; + } + if (node.kind === 64 || node.kind === 92 || node.kind === 90 || + isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) { + return getReferencesForNode(node, [sourceFile], true, false, false); + } + switch (node.kind) { + case 83: + case 75: + if (hasKind(node.parent, 178)) { + return getIfElseOccurrences(node.parent); + } + break; + case 89: + if (hasKind(node.parent, 186)) { + return getReturnOccurrences(node.parent); + } + break; + case 93: + if (hasKind(node.parent, 190)) { + return getThrowOccurrences(node.parent); + } + break; + case 67: + if (hasKind(parent(parent(node)), 191)) { + return getTryCatchFinallyOccurrences(node.parent.parent); + } + break; + case 95: + case 80: + if (hasKind(parent(node), 191)) { + return getTryCatchFinallyOccurrences(node.parent); + } + break; + case 91: + if (hasKind(node.parent, 188)) { + return getSwitchCaseDefaultOccurrences(node.parent); + } + break; + case 66: + case 72: + if (hasKind(parent(parent(node)), 188)) { + return getSwitchCaseDefaultOccurrences(node.parent.parent); + } + break; + case 65: + case 70: + if (hasKind(node.parent, 185) || hasKind(node.parent, 184)) { + return getBreakOrContinueStatementOccurences(node.parent); + } + break; + case 81: + if (hasKind(node.parent, 181) || + hasKind(node.parent, 182) || + hasKind(node.parent, 183)) { + return getLoopBreakContinueOccurrences(node.parent); + } + break; + case 99: + case 74: + if (hasKind(node.parent, 180) || hasKind(node.parent, 179)) { + return getLoopBreakContinueOccurrences(node.parent); + } + break; + case 114: + if (hasKind(node.parent, 133)) { + return getConstructorOccurrences(node.parent); + } + break; + case 116: + case 120: + if (hasKind(node.parent, 134) || hasKind(node.parent, 135)) { + return getGetAndSetOccurrences(node.parent); + } + default: + if (ts.isModifier(node.kind) && node.parent && + (ts.isDeclaration(node.parent) || node.parent.kind === 175)) { + return getModifierOccurrences(node.kind, node.parent); + } + } + return undefined; + function getIfElseOccurrences(ifStatement) { + var keywords = []; + while (hasKind(ifStatement.parent, 178) && ifStatement.parent.elseStatement === ifStatement) { + ifStatement = ifStatement.parent; + } + while (ifStatement) { + var children = ifStatement.getChildren(); + pushKeywordIf(keywords, children[0], 83); + for (var i = children.length - 1; i >= 0; i--) { + if (pushKeywordIf(keywords, children[i], 75)) { + break; + } + } + if (!hasKind(ifStatement.elseStatement, 178)) { + break; + } + ifStatement = ifStatement.elseStatement; + } + var result = []; + for (var i = 0; i < keywords.length; i++) { + if (keywords[i].kind === 75 && i < keywords.length - 1) { + var elseKeyword = keywords[i]; + var ifKeyword = keywords[i + 1]; + var shouldHighlightNextKeyword = true; + for (var j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) { + if (!ts.isWhiteSpace(sourceFile.text.charCodeAt(j))) { + shouldHighlightNextKeyword = false; + break; + } + } + if (shouldHighlightNextKeyword) { + result.push({ + fileName: fileName, + textSpan: ts.createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end), + isWriteAccess: false + }); + i++; + continue; + } + } + result.push(getReferenceEntryFromNode(keywords[i])); + } + return result; + } + function getReturnOccurrences(returnStatement) { + var func = ts.getContainingFunction(returnStatement); + if (!(func && hasKind(func.body, 174))) { + return undefined; + } + var keywords = []; + ts.forEachReturnStatement(func.body, function (returnStatement) { + pushKeywordIf(keywords, returnStatement.getFirstToken(), 89); + }); + ts.forEach(aggregateOwnedThrowStatements(func.body), function (throwStatement) { + pushKeywordIf(keywords, throwStatement.getFirstToken(), 93); + }); + return ts.map(keywords, getReferenceEntryFromNode); + } + function getThrowOccurrences(throwStatement) { + var owner = getThrowStatementOwner(throwStatement); + if (!owner) { + return undefined; + } + var keywords = []; + ts.forEach(aggregateOwnedThrowStatements(owner), function (throwStatement) { + pushKeywordIf(keywords, throwStatement.getFirstToken(), 93); + }); + if (ts.isFunctionBlock(owner)) { + ts.forEachReturnStatement(owner, function (returnStatement) { + pushKeywordIf(keywords, returnStatement.getFirstToken(), 89); + }); + } + return ts.map(keywords, getReferenceEntryFromNode); + } + function aggregateOwnedThrowStatements(node) { + var statementAccumulator = []; + aggregate(node); + return statementAccumulator; + function aggregate(node) { + if (node.kind === 190) { + statementAccumulator.push(node); + } + else if (node.kind === 191) { + var tryStatement = node; + if (tryStatement.catchClause) { + aggregate(tryStatement.catchClause); + } + else { + aggregate(tryStatement.tryBlock); + } + if (tryStatement.finallyBlock) { + aggregate(tryStatement.finallyBlock); + } + } + else if (!ts.isAnyFunction(node)) { + ts.forEachChild(node, aggregate); + } + } + ; + } + function getThrowStatementOwner(throwStatement) { + var child = throwStatement; + while (child.parent) { + var parent = child.parent; + if (ts.isFunctionBlock(parent) || parent.kind === 220) { + return parent; + } + if (parent.kind === 191) { + var tryStatement = parent; + if (tryStatement.tryBlock === child && tryStatement.catchClause) { + return child; + } + } + child = parent; + } + return undefined; + } + function getTryCatchFinallyOccurrences(tryStatement) { + var keywords = []; + pushKeywordIf(keywords, tryStatement.getFirstToken(), 95); + if (tryStatement.catchClause) { + pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), 67); + } + if (tryStatement.finallyBlock) { + var finallyKeyword = ts.findChildOfKind(tryStatement, 80, sourceFile); + pushKeywordIf(keywords, finallyKeyword, 80); + } + return ts.map(keywords, getReferenceEntryFromNode); + } + function getLoopBreakContinueOccurrences(loopNode) { + var keywords = []; + if (pushKeywordIf(keywords, loopNode.getFirstToken(), 81, 99, 74)) { + if (loopNode.kind === 179) { + var loopTokens = loopNode.getChildren(); + for (var i = loopTokens.length - 1; i >= 0; i--) { + if (pushKeywordIf(keywords, loopTokens[i], 99)) { + break; + } + } + } + } + var breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement); + ts.forEach(breaksAndContinues, function (statement) { + if (ownsBreakOrContinueStatement(loopNode, statement)) { + pushKeywordIf(keywords, statement.getFirstToken(), 65, 70); + } + }); + return ts.map(keywords, getReferenceEntryFromNode); + } + function getSwitchCaseDefaultOccurrences(switchStatement) { + var keywords = []; + pushKeywordIf(keywords, switchStatement.getFirstToken(), 91); + ts.forEach(switchStatement.clauses, function (clause) { + pushKeywordIf(keywords, clause.getFirstToken(), 66, 72); + var breaksAndContinues = aggregateAllBreakAndContinueStatements(clause); + ts.forEach(breaksAndContinues, function (statement) { + if (ownsBreakOrContinueStatement(switchStatement, statement)) { + pushKeywordIf(keywords, statement.getFirstToken(), 65); + } + }); + }); + return ts.map(keywords, getReferenceEntryFromNode); + } + function getBreakOrContinueStatementOccurences(breakOrContinueStatement) { + var owner = getBreakOrContinueOwner(breakOrContinueStatement); + if (owner) { + switch (owner.kind) { + case 181: + case 182: + case 183: + case 179: + case 180: + return getLoopBreakContinueOccurrences(owner); + case 188: + return getSwitchCaseDefaultOccurrences(owner); + } + } + return undefined; + } + function aggregateAllBreakAndContinueStatements(node) { + var statementAccumulator = []; + aggregate(node); + return statementAccumulator; + function aggregate(node) { + if (node.kind === 185 || node.kind === 184) { + statementAccumulator.push(node); + } + else if (!ts.isAnyFunction(node)) { + ts.forEachChild(node, aggregate); + } + } + ; + } + function ownsBreakOrContinueStatement(owner, statement) { + var actualOwner = getBreakOrContinueOwner(statement); + return actualOwner && actualOwner === owner; + } + function getBreakOrContinueOwner(statement) { + for (var node = statement.parent; node; node = node.parent) { + switch (node.kind) { + case 188: + if (statement.kind === 184) { + continue; + } + case 181: + case 182: + case 183: + case 180: + case 179: + if (!statement.label || isLabeledBy(node, statement.label.text)) { + return node; + } + break; + default: + if (ts.isAnyFunction(node)) { + return undefined; + } + break; + } + } + return undefined; + } + function getConstructorOccurrences(constructorDeclaration) { + var declarations = constructorDeclaration.symbol.getDeclarations(); + var keywords = []; + ts.forEach(declarations, function (declaration) { + ts.forEach(declaration.getChildren(), function (token) { + return pushKeywordIf(keywords, token, 114); + }); + }); + return ts.map(keywords, getReferenceEntryFromNode); + } + function getGetAndSetOccurrences(accessorDeclaration) { + var keywords = []; + tryPushAccessorKeyword(accessorDeclaration.symbol, 134); + tryPushAccessorKeyword(accessorDeclaration.symbol, 135); + return ts.map(keywords, getReferenceEntryFromNode); + function tryPushAccessorKeyword(accessorSymbol, accessorKind) { + var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); + if (accessor) { + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116, 120); }); + } + } + } + function getModifierOccurrences(modifier, declaration) { + var container = declaration.parent; + if (declaration.flags & 112) { + if (!(container.kind === 196 || + (declaration.kind === 128 && hasKind(container, 133)))) { + return undefined; + } + } + else if (declaration.flags & 128) { + if (container.kind !== 196) { + return undefined; + } + } + else if (declaration.flags & (1 | 2)) { + if (!(container.kind === 201 || container.kind === 220)) { + return undefined; + } + } + else { + return undefined; + } + var keywords = []; + var modifierFlag = getFlagFromModifier(modifier); + var nodes; + switch (container.kind) { + case 201: + case 220: + nodes = container.statements; + break; + case 133: + nodes = container.parameters.concat(container.parent.members); + break; + case 196: + nodes = container.members; + if (modifierFlag & 112) { + var constructor = ts.forEach(container.members, function (member) { + return member.kind === 133 && member; + }); + if (constructor) { + nodes = nodes.concat(constructor.parameters); + } + } + break; + default: + ts.Debug.fail("Invalid container kind."); + } + ts.forEach(nodes, function (node) { + if (node.modifiers && node.flags & modifierFlag) { + ts.forEach(node.modifiers, function (child) { return pushKeywordIf(keywords, child, modifier); }); + } + }); + return ts.map(keywords, getReferenceEntryFromNode); + function getFlagFromModifier(modifier) { + switch (modifier) { + case 109: + return 16; + case 107: + return 32; + case 108: + return 64; + case 110: + return 128; + case 77: + return 1; + case 115: + return 2; + default: + ts.Debug.fail(); + } + } + } + function hasKind(node, kind) { + return node !== undefined && node.kind === kind; + } + function parent(node) { + return node && node.parent; + } + function pushKeywordIf(keywordList, token) { + var expected = []; + for (var _i = 2; _i < arguments.length; _i++) { + expected[_i - 2] = arguments[_i]; + } + if (token && ts.contains(expected, token.kind)) { + keywordList.push(token); + return true; + } + return false; + } + } + function findRenameLocations(fileName, position, findInStrings, findInComments) { + return findReferences(fileName, position, findInStrings, findInComments); + } + function getReferencesAtPosition(fileName, position) { + return findReferences(fileName, position, false, false); + } + function findReferences(fileName, position, findInStrings, findInComments) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, position); + if (!node) { + return undefined; + } + if (node.kind !== 64 && + !isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && + !isNameOfExternalModuleImportOrDeclaration(node)) { + return undefined; + } + ts.Debug.assert(node.kind === 64 || node.kind === 7 || node.kind === 8); + return getReferencesForNode(node, program.getSourceFiles(), false, findInStrings, findInComments); + } + function initializeNameTable(sourceFile) { + var nameTable = {}; + walk(sourceFile); + sourceFile.nameTable = nameTable; + function walk(node) { + switch (node.kind) { + case 64: + nameTable[node.text] = node.text; + break; + case 8: + case 7: + nameTable[node.text] = node.text; + break; + default: + ts.forEachChild(node, walk); + } + } + } + function getReferencesForNode(node, sourceFiles, searchOnlyInCurrentFile, findInStrings, findInComments) { + if (isLabelName(node)) { + if (isJumpStatementTarget(node)) { + var labelDefinition = getTargetLabel(node.parent, node.text); + return labelDefinition ? getLabelReferencesInNode(labelDefinition.parent, labelDefinition) : [getReferenceEntryFromNode(node)]; + } + else { + return getLabelReferencesInNode(node.parent, node); + } + } + if (node.kind === 92) { + return getReferencesForThisKeyword(node, sourceFiles); + } + if (node.kind === 90) { + return getReferencesForSuperKeyword(node); + } + var symbol = typeInfoResolver.getSymbolAtLocation(node); + if (!symbol) { + return [getReferenceEntryFromNode(node)]; + } + var declarations = symbol.declarations; + if (!declarations || !declarations.length) { + return undefined; + } + var result; + var searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations); + var declaredName = getDeclaredName(symbol); + var scope = getSymbolScope(symbol); + if (scope) { + result = []; + getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result); + } + else { + if (searchOnlyInCurrentFile) { + ts.Debug.assert(sourceFiles.length === 1); + result = []; + getReferencesInNode(sourceFiles[0], symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result); + } + else { + var internedName = getInternedName(symbol, declarations); + ts.forEach(sourceFiles, function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + if (!sourceFile.nameTable) { + initializeNameTable(sourceFile); + } + ts.Debug.assert(sourceFile.nameTable !== undefined); + if (ts.lookUp(sourceFile.nameTable, internedName)) { + result = result || []; + getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result); + } + }); + } + } + return result; + function getDeclaredName(symbol) { + var name = typeInfoResolver.symbolToString(symbol); + return stripQuotes(name); + } + function getInternedName(symbol, declarations) { + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 160 ? d : undefined; }); + if (functionExpression && functionExpression.name) { + var name = functionExpression.name.text; + } + else { + var name = symbol.name; + } + return stripQuotes(name); + } + function stripQuotes(name) { + var length = name.length; + if (length >= 2 && name.charCodeAt(0) === 34 && name.charCodeAt(length - 1) === 34) { + return name.substring(1, length - 1); + } + ; + return name; + } + function getSymbolScope(symbol) { + if (symbol.getFlags() && (4 | 8192)) { + var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32) ? d : undefined; }); + if (privateDeclaration) { + return ts.getAncestor(privateDeclaration, 196); + } + } + if (symbol.parent || (symbol.getFlags() & 268435456)) { + return undefined; + } + var scope = undefined; + var declarations = symbol.getDeclarations(); + if (declarations) { + for (var i = 0, n = declarations.length; i < n; i++) { + var container = getContainerNode(declarations[i]); + if (!container) { + return undefined; + } + if (scope && scope !== container) { + return undefined; + } + if (container.kind === 220 && !ts.isExternalModule(container)) { + return undefined; + } + scope = container; + } + } + return scope; + } + function getPossibleSymbolReferencePositions(sourceFile, symbolName, start, end) { + var positions = []; + if (!symbolName || !symbolName.length) { + return positions; + } + var text = sourceFile.text; + var sourceLength = text.length; + var symbolNameLength = symbolName.length; + var position = text.indexOf(symbolName, start); + while (position >= 0) { + cancellationToken.throwIfCancellationRequested(); + if (position > end) + break; + var endPosition = position + symbolNameLength; + if ((position === 0 || !ts.isIdentifierPart(text.charCodeAt(position - 1), 2)) && + (endPosition === sourceLength || !ts.isIdentifierPart(text.charCodeAt(endPosition), 2))) { + positions.push(position); + } + position = text.indexOf(symbolName, position + symbolNameLength + 1); + } + return positions; + } + function getLabelReferencesInNode(container, targetLabel) { + var result = []; + var sourceFile = container.getSourceFile(); + var labelName = targetLabel.text; + var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, labelName, container.getStart(), container.getEnd()); + ts.forEach(possiblePositions, function (position) { + cancellationToken.throwIfCancellationRequested(); + var node = ts.getTouchingWord(sourceFile, position); + if (!node || node.getWidth() !== labelName.length) { + return; + } + if (node === targetLabel || + (isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel)) { + result.push(getReferenceEntryFromNode(node)); + } + }); + return result; + } + function isValidReferencePosition(node, searchSymbolName) { + if (node) { + switch (node.kind) { + case 64: + return node.getWidth() === searchSymbolName.length; + case 8: + if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || + isNameOfExternalModuleImportOrDeclaration(node)) { + return node.getWidth() === searchSymbolName.length + 2; + } + break; + case 7: + if (isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) { + return node.getWidth() === searchSymbolName.length; + } + break; + } + } + return false; + } + function getReferencesInNode(container, searchSymbol, searchText, searchLocation, searchMeaning, findInStrings, findInComments, result) { + var sourceFile = container.getSourceFile(); + var tripleSlashDirectivePrefixRegex = /^\/\/\/\s*= 0) { + result.push(getReferenceEntryFromNode(referenceSymbolDeclaration.name)); + } + } + }); + } + function isInString(position) { + var token = ts.getTokenAtPosition(sourceFile, position); + return token && token.kind === 8 && position > token.getStart(); + } + function isInComment(position) { + var token = ts.getTokenAtPosition(sourceFile, position); + if (token && position < token.getStart()) { + var commentRanges = ts.getLeadingCommentRanges(sourceFile.text, token.pos); + return ts.forEach(commentRanges, function (c) { + if (c.pos < position && position < c.end) { + var commentText = sourceFile.text.substring(c.pos, c.end); + if (!tripleSlashDirectivePrefixRegex.test(commentText)) { + return true; + } + } + }); + } + return false; + } + } + function getReferencesForSuperKeyword(superKeyword) { + var searchSpaceNode = ts.getSuperContainer(superKeyword, false); + if (!searchSpaceNode) { + return undefined; + } + var staticFlag = 128; + switch (searchSpaceNode.kind) { + case 130: + case 129: + case 132: + case 131: + case 133: + case 134: + case 135: + staticFlag &= searchSpaceNode.flags; + searchSpaceNode = searchSpaceNode.parent; + break; + default: + return undefined; + } + var result = []; + var sourceFile = searchSpaceNode.getSourceFile(); + var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "super", searchSpaceNode.getStart(), searchSpaceNode.getEnd()); + ts.forEach(possiblePositions, function (position) { + cancellationToken.throwIfCancellationRequested(); + var node = ts.getTouchingWord(sourceFile, position); + if (!node || node.kind !== 90) { + return; + } + var container = ts.getSuperContainer(node, false); + if (container && (128 & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) { + result.push(getReferenceEntryFromNode(node)); + } + }); + return result; + } + function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles) { + var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, false); + var staticFlag = 128; + switch (searchSpaceNode.kind) { + case 132: + case 131: + if (ts.isObjectLiteralMethod(searchSpaceNode)) { + break; + } + case 130: + case 129: + case 133: + case 134: + case 135: + staticFlag &= searchSpaceNode.flags; + searchSpaceNode = searchSpaceNode.parent; + break; + case 220: + if (ts.isExternalModule(searchSpaceNode)) { + return undefined; + } + case 195: + case 160: + break; + default: + return undefined; + } + var result = []; + if (searchSpaceNode.kind === 220) { + ts.forEach(sourceFiles, function (sourceFile) { + var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); + getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, result); + }); + } + else { + var sourceFile = searchSpaceNode.getSourceFile(); + var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", searchSpaceNode.getStart(), searchSpaceNode.getEnd()); + getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, result); + } + return result; + function getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, result) { + ts.forEach(possiblePositions, function (position) { + cancellationToken.throwIfCancellationRequested(); + var node = ts.getTouchingWord(sourceFile, position); + if (!node || node.kind !== 92) { + return; + } + var container = ts.getThisContainer(node, false); + switch (searchSpaceNode.kind) { + case 160: + case 195: + if (searchSpaceNode.symbol === container.symbol) { + result.push(getReferenceEntryFromNode(node)); + } + break; + case 132: + case 131: + if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { + result.push(getReferenceEntryFromNode(node)); + } + break; + case 196: + if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128) === staticFlag) { + result.push(getReferenceEntryFromNode(node)); + } + break; + case 220: + if (container.kind === 220 && !ts.isExternalModule(container)) { + result.push(getReferenceEntryFromNode(node)); + } + break; + } + }); + } + } + function populateSearchSymbolSet(symbol, location) { + var result = [symbol]; + if (isNameOfPropertyAssignment(location)) { + ts.forEach(getPropertySymbolsFromContextualType(location), function (contextualSymbol) { + result.push.apply(result, typeInfoResolver.getRootSymbols(contextualSymbol)); + }); + var shorthandValueSymbol = typeInfoResolver.getShorthandAssignmentValueSymbol(location.parent); + if (shorthandValueSymbol) { + result.push(shorthandValueSymbol); + } + } + ts.forEach(typeInfoResolver.getRootSymbols(symbol), function (rootSymbol) { + if (rootSymbol !== symbol) { + result.push(rootSymbol); + } + if (rootSymbol.parent && rootSymbol.parent.flags & (32 | 64)) { + getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result); + } + }); + return result; + } + function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { + if (symbol && symbol.flags & (32 | 64)) { + ts.forEach(symbol.getDeclarations(), function (declaration) { + if (declaration.kind === 196) { + getPropertySymbolFromTypeReference(ts.getClassBaseTypeNode(declaration)); + ts.forEach(ts.getClassImplementedTypeNodes(declaration), getPropertySymbolFromTypeReference); + } + else if (declaration.kind === 197) { + ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); + } + }); + } + return; + function getPropertySymbolFromTypeReference(typeReference) { + if (typeReference) { + var type = typeInfoResolver.getTypeAtLocation(typeReference); + if (type) { + var propertySymbol = typeInfoResolver.getPropertyOfType(type, propertyName); + if (propertySymbol) { + result.push(propertySymbol); + } + getPropertySymbolsFromBaseTypes(type.symbol, propertyName, result); + } + } + } + } + function isRelatableToSearchSet(searchSymbols, referenceSymbol, referenceLocation) { + if (searchSymbols.indexOf(referenceSymbol) >= 0) { + return true; + } + if (isNameOfPropertyAssignment(referenceLocation)) { + return ts.forEach(getPropertySymbolsFromContextualType(referenceLocation), function (contextualSymbol) { + return ts.forEach(typeInfoResolver.getRootSymbols(contextualSymbol), function (s) { return searchSymbols.indexOf(s) >= 0; }); + }); + } + return ts.forEach(typeInfoResolver.getRootSymbols(referenceSymbol), function (rootSymbol) { + if (searchSymbols.indexOf(rootSymbol) >= 0) { + return true; + } + if (rootSymbol.parent && rootSymbol.parent.flags & (32 | 64)) { + var result = []; + getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result); + return ts.forEach(result, function (s) { return searchSymbols.indexOf(s) >= 0; }); + } + return false; + }); + } + function getPropertySymbolsFromContextualType(node) { + if (isNameOfPropertyAssignment(node)) { + var objectLiteral = node.parent.parent; + var contextualType = typeInfoResolver.getContextualType(objectLiteral); + var name = node.text; + if (contextualType) { + if (contextualType.flags & 16384) { + var unionProperty = contextualType.getProperty(name); + if (unionProperty) { + return [unionProperty]; + } + else { + var result = []; + ts.forEach(contextualType.types, function (t) { + var symbol = t.getProperty(name); + if (symbol) { + result.push(symbol); + } + }); + return result; + } + } + else { + var symbol = contextualType.getProperty(name); + if (symbol) { + return [symbol]; + } + } + } + } + return undefined; + } + function getIntersectingMeaningFromDeclarations(meaning, declarations) { + if (declarations) { + do { + var lastIterationMeaning = meaning; + for (var i = 0, n = declarations.length; i < n; i++) { + var declarationMeaning = getMeaningFromDeclaration(declarations[i]); + if (declarationMeaning & meaning) { + meaning |= declarationMeaning; + } + } + } while (meaning !== lastIterationMeaning); + } + return meaning; + } + } + function getReferenceEntryFromNode(node) { + var start = node.getStart(); + var end = node.getEnd(); + if (node.kind === 8) { + start += 1; + end -= 1; + } + return { + fileName: node.getSourceFile().fileName, + textSpan: ts.createTextSpanFromBounds(start, end), + isWriteAccess: isWriteAccess(node) + }; + } + function isWriteAccess(node) { + if (node.kind === 64 && ts.isDeclarationOrFunctionExpressionOrCatchVariableName(node)) { + return true; + } + var parent = node.parent; + if (parent) { + if (parent.kind === 166 || parent.kind === 165) { + return true; + } + else if (parent.kind === 167 && parent.left === node) { + var operator = parent.operatorToken.kind; + return 52 <= operator && operator <= 63; + } + } + return false; + } + function getNavigateToItems(searchValue, maxResultCount) { + synchronizeHostData(); + return ts.NavigateTo.getNavigateToItems(program, cancellationToken, searchValue, maxResultCount); + } + function containErrors(diagnostics) { + return ts.forEach(diagnostics, function (diagnostic) { return diagnostic.category === 1; }); + } + function getEmitOutput(fileName) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var outputFiles = []; + function writeFile(fileName, data, writeByteOrderMark) { + outputFiles.push({ + name: fileName, + writeByteOrderMark: writeByteOrderMark, + text: data + }); + } + var emitOutput = program.emit(sourceFile, writeFile); + return { + outputFiles: outputFiles, + emitSkipped: emitOutput.emitSkipped + }; + } + function getMeaningFromDeclaration(node) { + switch (node.kind) { + case 128: + case 193: + case 150: + case 130: + case 129: + case 217: + case 218: + case 219: + case 132: + case 131: + case 133: + case 134: + case 135: + case 195: + case 160: + case 161: + case 216: + return 1; + case 127: + case 197: + case 198: + case 143: + return 2; + case 196: + case 199: + return 1 | 2; + case 200: + if (node.name.kind === 8) { + return 4 | 1; + } + else if (ts.getModuleInstanceState(node) === 1) { + return 4 | 1; + } + else { + return 4; + } + case 202: + return 1 | 2 | 4; + case 220: + return 4 | 1; + } + ts.Debug.fail("Unknown declaration type"); + } + function isTypeReference(node) { + if (isRightSideOfQualifiedName(node)) { + node = node.parent; + } + return node.parent.kind === 139; + } + function isNamespaceReference(node) { + var root = node; + var isLastClause = true; + if (root.parent.kind === 125) { + while (root.parent && root.parent.kind === 125) + root = root.parent; + isLastClause = root.right === node; + } + return root.parent.kind === 139 && !isLastClause; + } + function isInRightSideOfImport(node) { + while (node.parent.kind === 125) { + node = node.parent; + } + return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; + } + function getMeaningFromRightHandSideOfImportEquals(node) { + ts.Debug.assert(node.kind === 64); + if (node.parent.kind === 125 && + node.parent.right === node && + node.parent.parent.kind === 202) { + return 1 | 2 | 4; + } + return 4; + } + function getMeaningFromLocation(node) { + if (node.parent.kind === 208) { + return 1 | 2 | 4; + } + else if (isInRightSideOfImport(node)) { + return getMeaningFromRightHandSideOfImportEquals(node); + } + else if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(node)) { + return getMeaningFromDeclaration(node.parent); + } + else if (isTypeReference(node)) { + return 2; + } + else if (isNamespaceReference(node)) { + return 4; + } + else { + return 1; + } + } + function getSignatureHelpItems(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + return ts.SignatureHelp.getSignatureHelpItems(sourceFile, position, typeInfoResolver, cancellationToken); + } + function getSourceFile(fileName) { + return syntaxTreeCache.getCurrentSourceFile(fileName); + } + function getNameOrDottedNameSpan(fileName, startPos, endPos) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, startPos); + if (!node) { + return; + } + switch (node.kind) { + case 153: + case 125: + case 8: + case 79: + case 94: + case 88: + case 90: + case 92: + case 64: + break; + default: + return; + } + var nodeForStartPos = node; + while (true) { + if (isRightSideOfPropertyAccess(nodeForStartPos) || isRightSideOfQualifiedName(nodeForStartPos)) { + nodeForStartPos = nodeForStartPos.parent; + } + else if (isNameOfModuleDeclaration(nodeForStartPos)) { + if (nodeForStartPos.parent.parent.kind === 200 && + nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { + nodeForStartPos = nodeForStartPos.parent.parent.name; + } + else { + break; + } + } + else { + break; + } + } + return ts.createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd()); + } + function getBreakpointStatementAtPosition(fileName, position) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position); + } + function getNavigationBarItems(fileName) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.NavigationBar.getNavigationBarItems(sourceFile); + } + function getSemanticClassifications(fileName, span) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var result = []; + processNode(sourceFile); + return result; + function classifySymbol(symbol, meaningAtPosition) { + var flags = symbol.getFlags(); + if (flags & 32) { + return ClassificationTypeNames.className; + } + else if (flags & 384) { + return ClassificationTypeNames.enumName; + } + else if (flags & 524288) { + return ClassificationTypeNames.typeAlias; + } + else if (meaningAtPosition & 2) { + if (flags & 64) { + return ClassificationTypeNames.interfaceName; + } + else if (flags & 262144) { + return ClassificationTypeNames.typeParameterName; + } + } + else if (flags & 1536) { + if (meaningAtPosition & 4 || + (meaningAtPosition & 1 && hasValueSideModule(symbol))) { + return ClassificationTypeNames.moduleName; + } + } + return undefined; + function hasValueSideModule(symbol) { + return ts.forEach(symbol.declarations, function (declaration) { + return declaration.kind === 200 && ts.getModuleInstanceState(declaration) == 1; + }); + } + } + function processNode(node) { + if (node && ts.textSpanIntersectsWith(span, node.getStart(), node.getWidth())) { + if (node.kind === 64 && node.getWidth() > 0) { + var symbol = typeInfoResolver.getSymbolAtLocation(node); + if (symbol) { + var type = classifySymbol(symbol, getMeaningFromLocation(node)); + if (type) { + result.push({ + textSpan: ts.createTextSpan(node.getStart(), node.getWidth()), + classificationType: type + }); + } + } + } + ts.forEachChild(node, processNode); + } + } + } + function getSyntacticClassifications(fileName, span) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var triviaScanner = ts.createScanner(2, false, sourceFile.text); + var mergeConflictScanner = ts.createScanner(2, false, sourceFile.text); + var result = []; + processElement(sourceFile); + return result; + function classifyLeadingTrivia(token) { + var tokenStart = ts.skipTrivia(sourceFile.text, token.pos, false); + if (tokenStart === token.pos) { + return; + } + triviaScanner.setTextPos(token.pos); + while (true) { + var start = triviaScanner.getTextPos(); + var kind = triviaScanner.scan(); + var end = triviaScanner.getTextPos(); + var width = end - start; + if (ts.textSpanIntersectsWith(span, start, width)) { + if (!ts.isTrivia(kind)) { + return; + } + if (ts.isComment(kind)) { + result.push({ + textSpan: ts.createTextSpan(start, width), + classificationType: ClassificationTypeNames.comment + }); + continue; + } + if (kind === 6) { + var text = sourceFile.text; + var ch = text.charCodeAt(start); + if (ch === 60 || ch === 62) { + result.push({ + textSpan: ts.createTextSpan(start, width), + classificationType: ClassificationTypeNames.comment + }); + continue; + } + ts.Debug.assert(ch === 61); + classifyDisabledMergeCode(text, start, end); + } + } + } + } + function classifyDisabledMergeCode(text, start, end) { + for (var i = start; i < end; i++) { + if (ts.isLineBreak(text.charCodeAt(i))) { + break; + } + } + result.push({ + textSpan: ts.createTextSpanFromBounds(start, i), + classificationType: ClassificationTypeNames.comment + }); + mergeConflictScanner.setTextPos(i); + while (mergeConflictScanner.getTextPos() < end) { + classifyDisabledCodeToken(); + } + } + function classifyDisabledCodeToken() { + var start = mergeConflictScanner.getTextPos(); + var tokenKind = mergeConflictScanner.scan(); + var end = mergeConflictScanner.getTextPos(); + var type = classifyTokenType(tokenKind); + if (type) { + result.push({ + textSpan: ts.createTextSpanFromBounds(start, end), + classificationType: type + }); + } + } + function classifyToken(token) { + classifyLeadingTrivia(token); + if (token.getWidth() > 0) { + var type = classifyTokenType(token.kind, token); + if (type) { + result.push({ + textSpan: ts.createTextSpan(token.getStart(), token.getWidth()), + classificationType: type + }); + } + } + } + function classifyTokenType(tokenKind, token) { + if (ts.isKeyword(tokenKind)) { + return ClassificationTypeNames.keyword; + } + if (tokenKind === 24 || tokenKind === 25) { + if (token && ts.getTypeArgumentOrTypeParameterList(token.parent)) { + return ClassificationTypeNames.punctuation; + } + } + if (ts.isPunctuation(tokenKind)) { + if (token) { + if (tokenKind === 52) { + if (token.parent.kind === 193 || + token.parent.kind === 130 || + token.parent.kind === 128) { + return ClassificationTypeNames.operator; + } + } + if (token.parent.kind === 167 || + token.parent.kind === 165 || + token.parent.kind === 166 || + token.parent.kind === 168) { + return ClassificationTypeNames.operator; + } + } + return ClassificationTypeNames.punctuation; + } + else if (tokenKind === 7) { + return ClassificationTypeNames.numericLiteral; + } + else if (tokenKind === 8) { + return ClassificationTypeNames.stringLiteral; + } + else if (tokenKind === 9) { + return ClassificationTypeNames.stringLiteral; + } + else if (ts.isTemplateLiteralKind(tokenKind)) { + return ClassificationTypeNames.stringLiteral; + } + else if (tokenKind === 64) { + if (token) { + switch (token.parent.kind) { + case 196: + if (token.parent.name === token) { + return ClassificationTypeNames.className; + } + return; + case 127: + if (token.parent.name === token) { + return ClassificationTypeNames.typeParameterName; + } + return; + case 197: + if (token.parent.name === token) { + return ClassificationTypeNames.interfaceName; + } + return; + case 199: + if (token.parent.name === token) { + return ClassificationTypeNames.enumName; + } + return; + case 200: + if (token.parent.name === token) { + return ClassificationTypeNames.moduleName; + } + return; + } + } + return ClassificationTypeNames.text; + } + } + function processElement(element) { + if (ts.textSpanIntersectsWith(span, element.getFullStart(), element.getFullWidth())) { + var children = element.getChildren(); + for (var i = 0, n = children.length; i < n; i++) { + var child = children[i]; + if (ts.isToken(child)) { + classifyToken(child); + } + else { + processElement(child); + } + } + } + } + } + function getOutliningSpans(fileName) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.OutliningElementsCollector.collectElements(sourceFile); + } + function getBraceMatchingAtPosition(fileName, position) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var result = []; + var token = ts.getTouchingToken(sourceFile, position); + if (token.getStart(sourceFile) === position) { + var matchKind = getMatchingTokenKind(token); + if (matchKind) { + var parentElement = token.parent; + var childNodes = parentElement.getChildren(sourceFile); + for (var i = 0, n = childNodes.length; i < n; i++) { + var current = childNodes[i]; + if (current.kind === matchKind) { + var range1 = ts.createTextSpan(token.getStart(sourceFile), token.getWidth(sourceFile)); + var range2 = ts.createTextSpan(current.getStart(sourceFile), current.getWidth(sourceFile)); + if (range1.start < range2.start) { + result.push(range1, range2); + } + else { + result.push(range2, range1); + } + break; + } + } + } + } + return result; + function getMatchingTokenKind(token) { + switch (token.kind) { + case 14: return 15; + case 16: return 17; + case 18: return 19; + case 24: return 25; + case 15: return 14; + case 17: return 16; + case 19: return 18; + case 25: return 24; + } + return undefined; + } + } + function getIndentationAtPosition(fileName, position, editorOptions) { + var start = new Date().getTime(); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + log("getIndentationAtPosition: getCurrentSourceFile: " + (new Date().getTime() - start)); + var start = new Date().getTime(); + var result = ts.formatting.SmartIndenter.getIndentation(position, sourceFile, editorOptions); + log("getIndentationAtPosition: computeIndentation : " + (new Date().getTime() - start)); + return result; + } + function getFormattingEditsForRange(fileName, start, end, options) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(options), options); + } + function getFormattingEditsForDocument(fileName, options) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options); + } + function getFormattingEditsAfterKeystroke(fileName, position, key, options) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + if (key === "}") { + return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(options), options); + } + else if (key === ";") { + return ts.formatting.formatOnSemicolon(position, sourceFile, getRuleProvider(options), options); + } + else if (key === "\n") { + return ts.formatting.formatOnEnter(position, sourceFile, getRuleProvider(options), options); + } + return []; + } + function getTodoComments(fileName, descriptors) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + cancellationToken.throwIfCancellationRequested(); + var fileContents = sourceFile.text; + var result = []; + if (descriptors.length > 0) { + var regExp = getTodoCommentsRegExp(); + var matchArray; + while (matchArray = regExp.exec(fileContents)) { + cancellationToken.throwIfCancellationRequested(); + var firstDescriptorCaptureIndex = 3; + ts.Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex); + var preamble = matchArray[1]; + var matchPosition = matchArray.index + preamble.length; + var token = ts.getTokenAtPosition(sourceFile, matchPosition); + if (!isInsideComment(sourceFile, token, matchPosition)) { + continue; + } + var descriptor = undefined; + for (var i = 0, n = descriptors.length; i < n; i++) { + if (matchArray[i + firstDescriptorCaptureIndex]) { + descriptor = descriptors[i]; + } + } + ts.Debug.assert(descriptor !== undefined); + if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) { + continue; + } + var message = matchArray[2]; + result.push({ + descriptor: descriptor, + message: message, + position: matchPosition + }); + } + } + return result; + function escapeRegExp(str) { + return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"); + } + function getTodoCommentsRegExp() { + var singleLineCommentStart = /(?:\/\/+\s*)/.source; + var multiLineCommentStart = /(?:\/\*+\s*)/.source; + var anyNumberOfSpacesAndAsterixesAtStartOfLine = /(?:^(?:\s|\*)*)/.source; + var preamble = "(" + anyNumberOfSpacesAndAsterixesAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")"; + var literals = "(?:" + ts.map(descriptors, function (d) { return "(" + escapeRegExp(d.text) + ")"; }).join("|") + ")"; + var endOfLineOrEndOfComment = /(?:$|\*\/)/.source; + var messageRemainder = /(?:.*?)/.source; + var messagePortion = "(" + literals + messageRemainder + ")"; + var regExpString = preamble + messagePortion + endOfLineOrEndOfComment; + return new RegExp(regExpString, "gim"); + } + function isLetterOrDigit(char) { + return (char >= 97 && char <= 122) || + (char >= 65 && char <= 90) || + (char >= 48 && char <= 57); + } + } + function getRenameInfo(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingWord(sourceFile, position); + if (node && node.kind === 64) { + var symbol = typeInfoResolver.getSymbolAtLocation(node); + if (symbol) { + var declarations = symbol.getDeclarations(); + if (declarations && declarations.length > 0) { + var defaultLibFileName = host.getDefaultLibFileName(host.getCompilationSettings()); + if (defaultLibFileName) { + for (var i = 0; i < declarations.length; i++) { + var sourceFile = declarations[i].getSourceFile(); + if (sourceFile && getCanonicalFileName(ts.normalizePath(sourceFile.fileName)) === getCanonicalFileName(ts.normalizePath(defaultLibFileName))) { + return getRenameInfoError(ts.getLocaleSpecificMessage(ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library.key)); + } + } + } + var kind = getSymbolKind(symbol, typeInfoResolver, node); + if (kind) { + return { + canRename: true, + localizedErrorMessage: undefined, + displayName: symbol.name, + fullDisplayName: typeInfoResolver.getFullyQualifiedName(symbol), + kind: kind, + kindModifiers: getSymbolModifiers(symbol), + triggerSpan: ts.createTextSpan(node.getStart(), node.getWidth()) + }; + } + } + } + } + return getRenameInfoError(ts.getLocaleSpecificMessage(ts.Diagnostics.You_cannot_rename_this_element.key)); + function getRenameInfoError(localizedErrorMessage) { + return { + canRename: false, + localizedErrorMessage: localizedErrorMessage, + displayName: undefined, + fullDisplayName: undefined, + kind: undefined, + kindModifiers: undefined, + triggerSpan: undefined + }; + } + } + return { + dispose: dispose, + cleanupSemanticCache: cleanupSemanticCache, + getSyntacticDiagnostics: getSyntacticDiagnostics, + getSemanticDiagnostics: getSemanticDiagnostics, + getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics, + getSyntacticClassifications: getSyntacticClassifications, + getSemanticClassifications: getSemanticClassifications, + getCompletionsAtPosition: getCompletionsAtPosition, + getCompletionEntryDetails: getCompletionEntryDetails, + getSignatureHelpItems: getSignatureHelpItems, + getQuickInfoAtPosition: getQuickInfoAtPosition, + getDefinitionAtPosition: getDefinitionAtPosition, + getReferencesAtPosition: getReferencesAtPosition, + getOccurrencesAtPosition: getOccurrencesAtPosition, + getNameOrDottedNameSpan: getNameOrDottedNameSpan, + getBreakpointStatementAtPosition: getBreakpointStatementAtPosition, + getNavigateToItems: getNavigateToItems, + getRenameInfo: getRenameInfo, + findRenameLocations: findRenameLocations, + getNavigationBarItems: getNavigationBarItems, + getOutliningSpans: getOutliningSpans, + getTodoComments: getTodoComments, + getBraceMatchingAtPosition: getBraceMatchingAtPosition, + getIndentationAtPosition: getIndentationAtPosition, + getFormattingEditsForRange: getFormattingEditsForRange, + getFormattingEditsForDocument: getFormattingEditsForDocument, + getFormattingEditsAfterKeystroke: getFormattingEditsAfterKeystroke, + getEmitOutput: getEmitOutput, + getSourceFile: getSourceFile, + getProgram: getProgram + }; + } + ts.createLanguageService = createLanguageService; + function createClassifier() { + var scanner = ts.createScanner(2, false); + var noRegexTable = []; + noRegexTable[64] = true; + noRegexTable[8] = true; + noRegexTable[7] = true; + noRegexTable[9] = true; + noRegexTable[92] = true; + noRegexTable[38] = true; + noRegexTable[39] = true; + noRegexTable[17] = true; + noRegexTable[19] = true; + noRegexTable[15] = true; + noRegexTable[94] = true; + noRegexTable[79] = true; + var templateStack = []; + function isAccessibilityModifier(kind) { + switch (kind) { + case 109: + case 107: + case 108: + return true; + } + return false; + } + function canFollow(keyword1, keyword2) { + if (isAccessibilityModifier(keyword1)) { + if (keyword2 === 116 || + keyword2 === 120 || + keyword2 === 114 || + keyword2 === 110) { + return true; + } + return false; + } + return true; + } + function getClassificationsForLine(text, lexState, syntacticClassifierAbsent) { + var offset = 0; + var token = 0; + var lastNonTriviaToken = 0; + while (templateStack.length > 0) { + templateStack.pop(); + } + switch (lexState) { + case 3: + text = '"\\\n' + text; + offset = 3; + break; + case 2: + text = "'\\\n" + text; + offset = 3; + break; + case 1: + text = "/*\n" + text; + offset = 3; + break; + case 4: + text = "`\n" + text; + offset = 2; + break; + case 5: + text = "}\n" + text; + offset = 2; + case 6: + templateStack.push(11); + break; + } + scanner.setText(text); + var result = { + finalLexState: 0, + entries: [] + }; + var angleBracketStack = 0; + do { + token = scanner.scan(); + if (!ts.isTrivia(token)) { + if ((token === 36 || token === 56) && !noRegexTable[lastNonTriviaToken]) { + if (scanner.reScanSlashToken() === 9) { + token = 9; + } + } + else if (lastNonTriviaToken === 20 && isKeyword(token)) { + token = 64; + } + else if (isKeyword(lastNonTriviaToken) && isKeyword(token) && !canFollow(lastNonTriviaToken, token)) { + token = 64; + } + else if (lastNonTriviaToken === 64 && + token === 24) { + angleBracketStack++; + } + else if (token === 25 && angleBracketStack > 0) { + angleBracketStack--; + } + else if (token === 112 || + token === 121 || + token === 119 || + token === 113 || + token === 122) { + if (angleBracketStack > 0 && !syntacticClassifierAbsent) { + token = 64; + } + } + else if (token === 11) { + templateStack.push(token); + } + else if (token === 14) { + if (templateStack.length > 0) { + templateStack.push(token); + } + } + else if (token === 15) { + if (templateStack.length > 0) { + var lastTemplateStackToken = ts.lastOrUndefined(templateStack); + if (lastTemplateStackToken === 11) { + token = scanner.reScanTemplateToken(); + if (token === 13) { + templateStack.pop(); + } + else { + ts.Debug.assert(token === 12, "Should have been a template middle. Was " + token); + } + } + else { + ts.Debug.assert(lastTemplateStackToken === 14, "Should have been an open brace. Was: " + token); + templateStack.pop(); + } + } + } + lastNonTriviaToken = token; + } + processToken(); + } while (token !== 1); + return result; + function processToken() { + var start = scanner.getTokenPos(); + var end = scanner.getTextPos(); + addResult(end - start, classFromKind(token)); + if (end >= text.length) { + if (token === 8) { + var tokenText = scanner.getTokenText(); + if (scanner.isUnterminated()) { + var lastCharIndex = tokenText.length - 1; + var numBackslashes = 0; + while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === 92) { + numBackslashes++; + } + if (numBackslashes & 1) { + var quoteChar = tokenText.charCodeAt(0); + result.finalLexState = quoteChar === 34 ? 3 : 2; + } + } + } + else if (token === 3) { + if (scanner.isUnterminated()) { + result.finalLexState = 1; + } + } + else if (ts.isTemplateLiteralKind(token)) { + if (scanner.isUnterminated()) { + if (token === 13) { + result.finalLexState = 5; + } + else if (token === 10) { + result.finalLexState = 4; + } + else { + ts.Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token); + } + } + } + else if (templateStack.length > 0 && ts.lastOrUndefined(templateStack) === 11) { + result.finalLexState = 6; + } + } + } + function addResult(length, classification) { + if (length > 0) { + if (result.entries.length === 0) { + length -= offset; + } + result.entries.push({ length: length, classification: classification }); + } + } + } + function isBinaryExpressionOperatorToken(token) { + switch (token) { + case 35: + case 36: + case 37: + case 33: + case 34: + case 40: + case 41: + case 42: + case 24: + case 25: + case 26: + case 27: + case 86: + case 85: + case 28: + case 29: + case 30: + case 31: + case 43: + case 45: + case 44: + case 48: + case 49: + case 62: + case 61: + case 63: + case 58: + case 59: + case 60: + case 53: + case 54: + case 55: + case 56: + case 57: + case 52: + case 23: + return true; + default: + return false; + } + } + function isPrefixUnaryExpressionOperatorToken(token) { + switch (token) { + case 33: + case 34: + case 47: + case 46: + case 38: + case 39: + return true; + default: + return false; + } + } + function isKeyword(token) { + return token >= 65 && token <= 124; + } + function classFromKind(token) { + if (isKeyword(token)) { + return 1; + } + else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) { + return 2; + } + else if (token >= 14 && token <= 63) { + return 0; + } + switch (token) { + case 7: + return 6; + case 8: + return 7; + case 9: + return 8; + case 6: + case 3: + case 2: + return 3; + case 5: + case 4: + return 4; + case 64: + default: + if (ts.isTemplateLiteralKind(token)) { + return 7; + } + return 5; + } + } + return { getClassificationsForLine: getClassificationsForLine }; + } + ts.createClassifier = createClassifier; + function getDefaultLibFilePath(options) { + if (typeof __dirname !== "undefined") { + return __dirname + ts.directorySeparator + ts.getDefaultLibFileName(options); + } + throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. "); + } + ts.getDefaultLibFilePath = getDefaultLibFilePath; + function initializeServices() { + ts.objectAllocator = { + getNodeConstructor: function (kind) { + function Node() { + } + var proto = kind === 220 ? new SourceFileObject() : new NodeObject(); + proto.kind = kind; + proto.pos = 0; + proto.end = 0; + proto.flags = 0; + proto.parent = undefined; + Node.prototype = proto; + return Node; + }, + getSymbolConstructor: function () { return SymbolObject; }, + getTypeConstructor: function () { return TypeObject; }, + getSignatureConstructor: function () { return SignatureObject; } + }; + } + initializeServices(); +})(ts || (ts = {})); +var ts; +(function (ts) { + var server; + (function (server) { + var lineCollectionCapacity = 4; + var ScriptInfo = (function () { + function ScriptInfo(host, fileName, content, isOpen) { + if (isOpen === void 0) { isOpen = false; } + this.host = host; + this.fileName = fileName; + this.content = content; + this.isOpen = isOpen; + this.children = []; + this.svc = ScriptVersionCache.fromString(content); + } + ScriptInfo.prototype.close = function () { + this.isOpen = false; + }; + ScriptInfo.prototype.addChild = function (childInfo) { + this.children.push(childInfo); + }; + ScriptInfo.prototype.snap = function () { + return this.svc.getSnapshot(); + }; + ScriptInfo.prototype.getText = function () { + var snap = this.snap(); + return snap.getText(0, snap.getLength()); + }; + ScriptInfo.prototype.getLineInfo = function (line) { + var snap = this.snap(); + return snap.index.lineNumberToInfo(line); + }; + ScriptInfo.prototype.editContent = function (start, end, newText) { + this.svc.edit(start, end - start, newText); + }; + ScriptInfo.prototype.getTextChangeRangeBetweenVersions = function (startVersion, endVersion) { + return this.svc.getTextChangesBetweenVersions(startVersion, endVersion); + }; + ScriptInfo.prototype.getChangeRange = function (oldSnapshot) { + return this.snap().getChangeRange(oldSnapshot); + }; + return ScriptInfo; + })(); + var LSHost = (function () { + function LSHost(host, project) { + this.host = host; + this.project = project; + this.ls = null; + this.filenameToScript = {}; + this.roots = []; + } + LSHost.prototype.getDefaultLibFileName = function () { + var nodeModuleBinDir = ts.getDirectoryPath(ts.normalizePath(this.host.getExecutingFilePath())); + return ts.combinePaths(nodeModuleBinDir, ts.getDefaultLibFileName(this.compilationSettings)); + }; + LSHost.prototype.getScriptSnapshot = function (filename) { + var scriptInfo = this.getScriptInfo(filename); + if (scriptInfo) { + return scriptInfo.snap(); + } + }; + LSHost.prototype.setCompilationSettings = function (opt) { + this.compilationSettings = opt; + }; + LSHost.prototype.lineAffectsRefs = function (filename, line) { + var info = this.getScriptInfo(filename); + var lineInfo = info.getLineInfo(line); + if (lineInfo && lineInfo.text) { + var regex = /reference|import|\/\*|\*\//; + return regex.test(lineInfo.text); + } + }; + LSHost.prototype.getCompilationSettings = function () { + return this.compilationSettings; + }; + LSHost.prototype.getScriptFileNames = function () { + var filenames = []; + for (var filename in this.filenameToScript) { + if (this.filenameToScript[filename] && this.filenameToScript[filename].isOpen) { + filenames.push(filename); + } + } + return filenames; + }; + LSHost.prototype.getScriptVersion = function (filename) { + return this.getScriptInfo(filename).svc.latestVersion().toString(); + }; + LSHost.prototype.getCurrentDirectory = function () { + return ""; + }; + LSHost.prototype.getScriptIsOpen = function (filename) { + return this.getScriptInfo(filename).isOpen; + }; + LSHost.prototype.removeReferencedFile = function (info) { + if (!info.isOpen) { + this.filenameToScript[info.fileName] = undefined; + } + }; + LSHost.prototype.getScriptInfo = function (filename) { + var scriptInfo = ts.lookUp(this.filenameToScript, filename); + if (!scriptInfo) { + scriptInfo = this.project.openReferencedFile(filename); + if (scriptInfo) { + this.filenameToScript[scriptInfo.fileName] = scriptInfo; + } + } + else { + } + return scriptInfo; + }; + LSHost.prototype.addRoot = function (info) { + var scriptInfo = ts.lookUp(this.filenameToScript, info.fileName); + if (!scriptInfo) { + this.filenameToScript[info.fileName] = info; + this.roots.push(info); + } + }; + LSHost.prototype.saveTo = function (filename, tmpfilename) { + var script = this.getScriptInfo(filename); + if (script) { + var snap = script.snap(); + this.host.writeFile(tmpfilename, snap.getText(0, snap.getLength())); + } + }; + LSHost.prototype.reloadScript = function (filename, tmpfilename, cb) { + var script = this.getScriptInfo(filename); + if (script) { + script.svc.reloadFromFile(tmpfilename, cb); + } + }; + LSHost.prototype.editScript = function (filename, start, end, newText) { + var script = this.getScriptInfo(filename); + if (script) { + script.editContent(start, end, newText); + return; + } + throw new Error("No script with name '" + filename + "'"); + }; + LSHost.prototype.resolvePath = function (path) { + var start = new Date().getTime(); + var result = this.host.resolvePath(path); + return result; + }; + LSHost.prototype.fileExists = function (path) { + var start = new Date().getTime(); + var result = this.host.fileExists(path); + return result; + }; + LSHost.prototype.directoryExists = function (path) { + return this.host.directoryExists(path); + }; + LSHost.prototype.lineToTextSpan = function (filename, line) { + var script = this.filenameToScript[filename]; + var index = script.snap().index; + var lineInfo = index.lineNumberToInfo(line + 1); + var len; + if (lineInfo.leaf) { + len = lineInfo.leaf.text.length; + } + else { + var nextLineInfo = index.lineNumberToInfo(line + 2); + len = nextLineInfo.col - lineInfo.col; + } + return ts.createTextSpan(lineInfo.col, len); + }; + LSHost.prototype.lineColToPosition = function (filename, line, col) { + var script = this.filenameToScript[filename]; + var index = script.snap().index; + var lineInfo = index.lineNumberToInfo(line); + return (lineInfo.col + col - 1); + }; + LSHost.prototype.positionToLineCol = function (filename, position) { + var script = this.filenameToScript[filename]; + var index = script.snap().index; + var lineCol = index.charOffsetToLineNumberAndPos(position); + return { line: lineCol.line, col: lineCol.col + 1 }; + }; + return LSHost; + })(); + function getAbsolutePath(filename, directory) { + var rootLength = ts.getRootLength(filename); + if (rootLength > 0) { + return filename; + } + else { + var splitFilename = filename.split('/'); + var splitDir = directory.split('/'); + var i = 0; + var dirTail = 0; + var sflen = splitFilename.length; + while ((i < sflen) && (splitFilename[i].charAt(0) == '.')) { + var dots = splitFilename[i]; + if (dots == '..') { + dirTail++; + } + else if (dots != '.') { + return undefined; + } + i++; + } + return splitDir.slice(0, splitDir.length - dirTail).concat(splitFilename.slice(i)).join('/'); + } + } + var Project = (function () { + function Project(projectService) { + this.projectService = projectService; + this.filenameToSourceFile = {}; + this.updateGraphSeq = 0; + this.compilerService = new CompilerService(this); + } + Project.prototype.openReferencedFile = function (filename) { + return this.projectService.openFile(filename, false); + }; + Project.prototype.getSourceFile = function (info) { + return this.filenameToSourceFile[info.fileName]; + }; + Project.prototype.getSourceFileFromName = function (filename, requireOpen) { + var info = this.projectService.getScriptInfo(filename); + if (info) { + if ((!requireOpen) || info.isOpen) { + return this.getSourceFile(info); + } + } + }; + Project.prototype.removeReferencedFile = function (info) { + this.compilerService.host.removeReferencedFile(info); + this.updateGraph(); + }; + Project.prototype.updateFileMap = function () { + this.filenameToSourceFile = {}; + var sourceFiles = this.program.getSourceFiles(); + for (var i = 0, len = sourceFiles.length; i < len; i++) { + var normFilename = ts.normalizePath(sourceFiles[i].fileName); + this.filenameToSourceFile[normFilename] = sourceFiles[i]; + } + }; + Project.prototype.finishGraph = function () { + this.updateGraph(); + this.compilerService.languageService.getNavigateToItems(".*"); + }; + Project.prototype.updateGraph = function () { + this.program = this.compilerService.languageService.getProgram(); + this.updateFileMap(); + }; + Project.prototype.isConfiguredProject = function () { + return this.projectFilename; + }; + Project.prototype.addRoot = function (info) { + info.defaultProject = this; + this.compilerService.host.addRoot(info); + }; + Project.prototype.filesToString = function () { + var strBuilder = ""; + ts.forEachValue(this.filenameToSourceFile, function (sourceFile) { strBuilder += sourceFile.fileName + "\n"; }); + return strBuilder; + }; + Project.prototype.setProjectOptions = function (projectOptions) { + this.projectOptions = projectOptions; + if (projectOptions.compilerOptions) { + this.compilerService.setCompilerOptions(projectOptions.compilerOptions); + } + }; + return Project; + })(); + server.Project = Project; + function copyListRemovingItem(item, list) { + var copiedList = []; + for (var i = 0, len = list.length; i < len; i++) { + if (list[i] != item) { + copiedList.push(list[i]); + } + } + return copiedList; + } + var ProjectService = (function () { + function ProjectService(host, psLogger, eventHandler) { + this.host = host; + this.psLogger = psLogger; + this.eventHandler = eventHandler; + this.filenameToScriptInfo = {}; + this.openFileRoots = []; + this.openFilesReferenced = []; + this.inferredProjects = []; + } + ProjectService.prototype.watchedFileChanged = function (fileName) { + var info = this.filenameToScriptInfo[fileName]; + if (!info) { + this.psLogger.info("Error: got watch notification for unknown file: " + fileName); + } + if (!this.host.fileExists(fileName)) { + this.fileDeletedInFilesystem(info); + } + else { + if (info && (!info.isOpen)) { + info.svc.reloadFromFile(info.fileName); + } + } + }; + ProjectService.prototype.log = function (msg, type) { + if (type === void 0) { type = "Err"; } + this.psLogger.msg(msg, type); + }; + ProjectService.prototype.closeLog = function () { + this.psLogger.close(); + }; + ProjectService.prototype.createInferredProject = function (root) { + var iproj = new Project(this); + iproj.addRoot(root); + iproj.finishGraph(); + this.inferredProjects.push(iproj); + return iproj; + }; + ProjectService.prototype.fileDeletedInFilesystem = function (info) { + this.psLogger.info(info.fileName + " deleted"); + if (info.fileWatcher) { + info.fileWatcher.close(); + info.fileWatcher = undefined; + } + if (!info.isOpen) { + this.filenameToScriptInfo[info.fileName] = undefined; + var referencingProjects = this.findReferencingProjects(info); + for (var i = 0, len = referencingProjects.length; i < len; i++) { + referencingProjects[i].removeReferencedFile(info); + } + for (var j = 0, flen = this.openFileRoots.length; j < flen; j++) { + var openFile = this.openFileRoots[j]; + if (this.eventHandler) { + this.eventHandler("context", openFile.defaultProject, openFile.fileName); + } + } + for (var j = 0, flen = this.openFilesReferenced.length; j < flen; j++) { + var openFile = this.openFilesReferenced[j]; + if (this.eventHandler) { + this.eventHandler("context", openFile.defaultProject, openFile.fileName); + } + } + } + this.printProjects(); + }; + ProjectService.prototype.addOpenFile = function (info) { + this.findReferencingProjects(info); + if (info.defaultProject) { + this.openFilesReferenced.push(info); + } + else { + info.defaultProject = this.createInferredProject(info); + var openFileRoots = []; + for (var i = 0, len = this.openFileRoots.length; i < len; i++) { + var r = this.openFileRoots[i]; + if (info.defaultProject.getSourceFile(r)) { + this.inferredProjects = + copyListRemovingItem(r.defaultProject, this.inferredProjects); + this.openFilesReferenced.push(r); + r.defaultProject = info.defaultProject; + } + else { + openFileRoots.push(r); + } + } + this.openFileRoots = openFileRoots; + this.openFileRoots.push(info); + } + }; + ProjectService.prototype.closeOpenFile = function (info) { + var openFileRoots = []; + var removedProject; + for (var i = 0, len = this.openFileRoots.length; i < len; i++) { + if (info == this.openFileRoots[i]) { + removedProject = info.defaultProject; + } + else { + openFileRoots.push(this.openFileRoots[i]); + } + } + this.openFileRoots = openFileRoots; + if (removedProject) { + this.inferredProjects = copyListRemovingItem(removedProject, this.inferredProjects); + var openFilesReferenced = []; + var orphanFiles = []; + for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) { + var f = this.openFilesReferenced[i]; + if (f.defaultProject == removedProject) { + f.defaultProject = undefined; + orphanFiles.push(f); + } + else { + openFilesReferenced.push(f); + } + } + this.openFilesReferenced = openFilesReferenced; + for (var i = 0, len = orphanFiles.length; i < len; i++) { + this.addOpenFile(orphanFiles[i]); + } + } + else { + this.openFilesReferenced = copyListRemovingItem(info, this.openFilesReferenced); + } + info.close(); + }; + ProjectService.prototype.findReferencingProjects = function (info, excludedProject) { + var referencingProjects = []; + info.defaultProject = undefined; + for (var i = 0, len = this.inferredProjects.length; i < len; i++) { + this.inferredProjects[i].updateGraph(); + if (this.inferredProjects[i] != excludedProject) { + if (this.inferredProjects[i].getSourceFile(info)) { + info.defaultProject = this.inferredProjects[i]; + referencingProjects.push(this.inferredProjects[i]); + } + } + } + return referencingProjects; + }; + ProjectService.prototype.updateProjectStructure = function () { + this.log("updating project structure from ...", "Info"); + this.printProjects(); + for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) { + var refdFile = this.openFilesReferenced[i]; + refdFile.defaultProject.updateGraph(); + var sourceFile = refdFile.defaultProject.getSourceFile(refdFile); + if (!sourceFile) { + this.openFilesReferenced = copyListRemovingItem(refdFile, this.openFilesReferenced); + this.addOpenFile(refdFile); + } + } + var openFileRoots = []; + for (var i = 0, len = this.openFileRoots.length; i < len; i++) { + var rootFile = this.openFileRoots[i]; + var rootedProject = rootFile.defaultProject; + var referencingProjects = this.findReferencingProjects(rootFile, rootedProject); + if (referencingProjects.length == 0) { + rootFile.defaultProject = rootedProject; + openFileRoots.push(rootFile); + } + else { + this.inferredProjects = copyListRemovingItem(rootedProject, this.inferredProjects); + this.openFilesReferenced.push(rootFile); + } + } + this.openFileRoots = openFileRoots; + this.printProjects(); + }; + ProjectService.prototype.getScriptInfo = function (filename) { + filename = ts.normalizePath(filename); + return ts.lookUp(this.filenameToScriptInfo, filename); + }; + ProjectService.prototype.openFile = function (fileName, openedByClient) { + var _this = this; + if (openedByClient === void 0) { openedByClient = false; } + fileName = ts.normalizePath(fileName); + var info = ts.lookUp(this.filenameToScriptInfo, fileName); + if (!info) { + var content; + if (this.host.fileExists(fileName)) { + content = this.host.readFile(fileName); + } + if (!content) { + if (openedByClient) { + content = ""; + } + } + if (content !== undefined) { + info = new ScriptInfo(this.host, fileName, content, openedByClient); + this.filenameToScriptInfo[fileName] = info; + if (!info.isOpen) { + info.fileWatcher = this.host.watchFile(fileName, function (_) { _this.watchedFileChanged(fileName); }); + } + } + } + if (info) { + if (openedByClient) { + info.isOpen = true; + } + } + return info; + }; + ProjectService.prototype.openClientFile = function (filename) { + var info = this.openFile(filename, true); + this.addOpenFile(info); + this.printProjects(); + return info; + }; + ProjectService.prototype.closeClientFile = function (filename) { + var info = ts.lookUp(this.filenameToScriptInfo, filename); + if (info) { + this.closeOpenFile(info); + info.isOpen = false; + } + this.printProjects(); + }; + ProjectService.prototype.getProjectsReferencingFile = function (filename) { + var scriptInfo = ts.lookUp(this.filenameToScriptInfo, filename); + if (scriptInfo) { + var projects = []; + for (var i = 0, len = this.inferredProjects.length; i < len; i++) { + if (this.inferredProjects[i].getSourceFile(scriptInfo)) { + projects.push(this.inferredProjects[i]); + } + } + return projects; + } + }; + ProjectService.prototype.getProjectForFile = function (filename) { + var scriptInfo = ts.lookUp(this.filenameToScriptInfo, filename); + if (scriptInfo) { + return scriptInfo.defaultProject; + } + }; + ProjectService.prototype.printProjectsForFile = function (filename) { + var scriptInfo = ts.lookUp(this.filenameToScriptInfo, filename); + if (scriptInfo) { + this.psLogger.startGroup(); + this.psLogger.info("Projects for " + filename); + var projects = this.getProjectsReferencingFile(filename); + for (var i = 0, len = projects.length; i < len; i++) { + this.psLogger.info("Inferred Project " + i.toString()); + } + this.psLogger.endGroup(); + } + else { + this.psLogger.info(filename + " not in any project"); + } + }; + ProjectService.prototype.printProjects = function () { + this.psLogger.startGroup(); + for (var i = 0, len = this.inferredProjects.length; i < len; i++) { + var project = this.inferredProjects[i]; + project.updateGraph(); + this.psLogger.info("Project " + i.toString()); + this.psLogger.info(project.filesToString()); + this.psLogger.info("-----------------------------------------------"); + } + this.psLogger.info("Open file roots: "); + for (var i = 0, len = this.openFileRoots.length; i < len; i++) { + this.psLogger.info(this.openFileRoots[i].fileName); + } + this.psLogger.info("Open files referenced: "); + for (var i = 0, len = this.openFilesReferenced.length; i < len; i++) { + this.psLogger.info(this.openFilesReferenced[i].fileName); + } + this.psLogger.endGroup(); + }; + ProjectService.prototype.openConfigFile = function (configFilename) { + configFilename = ts.normalizePath(configFilename); + var dirPath = ts.getDirectoryPath(configFilename); + var rawConfig = ts.readConfigFile(configFilename); + if (!rawConfig) { + return { errorMsg: "tsconfig syntax error" }; + } + else { + var parsedCommandLine = ts.parseConfigFile(rawConfig); + if (parsedCommandLine.errors) { + return { errorMsg: "tsconfig option errors" }; + } + else if (parsedCommandLine.fileNames) { + var proj = this.createProject(configFilename); + for (var i = 0, len = parsedCommandLine.fileNames.length; i < len; i++) { + var rootFilename = parsedCommandLine.fileNames[i]; + var normRootFilename = ts.normalizePath(rootFilename); + normRootFilename = getAbsolutePath(normRootFilename, dirPath); + if (this.host.fileExists(normRootFilename)) { + var info = this.openFile(normRootFilename); + proj.addRoot(info); + } + else { + return { errorMsg: "specified file " + rootFilename + " not found" }; + } + } + var projectOptions = { + files: parsedCommandLine.fileNames, + compilerOptions: parsedCommandLine.options + }; + if (rawConfig.formatCodeOptions) { + projectOptions.formatCodeOptions = rawConfig.formatCodeOptions; + } + proj.setProjectOptions(projectOptions); + return { success: true, project: proj }; + } + else { + return { errorMsg: "no files found" }; + } + } + }; + ProjectService.prototype.createProject = function (projectFilename) { + var eproj = new Project(this); + eproj.projectFilename = projectFilename; + return eproj; + }; + return ProjectService; + })(); + server.ProjectService = ProjectService; + var CompilerService = (function () { + function CompilerService(project) { + this.project = project; + this.settings = ts.getDefaultCompilerOptions(); + this.documentRegistry = ts.createDocumentRegistry(); + this.formatCodeOptions = CompilerService.defaultFormatCodeOptions; + this.host = new LSHost(project.projectService.host, project); + this.settings.target = 1; + this.host.setCompilationSettings(this.settings); + this.languageService = ts.createLanguageService(this.host, this.documentRegistry); + this.classifier = ts.createClassifier(); + } + CompilerService.prototype.setCompilerOptions = function (opt) { + this.settings = opt; + this.host.setCompilationSettings(opt); + }; + CompilerService.prototype.isExternalModule = function (filename) { + var sourceFile = this.languageService.getSourceFile(filename); + return ts.isExternalModule(sourceFile); + }; + CompilerService.defaultFormatCodeOptions = { + IndentSize: 4, + TabSize: 4, + NewLineCharacter: ts.sys.newLine, + ConvertTabsToSpaces: true, + InsertSpaceAfterCommaDelimiter: true, + InsertSpaceAfterSemicolonInForStatements: true, + InsertSpaceBeforeAndAfterBinaryOperators: true, + InsertSpaceAfterKeywordsInControlFlowStatements: true, + InsertSpaceAfterFunctionKeywordForAnonymousFunctions: false, + InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false, + PlaceOpenBraceOnNewLineForFunctions: false, + PlaceOpenBraceOnNewLineForControlBlocks: false + }; + return CompilerService; + })(); + var CharRangeSection; + (function (CharRangeSection) { + CharRangeSection[CharRangeSection["PreStart"] = 0] = "PreStart"; + CharRangeSection[CharRangeSection["Start"] = 1] = "Start"; + CharRangeSection[CharRangeSection["Entire"] = 2] = "Entire"; + CharRangeSection[CharRangeSection["Mid"] = 3] = "Mid"; + CharRangeSection[CharRangeSection["End"] = 4] = "End"; + CharRangeSection[CharRangeSection["PostEnd"] = 5] = "PostEnd"; + })(CharRangeSection || (CharRangeSection = {})); + var BaseLineIndexWalker = (function () { + function BaseLineIndexWalker() { + this.goSubtree = true; + this.done = false; + } + BaseLineIndexWalker.prototype.leaf = function (rangeStart, rangeLength, ll) { + }; + return BaseLineIndexWalker; + })(); + var EditWalker = (function (_super) { + __extends(EditWalker, _super); + function EditWalker() { + _super.call(this); + this.lineIndex = new LineIndex(); + this.endBranch = []; + this.state = 2; + this.initialText = ""; + this.trailingText = ""; + this.suppressTrailingText = false; + this.lineIndex.root = new LineNode(); + this.startPath = [this.lineIndex.root]; + this.stack = [this.lineIndex.root]; + } + EditWalker.prototype.insertLines = function (insertedText) { + if (this.suppressTrailingText) { + this.trailingText = ""; + } + if (insertedText) { + insertedText = this.initialText + insertedText + this.trailingText; + } + else { + insertedText = this.initialText + this.trailingText; + } + var lm = LineIndex.linesFromText(insertedText); + var lines = lm.lines; + if (lines.length > 1) { + if (lines[lines.length - 1] == "") { + lines.length--; + } + } + var branchParent; + var lastZeroCount; + for (var k = this.endBranch.length - 1; k >= 0; k--) { + this.endBranch[k].updateCounts(); + if (this.endBranch[k].charCount() == 0) { + lastZeroCount = this.endBranch[k]; + if (k > 0) { + branchParent = this.endBranch[k - 1]; + } + else { + branchParent = this.branchNode; + } + } + } + if (lastZeroCount) { + branchParent.remove(lastZeroCount); + } + var insertionNode = this.startPath[this.startPath.length - 2]; + var leafNode = this.startPath[this.startPath.length - 1]; + var len = lines.length; + if (len > 0) { + leafNode.text = lines[0]; + if (len > 1) { + var insertedNodes = new Array(len - 1); + var startNode = leafNode; + for (var i = 1, len = lines.length; i < len; i++) { + insertedNodes[i - 1] = new LineLeaf(lines[i]); + } + var pathIndex = this.startPath.length - 2; + while (pathIndex >= 0) { + insertionNode = this.startPath[pathIndex]; + insertedNodes = insertionNode.insertAt(startNode, insertedNodes); + pathIndex--; + startNode = insertionNode; + } + var insertedNodesLen = insertedNodes.length; + while (insertedNodesLen > 0) { + var newRoot = new LineNode(); + newRoot.add(this.lineIndex.root); + insertedNodes = newRoot.insertAt(this.lineIndex.root, insertedNodes); + insertedNodesLen = insertedNodes.length; + this.lineIndex.root = newRoot; + } + this.lineIndex.root.updateCounts(); + } + else { + for (var j = this.startPath.length - 2; j >= 0; j--) { + this.startPath[j].updateCounts(); + } + } + } + else { + insertionNode.remove(leafNode); + for (var j = this.startPath.length - 2; j >= 0; j--) { + this.startPath[j].updateCounts(); + } + } + return this.lineIndex; + }; + EditWalker.prototype.post = function (relativeStart, relativeLength, lineCollection, parent, nodeType) { + if (lineCollection == this.lineCollectionAtBranch) { + this.state = 4; + } + this.stack.length--; + return undefined; + }; + EditWalker.prototype.pre = function (relativeStart, relativeLength, lineCollection, parent, nodeType) { + var currentNode = this.stack[this.stack.length - 1]; + if ((this.state == 2) && (nodeType == 1)) { + this.state = 1; + this.branchNode = currentNode; + this.lineCollectionAtBranch = lineCollection; + } + var child; + function fresh(node) { + if (node.isLeaf()) { + return new LineLeaf(""); + } + else + return new LineNode(); + } + switch (nodeType) { + case 0: + this.goSubtree = false; + if (this.state != 4) { + currentNode.add(lineCollection); + } + break; + case 1: + if (this.state == 4) { + this.goSubtree = false; + } + else { + child = fresh(lineCollection); + currentNode.add(child); + this.startPath[this.startPath.length] = child; + } + break; + case 2: + if (this.state != 4) { + child = fresh(lineCollection); + currentNode.add(child); + this.startPath[this.startPath.length] = child; + } + else { + if (!lineCollection.isLeaf()) { + child = fresh(lineCollection); + currentNode.add(child); + this.endBranch[this.endBranch.length] = child; + } + } + break; + case 3: + this.goSubtree = false; + break; + case 4: + if (this.state != 4) { + this.goSubtree = false; + } + else { + if (!lineCollection.isLeaf()) { + child = fresh(lineCollection); + currentNode.add(child); + this.endBranch[this.endBranch.length] = child; + } + } + break; + case 5: + this.goSubtree = false; + if (this.state != 1) { + currentNode.add(lineCollection); + } + break; + } + if (this.goSubtree) { + this.stack[this.stack.length] = child; + } + return lineCollection; + }; + EditWalker.prototype.leaf = function (relativeStart, relativeLength, ll) { + if (this.state == 1) { + this.initialText = ll.text.substring(0, relativeStart); + } + else if (this.state == 2) { + this.initialText = ll.text.substring(0, relativeStart); + this.trailingText = ll.text.substring(relativeStart + relativeLength); + } + else { + this.trailingText = ll.text.substring(relativeStart + relativeLength); + } + }; + return EditWalker; + })(BaseLineIndexWalker); + var TextChange = (function () { + function TextChange(pos, deleteLen, insertedText) { + this.pos = pos; + this.deleteLen = deleteLen; + this.insertedText = insertedText; + } + TextChange.prototype.getTextChangeRange = function () { + return ts.createTextChangeRange(ts.createTextSpan(this.pos, this.deleteLen), this.insertedText ? this.insertedText.length : 0); + }; + return TextChange; + })(); + var ScriptVersionCache = (function () { + function ScriptVersionCache() { + this.changes = []; + this.versions = []; + this.minVersion = 0; + this.currentVersion = 0; + } + ScriptVersionCache.prototype.edit = function (pos, deleteLen, insertedText) { + this.changes[this.changes.length] = new TextChange(pos, deleteLen, insertedText); + if ((this.changes.length > ScriptVersionCache.changeNumberThreshold) || + (deleteLen > ScriptVersionCache.changeLengthThreshold) || + (insertedText && (insertedText.length > ScriptVersionCache.changeLengthThreshold))) { + this.getSnapshot(); + } + }; + ScriptVersionCache.prototype.latest = function () { + return this.versions[this.currentVersion]; + }; + ScriptVersionCache.prototype.latestVersion = function () { + if (this.changes.length > 0) { + this.getSnapshot(); + } + return this.currentVersion; + }; + ScriptVersionCache.prototype.reloadFromFile = function (filename, cb) { + var content = ts.sys.readFile(filename); + this.reload(content); + if (cb) + cb(); + }; + ScriptVersionCache.prototype.reload = function (script) { + this.currentVersion++; + this.changes = []; + var snap = new LineIndexSnapshot(this.currentVersion, this); + this.versions[this.currentVersion] = snap; + snap.index = new LineIndex(); + var lm = LineIndex.linesFromText(script); + snap.index.load(lm.lines); + for (var i = this.minVersion; i < this.currentVersion; i++) { + this.versions[i] = undefined; + } + this.minVersion = this.currentVersion; + }; + ScriptVersionCache.prototype.getSnapshot = function () { + var snap = this.versions[this.currentVersion]; + if (this.changes.length > 0) { + var snapIndex = this.latest().index; + for (var i = 0, len = this.changes.length; i < len; i++) { + var change = this.changes[i]; + snapIndex = snapIndex.edit(change.pos, change.deleteLen, change.insertedText); + } + snap = new LineIndexSnapshot(this.currentVersion + 1, this); + snap.index = snapIndex; + snap.changesSincePreviousVersion = this.changes; + this.currentVersion = snap.version; + this.versions[snap.version] = snap; + this.changes = []; + } + return snap; + }; + ScriptVersionCache.prototype.getTextChangesBetweenVersions = function (oldVersion, newVersion) { + if (oldVersion < newVersion) { + if (oldVersion >= this.minVersion) { + var textChangeRanges = []; + for (var i = oldVersion + 1; i <= newVersion; i++) { + var snap = this.versions[i]; + for (var j = 0, len = snap.changesSincePreviousVersion.length; j < len; j++) { + var textChange = snap.changesSincePreviousVersion[j]; + textChangeRanges[textChangeRanges.length] = textChange.getTextChangeRange(); + } + } + return ts.collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges); + } + else { + return undefined; + } + } + else { + return ts.unchangedTextChangeRange; + } + }; + ScriptVersionCache.fromString = function (script) { + var svc = new ScriptVersionCache(); + var snap = new LineIndexSnapshot(0, svc); + svc.versions[svc.currentVersion] = snap; + snap.index = new LineIndex(); + var lm = LineIndex.linesFromText(script); + snap.index.load(lm.lines); + return svc; + }; + ScriptVersionCache.changeNumberThreshold = 8; + ScriptVersionCache.changeLengthThreshold = 256; + return ScriptVersionCache; + })(); + var LineIndexSnapshot = (function () { + function LineIndexSnapshot(version, cache) { + this.version = version; + this.cache = cache; + this.changesSincePreviousVersion = []; + } + LineIndexSnapshot.prototype.getText = function (rangeStart, rangeEnd) { + return this.index.getText(rangeStart, rangeEnd - rangeStart); + }; + LineIndexSnapshot.prototype.getLength = function () { + return this.index.root.charCount(); + }; + LineIndexSnapshot.prototype.getLineStartPositions = function () { + var starts = [-1]; + var count = 1; + var pos = 0; + this.index.every(function (ll, s, len) { + starts[count++] = pos; + pos += ll.text.length; + return true; + }, 0); + return starts; + }; + LineIndexSnapshot.prototype.getLineMapper = function () { + var _this = this; + return (function (line) { + return _this.index.lineNumberToInfo(line).col; + }); + }; + LineIndexSnapshot.prototype.getTextChangeRangeSinceVersion = function (scriptVersion) { + if (this.version <= scriptVersion) { + return ts.unchangedTextChangeRange; + } + else { + return this.cache.getTextChangesBetweenVersions(scriptVersion, this.version); + } + }; + LineIndexSnapshot.prototype.getChangeRange = function (oldSnapshot) { + var oldSnap = oldSnapshot; + return this.getTextChangeRangeSinceVersion(oldSnap.version); + }; + return LineIndexSnapshot; + })(); + var LineIndex = (function () { + function LineIndex() { + this.checkEdits = false; + } + LineIndex.prototype.charOffsetToLineNumberAndPos = function (charOffset) { + return this.root.charOffsetToLineNumberAndPos(1, charOffset); + }; + LineIndex.prototype.lineNumberToInfo = function (lineNumber) { + var lineCount = this.root.lineCount(); + if (lineNumber <= lineCount) { + var lineInfo = this.root.lineNumberToInfo(lineNumber, 0); + lineInfo.line = lineNumber; + return lineInfo; + } + else { + return { + line: lineNumber, + col: this.root.charCount() + }; + } + }; + LineIndex.prototype.load = function (lines) { + if (lines.length > 0) { + var leaves = []; + for (var i = 0, len = lines.length; i < len; i++) { + leaves[i] = new LineLeaf(lines[i]); + } + this.root = LineIndex.buildTreeFromBottom(leaves); + } + else { + this.root = new LineNode(); + } + }; + LineIndex.prototype.walk = function (rangeStart, rangeLength, walkFns) { + this.root.walk(rangeStart, rangeLength, walkFns); + }; + LineIndex.prototype.getText = function (rangeStart, rangeLength) { + var accum = ""; + if (rangeLength > 0) { + this.walk(rangeStart, rangeLength, { + goSubtree: true, + done: false, + leaf: function (relativeStart, relativeLength, ll) { + accum = accum.concat(ll.text.substring(relativeStart, relativeStart + relativeLength)); + } + }); + } + return accum; + }; + LineIndex.prototype.every = function (f, rangeStart, rangeEnd) { + if (!rangeEnd) { + rangeEnd = this.root.charCount(); + } + var walkFns = { + goSubtree: true, + done: false, + leaf: function (relativeStart, relativeLength, ll) { + if (!f(ll, relativeStart, relativeLength)) { + this.done = true; + } + } + }; + this.walk(rangeStart, rangeEnd - rangeStart, walkFns); + return !walkFns.done; + }; + LineIndex.prototype.edit = function (pos, deleteLength, newText) { + function editFlat(source, s, dl, nt) { + if (nt === void 0) { nt = ""; } + return source.substring(0, s) + nt + source.substring(s + dl, source.length); + } + if (this.root.charCount() == 0) { + if (newText) { + this.load(LineIndex.linesFromText(newText).lines); + return this; + } + } + else { + if (this.checkEdits) { + var checkText = editFlat(this.getText(0, this.root.charCount()), pos, deleteLength, newText); + } + var walker = new EditWalker(); + if (deleteLength > 0) { + var e = pos + deleteLength; + var lineInfo = this.charOffsetToLineNumberAndPos(e); + if ((lineInfo && (lineInfo.col == 0))) { + deleteLength += lineInfo.text.length; + if (newText) { + newText = newText + lineInfo.text; + } + else { + newText = lineInfo.text; + } + } + } + else if (pos >= this.root.charCount()) { + var endString = this.getText(pos - 1, 1); + if (newText) { + newText = endString + newText; + } + else { + newText = endString; + } + pos = pos - 1; + deleteLength = 0; + walker.suppressTrailingText = true; + } + this.root.walk(pos, deleteLength, walker); + walker.insertLines(newText); + if (this.checkEdits) { + var updatedText = this.getText(0, this.root.charCount()); + ts.Debug.assert(checkText == updatedText, "buffer edit mismatch"); + } + return walker.lineIndex; + } + }; + LineIndex.buildTreeFromBottom = function (nodes) { + var nodeCount = Math.ceil(nodes.length / lineCollectionCapacity); + var interiorNodes = []; + var nodeIndex = 0; + for (var i = 0; i < nodeCount; i++) { + interiorNodes[i] = new LineNode(); + var charCount = 0; + var lineCount = 0; + for (var j = 0; j < lineCollectionCapacity; j++) { + if (nodeIndex < nodes.length) { + interiorNodes[i].add(nodes[nodeIndex]); + charCount += nodes[nodeIndex].charCount(); + lineCount += nodes[nodeIndex].lineCount(); + } + else { + break; + } + nodeIndex++; + } + interiorNodes[i].totalChars = charCount; + interiorNodes[i].totalLines = lineCount; + } + if (interiorNodes.length == 1) { + return interiorNodes[0]; + } + else { + return this.buildTreeFromBottom(interiorNodes); + } + }; + LineIndex.linesFromText = function (text) { + var lineStarts = ts.computeLineStarts(text); + if (lineStarts.length == 0) { + return { lines: [], lineMap: lineStarts }; + } + var lines = new Array(lineStarts.length); + var lc = lineStarts.length - 1; + for (var lmi = 0; lmi < lc; lmi++) { + lines[lmi] = text.substring(lineStarts[lmi], lineStarts[lmi + 1]); + } + var endText = text.substring(lineStarts[lc]); + if (endText.length > 0) { + lines[lc] = endText; + } + else { + lines.length--; + } + return { lines: lines, lineMap: lineStarts }; + }; + return LineIndex; + })(); + var LineNode = (function () { + function LineNode() { + this.totalChars = 0; + this.totalLines = 0; + this.children = []; + } + LineNode.prototype.isLeaf = function () { + return false; + }; + LineNode.prototype.updateCounts = function () { + this.totalChars = 0; + this.totalLines = 0; + for (var i = 0, len = this.children.length; i < len; i++) { + var child = this.children[i]; + this.totalChars += child.charCount(); + this.totalLines += child.lineCount(); + } + }; + LineNode.prototype.execWalk = function (rangeStart, rangeLength, walkFns, childIndex, nodeType) { + if (walkFns.pre) { + walkFns.pre(rangeStart, rangeLength, this.children[childIndex], this, nodeType); + } + if (walkFns.goSubtree) { + this.children[childIndex].walk(rangeStart, rangeLength, walkFns); + if (walkFns.post) { + walkFns.post(rangeStart, rangeLength, this.children[childIndex], this, nodeType); + } + } + else { + walkFns.goSubtree = true; + } + return walkFns.done; + }; + LineNode.prototype.skipChild = function (relativeStart, relativeLength, childIndex, walkFns, nodeType) { + if (walkFns.pre && (!walkFns.done)) { + walkFns.pre(relativeStart, relativeLength, this.children[childIndex], this, nodeType); + walkFns.goSubtree = true; + } + }; + LineNode.prototype.walk = function (rangeStart, rangeLength, walkFns) { + var childIndex = 0; + var child = this.children[0]; + var childCharCount = child.charCount(); + var adjustedStart = rangeStart; + while (adjustedStart >= childCharCount) { + this.skipChild(adjustedStart, rangeLength, childIndex, walkFns, 0); + adjustedStart -= childCharCount; + child = this.children[++childIndex]; + childCharCount = child.charCount(); + } + if ((adjustedStart + rangeLength) <= childCharCount) { + if (this.execWalk(adjustedStart, rangeLength, walkFns, childIndex, 2)) { + return; + } + } + else { + if (this.execWalk(adjustedStart, childCharCount - adjustedStart, walkFns, childIndex, 1)) { + return; + } + var adjustedLength = rangeLength - (childCharCount - adjustedStart); + child = this.children[++childIndex]; + childCharCount = child.charCount(); + while (adjustedLength > childCharCount) { + if (this.execWalk(0, childCharCount, walkFns, childIndex, 3)) { + return; + } + adjustedLength -= childCharCount; + child = this.children[++childIndex]; + childCharCount = child.charCount(); + } + if (adjustedLength > 0) { + if (this.execWalk(0, adjustedLength, walkFns, childIndex, 4)) { + return; + } + } + } + if (walkFns.pre) { + var clen = this.children.length; + if (childIndex < (clen - 1)) { + for (var ej = childIndex + 1; ej < clen; ej++) { + this.skipChild(0, 0, ej, walkFns, 5); + } + } + } + }; + LineNode.prototype.charOffsetToLineNumberAndPos = function (lineNumber, charOffset) { + var childInfo = this.childFromCharOffset(lineNumber, charOffset); + if (!childInfo.child) { + return { + line: lineNumber, + col: charOffset + }; + } + else if (childInfo.childIndex < this.children.length) { + if (childInfo.child.isLeaf()) { + return { + line: childInfo.lineNumber, + col: childInfo.charOffset, + text: (childInfo.child).text, + leaf: (childInfo.child) + }; + } + else { + var lineNode = (childInfo.child); + return lineNode.charOffsetToLineNumberAndPos(childInfo.lineNumber, childInfo.charOffset); + } + } + else { + var lineInfo = this.lineNumberToInfo(this.lineCount(), 0); + return { line: this.lineCount(), col: lineInfo.leaf.charCount() }; + } + }; + LineNode.prototype.lineNumberToInfo = function (lineNumber, charOffset) { + var childInfo = this.childFromLineNumber(lineNumber, charOffset); + if (!childInfo.child) { + return { + line: lineNumber, + col: charOffset + }; + } + else if (childInfo.child.isLeaf()) { + return { + line: lineNumber, + col: childInfo.charOffset, + text: (childInfo.child).text, + leaf: (childInfo.child) + }; + } + else { + var lineNode = (childInfo.child); + return lineNode.lineNumberToInfo(childInfo.relativeLineNumber, childInfo.charOffset); + } + }; + LineNode.prototype.childFromLineNumber = function (lineNumber, charOffset) { + var child; + var relativeLineNumber = lineNumber; + for (var i = 0, len = this.children.length; i < len; i++) { + child = this.children[i]; + var childLineCount = child.lineCount(); + if (childLineCount >= relativeLineNumber) { + break; + } + else { + relativeLineNumber -= childLineCount; + charOffset += child.charCount(); + } + } + return { + child: child, + childIndex: i, + relativeLineNumber: relativeLineNumber, + charOffset: charOffset + }; + }; + LineNode.prototype.childFromCharOffset = function (lineNumber, charOffset) { + var child; + for (var i = 0, len = this.children.length; i < len; i++) { + child = this.children[i]; + if (child.charCount() > charOffset) { + break; + } + else { + charOffset -= child.charCount(); + lineNumber += child.lineCount(); + } + } + return { + child: child, + childIndex: i, + charOffset: charOffset, + lineNumber: lineNumber + }; + }; + LineNode.prototype.splitAfter = function (childIndex) { + var splitNode; + var clen = this.children.length; + childIndex++; + var endLength = childIndex; + if (childIndex < clen) { + splitNode = new LineNode(); + while (childIndex < clen) { + splitNode.add(this.children[childIndex++]); + } + splitNode.updateCounts(); + } + this.children.length = endLength; + return splitNode; + }; + LineNode.prototype.remove = function (child) { + var childIndex = this.findChildIndex(child); + var clen = this.children.length; + if (childIndex < (clen - 1)) { + for (var i = childIndex; i < (clen - 1); i++) { + this.children[i] = this.children[i + 1]; + } + } + this.children.length--; + }; + LineNode.prototype.findChildIndex = function (child) { + var childIndex = 0; + var clen = this.children.length; + while ((this.children[childIndex] != child) && (childIndex < clen)) + childIndex++; + return childIndex; + }; + LineNode.prototype.insertAt = function (child, nodes) { + var childIndex = this.findChildIndex(child); + var clen = this.children.length; + var nodeCount = nodes.length; + if ((clen < lineCollectionCapacity) && (childIndex == (clen - 1)) && (nodeCount == 1)) { + this.add(nodes[0]); + this.updateCounts(); + return []; + } + else { + var shiftNode = this.splitAfter(childIndex); + var nodeIndex = 0; + childIndex++; + while ((childIndex < lineCollectionCapacity) && (nodeIndex < nodeCount)) { + this.children[childIndex++] = nodes[nodeIndex++]; + } + var splitNodes = []; + var splitNodeCount = 0; + if (nodeIndex < nodeCount) { + splitNodeCount = Math.ceil((nodeCount - nodeIndex) / lineCollectionCapacity); + splitNodes = new Array(splitNodeCount); + var splitNodeIndex = 0; + for (var i = 0; i < splitNodeCount; i++) { + splitNodes[i] = new LineNode(); + } + var splitNode = splitNodes[0]; + while (nodeIndex < nodeCount) { + splitNode.add(nodes[nodeIndex++]); + if (splitNode.children.length == lineCollectionCapacity) { + splitNodeIndex++; + splitNode = splitNodes[splitNodeIndex]; + } + } + for (i = splitNodes.length - 1; i >= 0; i--) { + if (splitNodes[i].children.length == 0) { + splitNodes.length--; + } + } + } + if (shiftNode) { + splitNodes[splitNodes.length] = shiftNode; + } + this.updateCounts(); + for (i = 0; i < splitNodeCount; i++) { + splitNodes[i].updateCounts(); + } + return splitNodes; + } + }; + LineNode.prototype.add = function (collection) { + this.children[this.children.length] = collection; + return (this.children.length < lineCollectionCapacity); + }; + LineNode.prototype.charCount = function () { + return this.totalChars; + }; + LineNode.prototype.lineCount = function () { + return this.totalLines; + }; + return LineNode; + })(); + var LineLeaf = (function () { + function LineLeaf(text) { + this.text = text; + } + LineLeaf.prototype.setUdata = function (data) { + this.udata = data; + }; + LineLeaf.prototype.getUdata = function () { + return this.udata; + }; + LineLeaf.prototype.isLeaf = function () { + return true; + }; + LineLeaf.prototype.walk = function (rangeStart, rangeLength, walkFns) { + walkFns.leaf(rangeStart, rangeLength, this); + }; + LineLeaf.prototype.charCount = function () { + return this.text.length; + }; + LineLeaf.prototype.lineCount = function () { + return 1; + }; + return LineLeaf; + })(); + })(server = ts.server || (ts.server = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var server; + (function (server) { + var spaceCache = [" ", " ", " ", " "]; + function generateSpaces(n) { + if (!spaceCache[n]) { + var strBuilder = ""; + for (var i = 0; i < n; i++) { + strBuilder += " "; + } + spaceCache[n] = strBuilder; + } + return spaceCache[n]; + } + function compareNumber(a, b) { + if (a < b) { + return -1; + } + else if (a == b) { + return 0; + } + else + return 1; + } + function compareFileStart(a, b) { + if (a.file < b.file) { + return -1; + } + else if (a.file == b.file) { + var n = compareNumber(a.start.line, b.start.line); + if (n == 0) { + return compareNumber(a.start.col, b.start.col); + } + else + return n; + } + else { + return 1; + } + } + function formatDiag(fileName, project, diag) { + return { + start: project.compilerService.host.positionToLineCol(fileName, diag.start), + end: project.compilerService.host.positionToLineCol(fileName, diag.start + diag.length), + text: ts.flattenDiagnosticMessageText(diag.messageText, "\n") + }; + } + function allEditsBeforePos(edits, pos) { + for (var i = 0, len = edits.length; i < len; i++) { + if (ts.textSpanEnd(edits[i].span) >= pos) { + return false; + } + } + return true; + } + var CommandNames; + (function (CommandNames) { + CommandNames.Change = "change"; + CommandNames.Close = "close"; + CommandNames.Completions = "completions"; + CommandNames.CompletionDetails = "completionEntryDetails"; + CommandNames.Definition = "definition"; + CommandNames.Format = "format"; + CommandNames.Formatonkey = "formatonkey"; + CommandNames.Geterr = "geterr"; + CommandNames.NavBar = "navbar"; + CommandNames.Navto = "navto"; + CommandNames.Open = "open"; + CommandNames.Quickinfo = "quickinfo"; + CommandNames.References = "references"; + CommandNames.Reload = "reload"; + CommandNames.Rename = "rename"; + CommandNames.Saveto = "saveto"; + CommandNames.Brace = "brace"; + CommandNames.Unknown = "unknown"; + })(CommandNames = server.CommandNames || (server.CommandNames = {})); + var Errors; + (function (Errors) { + Errors.NoProject = new Error("No Project."); + })(Errors || (Errors = {})); + var Session = (function () { + function Session(host, logger) { + var _this = this; + this.host = host; + this.logger = logger; + this.pendingOperation = false; + this.fileHash = {}; + this.nextFileId = 1; + this.changeSeq = 0; + this.projectService = + new server.ProjectService(host, logger, function (eventName, project, fileName) { + _this.handleEvent(eventName, project, fileName); + }); + } + Session.prototype.handleEvent = function (eventName, project, fileName) { + 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); + } + }; + Session.prototype.logError = function (err, cmd) { + var typedErr = err; + var msg = "Exception on executing command " + cmd; + if (typedErr.message) { + msg += ":\n" + typedErr.message; + if (typedErr.stack) { + msg += "\n" + typedErr.stack; + } + } + this.projectService.log(msg); + }; + Session.prototype.sendLineToClient = function (line) { + this.host.write(line + this.host.newLine); + }; + Session.prototype.send = function (msg) { + var json = JSON.stringify(msg); + this.sendLineToClient('Content-Length: ' + (1 + Buffer.byteLength(json, 'utf8')) + + '\r\n\r\n' + json); + }; + Session.prototype.event = function (info, eventName) { + var ev = { + seq: 0, + type: "event", + event: eventName, + body: info + }; + this.send(ev); + }; + Session.prototype.response = function (info, cmdName, reqSeq, errorMsg) { + if (reqSeq === void 0) { reqSeq = 0; } + var res = { + seq: 0, + type: "response", + command: cmdName, + request_seq: reqSeq, + success: !errorMsg + }; + if (!errorMsg) { + res.body = info; + } + else { + res.message = errorMsg; + } + this.send(res); + }; + Session.prototype.output = function (body, commandName, requestSequence, errorMessage) { + if (requestSequence === void 0) { requestSequence = 0; } + this.response(body, commandName, requestSequence, errorMessage); + }; + Session.prototype.semanticCheck = function (file, project) { + var diags = project.compilerService.languageService.getSemanticDiagnostics(file); + if (diags) { + var bakedDiags = diags.map(function (diag) { return formatDiag(file, project, diag); }); + this.event({ file: file, diagnostics: bakedDiags }, "semanticDiag"); + } + }; + Session.prototype.syntacticCheck = function (file, project) { + var diags = project.compilerService.languageService.getSyntacticDiagnostics(file); + if (diags) { + var bakedDiags = diags.map(function (diag) { return formatDiag(file, project, diag); }); + this.event({ file: file, diagnostics: bakedDiags }, "syntaxDiag"); + } + }; + Session.prototype.errorCheck = function (file, project) { + this.syntacticCheck(file, project); + this.semanticCheck(file, project); + }; + Session.prototype.updateProjectStructure = function (seq, matchSeq, ms) { + var _this = this; + if (ms === void 0) { ms = 1500; } + setTimeout(function () { + if (matchSeq(seq)) { + _this.projectService.updateProjectStructure(); + } + }, ms); + }; + Session.prototype.updateErrorCheck = function (checkList, seq, matchSeq, ms, followMs) { + var _this = this; + if (ms === void 0) { ms = 1500; } + if (followMs === void 0) { followMs = 200; } + if (followMs > ms) { + followMs = ms; + } + if (this.errorTimer) { + clearTimeout(this.errorTimer); + } + if (this.immediateId) { + clearImmediate(this.immediateId); + this.immediateId = undefined; + } + var index = 0; + var checkOne = function () { + if (matchSeq(seq)) { + var checkSpec = checkList[index++]; + if (checkSpec.project.getSourceFileFromName(checkSpec.fileName, true)) { + _this.syntacticCheck(checkSpec.fileName, checkSpec.project); + _this.immediateId = setImmediate(function () { + _this.semanticCheck(checkSpec.fileName, checkSpec.project); + _this.immediateId = undefined; + if (checkList.length > index) { + _this.errorTimer = setTimeout(checkOne, followMs); + } + else { + _this.errorTimer = undefined; + } + }); + } + } + }; + if ((checkList.length > index) && (matchSeq(seq))) { + this.errorTimer = setTimeout(checkOne, ms); + } + }; + Session.prototype.getDefinition = function (line, col, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var definitions = compilerService.languageService.getDefinitionAtPosition(file, position); + if (!definitions) { + return undefined; + } + return definitions.map(function (def) { return ({ + file: def.fileName, + start: compilerService.host.positionToLineCol(def.fileName, def.textSpan.start), + end: compilerService.host.positionToLineCol(def.fileName, ts.textSpanEnd(def.textSpan)) + }); }); + }; + Session.prototype.getRenameLocations = function (line, col, fileName, findInComments, findInStrings) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var renameInfo = compilerService.languageService.getRenameInfo(file, position); + if (!renameInfo) { + return undefined; + } + if (!renameInfo.canRename) { + return { + info: renameInfo, + locs: [] + }; + } + var renameLocations = compilerService.languageService.findRenameLocations(file, position, findInStrings, findInComments); + if (!renameLocations) { + return undefined; + } + var bakedRenameLocs = renameLocations.map(function (location) { return { + file: location.fileName, + start: compilerService.host.positionToLineCol(location.fileName, location.textSpan.start), + end: compilerService.host.positionToLineCol(location.fileName, ts.textSpanEnd(location.textSpan)) + }; }).sort(function (a, b) { + if (a.file < b.file) { + return -1; + } + else if (a.file > b.file) { + return 1; + } + else { + if (a.start.line < b.start.line) { + return 1; + } + else if (a.start.line > b.start.line) { + return -1; + } + else { + return b.start.col - a.start.col; + } + } + }).reduce(function (accum, cur) { + var curFileAccum; + if (accum.length > 0) { + curFileAccum = accum[accum.length - 1]; + if (curFileAccum.file != cur.file) { + curFileAccum = undefined; + } + } + if (!curFileAccum) { + curFileAccum = { file: cur.file, locs: [] }; + accum.push(curFileAccum); + } + curFileAccum.locs.push({ start: cur.start, end: cur.end }); + return accum; + }, []); + return { info: renameInfo, locs: bakedRenameLocs }; + }; + Session.prototype.getReferences = function (line, col, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var references = compilerService.languageService.getReferencesAtPosition(file, position); + if (!references) { + return undefined; + } + var nameInfo = compilerService.languageService.getQuickInfoAtPosition(file, position); + if (!nameInfo) { + return undefined; + } + var displayString = ts.displayPartsToString(nameInfo.displayParts); + var nameSpan = nameInfo.textSpan; + var nameColStart = compilerService.host.positionToLineCol(file, nameSpan.start).col; + var nameText = compilerService.host.getScriptSnapshot(file).getText(nameSpan.start, ts.textSpanEnd(nameSpan)); + var bakedRefs = references.map(function (ref) { + var start = compilerService.host.positionToLineCol(ref.fileName, ref.textSpan.start); + var refLineSpan = compilerService.host.lineToTextSpan(ref.fileName, start.line - 1); + var snap = compilerService.host.getScriptSnapshot(ref.fileName); + var lineText = snap.getText(refLineSpan.start, ts.textSpanEnd(refLineSpan)).replace(/\r|\n/g, ""); + return { + file: ref.fileName, + start: start, + lineText: lineText, + end: compilerService.host.positionToLineCol(ref.fileName, ts.textSpanEnd(ref.textSpan)), + isWriteAccess: ref.isWriteAccess + }; + }).sort(compareFileStart); + return { + refs: bakedRefs, + symbolName: nameText, + symbolStartCol: nameColStart, + symbolDisplayString: displayString + }; + }; + Session.prototype.openClientFile = function (fileName) { + var file = ts.normalizePath(fileName); + this.projectService.openClientFile(file); + }; + Session.prototype.getQuickInfo = function (line, col, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var quickInfo = compilerService.languageService.getQuickInfoAtPosition(file, position); + if (!quickInfo) { + return undefined; + } + var displayString = ts.displayPartsToString(quickInfo.displayParts); + var docString = ts.displayPartsToString(quickInfo.documentation); + return { + kind: quickInfo.kind, + kindModifiers: quickInfo.kindModifiers, + start: compilerService.host.positionToLineCol(file, quickInfo.textSpan.start), + end: compilerService.host.positionToLineCol(file, ts.textSpanEnd(quickInfo.textSpan)), + displayString: displayString, + documentation: docString + }; + }; + Session.prototype.getFormattingEditsForRange = function (line, col, endLine, endCol, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var startPosition = compilerService.host.lineColToPosition(file, line, col); + var endPosition = compilerService.host.lineColToPosition(file, endLine, endCol); + var edits = compilerService.languageService.getFormattingEditsForRange(file, startPosition, endPosition, compilerService.formatCodeOptions); + if (!edits) { + return undefined; + } + return edits.map(function (edit) { + return { + start: compilerService.host.positionToLineCol(file, edit.span.start), + end: compilerService.host.positionToLineCol(file, ts.textSpanEnd(edit.span)), + newText: edit.newText ? edit.newText : "" + }; + }); + }; + Session.prototype.getFormattingEditsAfterKeystroke = function (line, col, key, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var edits = compilerService.languageService.getFormattingEditsAfterKeystroke(file, position, key, compilerService.formatCodeOptions); + if ((key == "\n") && ((!edits) || (edits.length == 0) || allEditsBeforePos(edits, position))) { + var editorOptions = { + IndentSize: 4, + TabSize: 4, + NewLineCharacter: "\n", + ConvertTabsToSpaces: true + }; + var indentPosition = compilerService.languageService.getIndentationAtPosition(file, position, editorOptions); + var spaces = generateSpaces(indentPosition); + if (indentPosition > 0) { + edits.push({ span: ts.createTextSpanFromBounds(position, position), newText: spaces }); + } + } + if (!edits) { + return undefined; + } + return edits.map(function (edit) { + return { + start: compilerService.host.positionToLineCol(file, edit.span.start), + end: compilerService.host.positionToLineCol(file, ts.textSpanEnd(edit.span)), + newText: edit.newText ? edit.newText : "" + }; + }); + }; + Session.prototype.getCompletions = function (line, col, prefix, fileName) { + if (!prefix) { + prefix = ""; + } + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var completions = compilerService.languageService.getCompletionsAtPosition(file, position); + if (!completions) { + return undefined; + } + return completions.entries.reduce(function (result, entry) { + if (completions.isMemberCompletion || entry.name.indexOf(prefix) == 0) { + result.push(entry); + } + return result; + }, []); + }; + Session.prototype.getCompletionEntryDetails = function (line, col, entryNames, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + return entryNames.reduce(function (accum, entryName) { + var details = compilerService.languageService.getCompletionEntryDetails(file, position, entryName); + if (details) { + accum.push(details); + } + return accum; + }, []); + }; + Session.prototype.getDiagnostics = function (delay, fileNames) { + var _this = this; + var checkList = fileNames.reduce(function (accum, fileName) { + fileName = ts.normalizePath(fileName); + var project = _this.projectService.getProjectForFile(fileName); + if (project) { + accum.push({ fileName: fileName, project: project }); + } + return accum; + }, []); + if (checkList.length > 0) { + this.updateErrorCheck(checkList, this.changeSeq, function (n) { return n == _this.changeSeq; }, delay); + } + }; + Session.prototype.change = function (line, col, endLine, endCol, insertString, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (project) { + var compilerService = project.compilerService; + var start = compilerService.host.lineColToPosition(file, line, col); + var end = compilerService.host.lineColToPosition(file, endLine, endCol); + if (start >= 0) { + compilerService.host.editScript(file, start, end, insertString); + this.changeSeq++; + } + } + }; + Session.prototype.reload = function (fileName, tempFileName, reqSeq) { + var _this = this; + if (reqSeq === void 0) { reqSeq = 0; } + var file = ts.normalizePath(fileName); + var tmpfile = ts.normalizePath(tempFileName); + var project = this.projectService.getProjectForFile(file); + if (project) { + this.changeSeq++; + project.compilerService.host.reloadScript(file, tmpfile, function () { + _this.output(undefined, CommandNames.Reload, reqSeq); + }); + } + }; + Session.prototype.saveToTmp = function (fileName, tempFileName) { + var file = ts.normalizePath(fileName); + var tmpfile = ts.normalizePath(tempFileName); + var project = this.projectService.getProjectForFile(file); + if (project) { + project.compilerService.host.saveTo(file, tmpfile); + } + }; + Session.prototype.closeClientFile = function (fileName) { + var file = ts.normalizePath(fileName); + this.projectService.closeClientFile(file); + }; + Session.prototype.decorateNavigationBarItem = function (project, fileName, items) { + var _this = this; + if (!items) { + return undefined; + } + var compilerService = project.compilerService; + return items.map(function (item) { return ({ + text: item.text, + kind: item.kind, + kindModifiers: item.kindModifiers, + spans: item.spans.map(function (span) { return ({ + start: compilerService.host.positionToLineCol(fileName, span.start), + end: compilerService.host.positionToLineCol(fileName, ts.textSpanEnd(span)) + }); }), + childItems: _this.decorateNavigationBarItem(project, fileName, item.childItems) + }); }); + }; + Session.prototype.getNavigationBarItems = function (fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var items = compilerService.languageService.getNavigationBarItems(file); + if (!items) { + return undefined; + } + return this.decorateNavigationBarItem(project, fileName, items); + }; + Session.prototype.getNavigateToItems = function (searchValue, fileName, maxResultCount) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var navItems = compilerService.languageService.getNavigateToItems(searchValue, maxResultCount); + if (!navItems) { + return undefined; + } + return navItems.map(function (navItem) { + var start = compilerService.host.positionToLineCol(navItem.fileName, navItem.textSpan.start); + var end = compilerService.host.positionToLineCol(navItem.fileName, ts.textSpanEnd(navItem.textSpan)); + var bakedItem = { + name: navItem.name, + kind: navItem.kind, + file: navItem.fileName, + start: start, + end: end + }; + if (navItem.kindModifiers && (navItem.kindModifiers != "")) { + bakedItem.kindModifiers = navItem.kindModifiers; + } + if (navItem.matchKind != 'none') { + bakedItem.matchKind = navItem.matchKind; + } + if (navItem.containerName && (navItem.containerName.length > 0)) { + bakedItem.containerName = navItem.containerName; + } + if (navItem.containerKind && (navItem.containerKind.length > 0)) { + bakedItem.containerKind = navItem.containerKind; + } + return bakedItem; + }); + }; + Session.prototype.getBraceMatching = function (line, col, fileName) { + var file = ts.normalizePath(fileName); + var project = this.projectService.getProjectForFile(file); + if (!project) { + throw Errors.NoProject; + } + var compilerService = project.compilerService; + var position = compilerService.host.lineColToPosition(file, line, col); + var spans = compilerService.languageService.getBraceMatchingAtPosition(file, position); + if (!spans) { + return undefined; + } + return spans.map(function (span) { return ({ + start: compilerService.host.positionToLineCol(file, span.start), + end: compilerService.host.positionToLineCol(file, span.start + span.length) + }); }); + }; + Session.prototype.onMessage = function (message) { + try { + var request = JSON.parse(message); + var response; + var errorMessage; + var responseRequired = true; + switch (request.command) { + case CommandNames.Definition: { + var defArgs = request.arguments; + response = this.getDefinition(defArgs.line, defArgs.col, defArgs.file); + break; + } + case CommandNames.References: { + var refArgs = request.arguments; + response = this.getReferences(refArgs.line, refArgs.col, refArgs.file); + break; + } + case CommandNames.Rename: { + var renameArgs = request.arguments; + response = this.getRenameLocations(renameArgs.line, renameArgs.col, renameArgs.file, renameArgs.findInComments, renameArgs.findInStrings); + break; + } + case CommandNames.Open: { + var openArgs = request.arguments; + this.openClientFile(openArgs.file); + responseRequired = false; + break; + } + case CommandNames.Quickinfo: { + var quickinfoArgs = request.arguments; + response = this.getQuickInfo(quickinfoArgs.line, quickinfoArgs.col, quickinfoArgs.file); + break; + } + case CommandNames.Format: { + var formatArgs = request.arguments; + response = this.getFormattingEditsForRange(formatArgs.line, formatArgs.col, formatArgs.endLine, formatArgs.endCol, formatArgs.file); + break; + } + case CommandNames.Formatonkey: { + var formatOnKeyArgs = request.arguments; + response = this.getFormattingEditsAfterKeystroke(formatOnKeyArgs.line, formatOnKeyArgs.col, formatOnKeyArgs.key, formatOnKeyArgs.file); + break; + } + case CommandNames.Completions: { + var completionsArgs = request.arguments; + response = this.getCompletions(request.arguments.line, request.arguments.col, completionsArgs.prefix, request.arguments.file); + break; + } + case CommandNames.CompletionDetails: { + var completionDetailsArgs = request.arguments; + response = this.getCompletionEntryDetails(request.arguments.line, request.arguments.col, completionDetailsArgs.entryNames, request.arguments.file); + break; + } + case CommandNames.Geterr: { + var geterrArgs = request.arguments; + response = this.getDiagnostics(geterrArgs.delay, geterrArgs.files); + responseRequired = false; + break; + } + case CommandNames.Change: { + var changeArgs = request.arguments; + this.change(changeArgs.line, changeArgs.col, changeArgs.endLine, changeArgs.endCol, changeArgs.insertString, changeArgs.file); + responseRequired = false; + break; + } + case CommandNames.Reload: { + var reloadArgs = request.arguments; + this.reload(reloadArgs.file, reloadArgs.tmpfile, request.seq); + break; + } + case CommandNames.Saveto: { + var savetoArgs = request.arguments; + this.saveToTmp(savetoArgs.file, savetoArgs.tmpfile); + responseRequired = false; + break; + } + case CommandNames.Close: { + var closeArgs = request.arguments; + this.closeClientFile(closeArgs.file); + responseRequired = false; + break; + } + case CommandNames.Navto: { + var navtoArgs = request.arguments; + response = this.getNavigateToItems(navtoArgs.searchValue, navtoArgs.file, navtoArgs.maxResultCount); + break; + } + case CommandNames.Brace: { + var braceArguments = request.arguments; + response = this.getBraceMatching(braceArguments.line, braceArguments.col, braceArguments.file); + break; + } + case CommandNames.NavBar: { + var navBarArgs = request.arguments; + response = this.getNavigationBarItems(navBarArgs.file); + break; + } + default: { + this.projectService.log("Unrecognized JSON command: " + message); + this.output(undefined, CommandNames.Unknown, request.seq, "Unrecognized JSON command: " + request.command); + break; + } + } + if (response) { + this.output(response, request.command, request.seq); + } + else if (responseRequired) { + this.output(undefined, request.command, request.seq, "No content available."); + } + } + catch (err) { + if (err instanceof ts.OperationCanceledException) { + } + this.logError(err, message); + this.output(undefined, request ? request.command : CommandNames.Unknown, request ? request.seq : 0, "Error processing request. " + err.message); + } + }; + return Session; + })(); + server.Session = Session; + })(server = ts.server || (ts.server = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var server; + (function (server) { + var nodeproto = require('_debugger'); + var readline = require('readline'); + var path = require('path'); + var fs = require('fs'); + var rl = readline.createInterface({ + input: process.stdin, + output: process.stdout, + terminal: false + }); + var Logger = (function () { + function Logger(logFilename) { + this.logFilename = logFilename; + this.fd = -1; + this.seq = 0; + this.inGroup = false; + this.firstInGroup = true; + } + Logger.padStringRight = function (str, padding) { + return (str + padding).slice(0, padding.length); + }; + Logger.prototype.close = function () { + if (this.fd >= 0) { + fs.close(this.fd); + } + }; + Logger.prototype.perftrc = function (s) { + this.msg(s, "Perf"); + }; + Logger.prototype.info = function (s) { + this.msg(s, "Info"); + }; + Logger.prototype.startGroup = function () { + this.inGroup = true; + this.firstInGroup = true; + }; + Logger.prototype.endGroup = function () { + this.inGroup = false; + this.seq++; + this.firstInGroup = true; + }; + Logger.prototype.msg = function (s, type) { + if (type === void 0) { type = "Err"; } + if (this.fd < 0) { + this.fd = fs.openSync(this.logFilename, "w"); + } + if (this.fd >= 0) { + s = s + "\n"; + var prefix = Logger.padStringRight(type + " " + this.seq.toString(), " "); + if (this.firstInGroup) { + s = prefix + s; + this.firstInGroup = false; + } + if (!this.inGroup) { + this.seq++; + this.firstInGroup = true; + } + var buf = new Buffer(s); + fs.writeSync(this.fd, buf, 0, buf.length, null); + } + }; + return Logger; + })(); + var WatchedFileSet = (function () { + function WatchedFileSet(interval, chunkSize) { + if (interval === void 0) { interval = 2500; } + if (chunkSize === void 0) { chunkSize = 30; } + this.interval = interval; + this.chunkSize = chunkSize; + this.watchedFiles = []; + this.nextFileToCheck = 0; + } + WatchedFileSet.copyListRemovingItem = function (item, list) { + var copiedList = []; + for (var i = 0, len = list.length; i < len; i++) { + if (list[i] != item) { + copiedList.push(list[i]); + } + } + return copiedList; + }; + WatchedFileSet.getModifiedTime = function (fileName) { + return fs.statSync(fileName).mtime; + }; + WatchedFileSet.prototype.poll = function (checkedIndex) { + var watchedFile = this.watchedFiles[checkedIndex]; + if (!watchedFile) { + return; + } + fs.stat(watchedFile.fileName, function (err, stats) { + if (err) { + watchedFile.callback(watchedFile.fileName); + } + else if (watchedFile.mtime.getTime() != stats.mtime.getTime()) { + watchedFile.mtime = WatchedFileSet.getModifiedTime(watchedFile.fileName); + watchedFile.callback(watchedFile.fileName); + } + }); + }; + WatchedFileSet.prototype.startWatchTimer = function () { + var _this = this; + this.watchTimer = setInterval(function () { + var count = 0; + var nextToCheck = _this.nextFileToCheck; + var firstCheck = -1; + while ((count < _this.chunkSize) && (nextToCheck != firstCheck)) { + _this.poll(nextToCheck); + if (firstCheck < 0) { + firstCheck = nextToCheck; + } + nextToCheck++; + if (nextToCheck === _this.watchedFiles.length) { + nextToCheck = 0; + } + count++; + } + _this.nextFileToCheck = nextToCheck; + }, this.interval); + }; + WatchedFileSet.prototype.addFile = function (fileName, callback) { + var file = { + fileName: fileName, + callback: callback, + mtime: WatchedFileSet.getModifiedTime(fileName) + }; + this.watchedFiles.push(file); + if (this.watchedFiles.length === 1) { + this.startWatchTimer(); + } + return file; + }; + WatchedFileSet.prototype.removeFile = function (file) { + this.watchedFiles = WatchedFileSet.copyListRemovingItem(file, this.watchedFiles); + }; + return WatchedFileSet; + })(); + var IOSession = (function (_super) { + __extends(IOSession, _super); + function IOSession(host, logger) { + _super.call(this, host, logger); + } + IOSession.prototype.listen = function () { + var _this = this; + rl.on('line', function (input) { + var message = input.trim(); + _this.onMessage(message); + }); + rl.on('close', function () { + _this.projectService.closeLog(); + _this.projectService.log("Exiting..."); + process.exit(0); + }); + }; + return IOSession; + })(server.Session); + var logger = new Logger(__dirname + "/.log" + process.pid.toString()); + var watchedFileSet = new WatchedFileSet(); + ts.sys.watchFile = function (fileName, callback) { + var watchedFile = watchedFileSet.addFile(fileName, callback); + return { + close: function () { return watchedFileSet.removeFile(watchedFile); } + }; + }; + new IOSession(ts.sys, logger).listen(); + })(server = ts.server || (ts.server = {})); +})(ts || (ts = {})); diff --git a/bin/typescript.d.ts b/bin/typescript.d.ts index b0cc19c87d3..8da331c74e1 100644 --- a/bin/typescript.d.ts +++ b/bin/typescript.d.ts @@ -123,132 +123,142 @@ declare module "typescript" { VoidKeyword = 98, WhileKeyword = 99, WithKeyword = 100, - ImplementsKeyword = 101, - InterfaceKeyword = 102, - LetKeyword = 103, - PackageKeyword = 104, - PrivateKeyword = 105, - ProtectedKeyword = 106, - PublicKeyword = 107, - StaticKeyword = 108, - YieldKeyword = 109, - AnyKeyword = 110, - BooleanKeyword = 111, - ConstructorKeyword = 112, - DeclareKeyword = 113, - GetKeyword = 114, - ModuleKeyword = 115, - RequireKeyword = 116, - NumberKeyword = 117, - SetKeyword = 118, - StringKeyword = 119, - SymbolKeyword = 120, - TypeKeyword = 121, - OfKeyword = 122, - QualifiedName = 123, - ComputedPropertyName = 124, - TypeParameter = 125, - Parameter = 126, - PropertySignature = 127, - PropertyDeclaration = 128, - MethodSignature = 129, - MethodDeclaration = 130, - Constructor = 131, - GetAccessor = 132, - SetAccessor = 133, - CallSignature = 134, - ConstructSignature = 135, - IndexSignature = 136, - TypeReference = 137, - FunctionType = 138, - ConstructorType = 139, - TypeQuery = 140, - TypeLiteral = 141, - ArrayType = 142, - TupleType = 143, - UnionType = 144, - ParenthesizedType = 145, - ObjectBindingPattern = 146, - ArrayBindingPattern = 147, - BindingElement = 148, - ArrayLiteralExpression = 149, - ObjectLiteralExpression = 150, - PropertyAccessExpression = 151, - ElementAccessExpression = 152, - CallExpression = 153, - NewExpression = 154, - TaggedTemplateExpression = 155, - TypeAssertionExpression = 156, - ParenthesizedExpression = 157, - FunctionExpression = 158, - ArrowFunction = 159, - DeleteExpression = 160, - TypeOfExpression = 161, - VoidExpression = 162, - PrefixUnaryExpression = 163, - PostfixUnaryExpression = 164, - BinaryExpression = 165, - ConditionalExpression = 166, - TemplateExpression = 167, - YieldExpression = 168, - SpreadElementExpression = 169, - OmittedExpression = 170, - TemplateSpan = 171, - Block = 172, - VariableStatement = 173, - EmptyStatement = 174, - ExpressionStatement = 175, - IfStatement = 176, - DoStatement = 177, - WhileStatement = 178, - ForStatement = 179, - ForInStatement = 180, - ForOfStatement = 181, - ContinueStatement = 182, - BreakStatement = 183, - ReturnStatement = 184, - WithStatement = 185, - SwitchStatement = 186, - LabeledStatement = 187, - ThrowStatement = 188, - TryStatement = 189, - DebuggerStatement = 190, - VariableDeclaration = 191, - VariableDeclarationList = 192, - FunctionDeclaration = 193, - ClassDeclaration = 194, - InterfaceDeclaration = 195, - TypeAliasDeclaration = 196, - EnumDeclaration = 197, - ModuleDeclaration = 198, - ModuleBlock = 199, - ImportDeclaration = 200, - ExportAssignment = 201, - ExternalModuleReference = 202, - CaseClause = 203, - DefaultClause = 204, - HeritageClause = 205, - CatchClause = 206, - PropertyAssignment = 207, - ShorthandPropertyAssignment = 208, - EnumMember = 209, - SourceFile = 210, - SyntaxList = 211, - Count = 212, + AsKeyword = 101, + FromKeyword = 102, + ImplementsKeyword = 103, + InterfaceKeyword = 104, + LetKeyword = 105, + PackageKeyword = 106, + PrivateKeyword = 107, + ProtectedKeyword = 108, + PublicKeyword = 109, + StaticKeyword = 110, + YieldKeyword = 111, + AnyKeyword = 112, + BooleanKeyword = 113, + ConstructorKeyword = 114, + DeclareKeyword = 115, + GetKeyword = 116, + ModuleKeyword = 117, + RequireKeyword = 118, + NumberKeyword = 119, + SetKeyword = 120, + StringKeyword = 121, + SymbolKeyword = 122, + TypeKeyword = 123, + OfKeyword = 124, + QualifiedName = 125, + ComputedPropertyName = 126, + TypeParameter = 127, + Parameter = 128, + PropertySignature = 129, + PropertyDeclaration = 130, + MethodSignature = 131, + MethodDeclaration = 132, + Constructor = 133, + GetAccessor = 134, + SetAccessor = 135, + CallSignature = 136, + ConstructSignature = 137, + IndexSignature = 138, + TypeReference = 139, + FunctionType = 140, + ConstructorType = 141, + TypeQuery = 142, + TypeLiteral = 143, + ArrayType = 144, + TupleType = 145, + UnionType = 146, + ParenthesizedType = 147, + ObjectBindingPattern = 148, + ArrayBindingPattern = 149, + BindingElement = 150, + ArrayLiteralExpression = 151, + ObjectLiteralExpression = 152, + PropertyAccessExpression = 153, + ElementAccessExpression = 154, + CallExpression = 155, + NewExpression = 156, + TaggedTemplateExpression = 157, + TypeAssertionExpression = 158, + ParenthesizedExpression = 159, + FunctionExpression = 160, + ArrowFunction = 161, + DeleteExpression = 162, + TypeOfExpression = 163, + VoidExpression = 164, + PrefixUnaryExpression = 165, + PostfixUnaryExpression = 166, + BinaryExpression = 167, + ConditionalExpression = 168, + TemplateExpression = 169, + YieldExpression = 170, + SpreadElementExpression = 171, + OmittedExpression = 172, + TemplateSpan = 173, + Block = 174, + VariableStatement = 175, + EmptyStatement = 176, + ExpressionStatement = 177, + IfStatement = 178, + DoStatement = 179, + WhileStatement = 180, + ForStatement = 181, + ForInStatement = 182, + ForOfStatement = 183, + ContinueStatement = 184, + BreakStatement = 185, + ReturnStatement = 186, + WithStatement = 187, + SwitchStatement = 188, + LabeledStatement = 189, + ThrowStatement = 190, + TryStatement = 191, + DebuggerStatement = 192, + VariableDeclaration = 193, + VariableDeclarationList = 194, + FunctionDeclaration = 195, + ClassDeclaration = 196, + InterfaceDeclaration = 197, + TypeAliasDeclaration = 198, + EnumDeclaration = 199, + ModuleDeclaration = 200, + ModuleBlock = 201, + ImportEqualsDeclaration = 202, + ImportDeclaration = 203, + ImportClause = 204, + NamespaceImport = 205, + NamedImports = 206, + ImportSpecifier = 207, + ExportAssignment = 208, + ExportDeclaration = 209, + NamedExports = 210, + ExportSpecifier = 211, + ExternalModuleReference = 212, + CaseClause = 213, + DefaultClause = 214, + HeritageClause = 215, + CatchClause = 216, + PropertyAssignment = 217, + ShorthandPropertyAssignment = 218, + EnumMember = 219, + SourceFile = 220, + SyntaxList = 221, + Count = 222, FirstAssignment = 52, LastAssignment = 63, FirstReservedWord = 65, LastReservedWord = 100, FirstKeyword = 65, - LastKeyword = 122, - FirstFutureReservedWord = 101, - LastFutureReservedWord = 109, - FirstTypeNode = 137, - LastTypeNode = 145, + LastKeyword = 124, + FirstFutureReservedWord = 103, + LastFutureReservedWord = 111, + FirstTypeNode = 139, + LastTypeNode = 147, FirstPunctuation = 14, LastPunctuation = 63, FirstToken = 0, - LastToken = 122, + LastToken = 124, FirstTriviaToken = 2, LastTriviaToken = 6, FirstLiteralToken = 7, @@ -257,7 +267,7 @@ declare module "typescript" { LastTemplateToken = 13, FirstBinaryOperator = 24, LastBinaryOperator = 63, - FirstNode = 123, + FirstNode = 125, } const enum NodeFlags { Export = 1, @@ -295,13 +305,13 @@ declare module "typescript" { kind: SyntaxKind; flags: NodeFlags; parserContextFlags?: ParserContextFlags; + modifiers?: ModifiersArray; id?: number; parent?: Node; symbol?: Symbol; locals?: SymbolTable; nextContainer?: Node; localSymbol?: Symbol; - modifiers?: ModifiersArray; } interface NodeArray extends Array, TextRange { hasTrailingComma?: boolean; @@ -665,20 +675,49 @@ declare module "typescript" { name: Identifier; members: NodeArray; } - interface ModuleDeclaration extends Declaration, ModuleElement { + interface ExportContainer { + exportStars?: ExportDeclaration[]; + } + interface ModuleDeclaration extends Declaration, ModuleElement, ExportContainer { name: Identifier | LiteralExpression; body: ModuleBlock | ModuleDeclaration; } interface ModuleBlock extends Node, ModuleElement { statements: NodeArray; } - interface ImportDeclaration extends Declaration, ModuleElement { + interface ImportEqualsDeclaration extends Declaration, ModuleElement { name: Identifier; moduleReference: EntityName | ExternalModuleReference; } interface ExternalModuleReference extends Node { expression?: Expression; } + interface ImportDeclaration extends Statement, ModuleElement { + importClause?: ImportClause; + moduleSpecifier: Expression; + } + interface ImportClause extends Declaration { + name?: Identifier; + namedBindings?: NamespaceImport | NamedImports; + } + interface NamespaceImport extends Declaration { + name: Identifier; + } + interface ExportDeclaration extends Statement, ModuleElement { + exportClause?: NamedExports; + moduleSpecifier?: Expression; + } + interface NamedImportsOrExports extends Node { + elements: NodeArray; + } + type NamedImports = NamedImportsOrExports; + type NamedExports = NamedImportsOrExports; + interface ImportOrExportSpecifier extends Declaration { + propertyName?: Identifier; + name: Identifier; + } + type ImportSpecifier = ImportOrExportSpecifier; + type ExportSpecifier = ImportOrExportSpecifier; interface ExportAssignment extends Statement, ModuleElement { exportName: Identifier; } @@ -688,7 +727,7 @@ declare module "typescript" { interface CommentRange extends TextRange { hasTrailingNewLine?: boolean; } - interface SourceFile extends Declaration { + interface SourceFile extends Declaration, ExportContainer { statements: NodeArray; endOfFileToken: Node; fileName: string; @@ -842,7 +881,7 @@ declare module "typescript" { } interface SymbolVisibilityResult { accessibility: SymbolAccessibility; - aliasesToMakeVisible?: ImportDeclaration[]; + aliasesToMakeVisible?: ImportEqualsDeclaration[]; errorSymbolName?: string; errorNode?: Node; } @@ -850,11 +889,11 @@ declare module "typescript" { errorModuleName?: string; } interface EmitResolver { - getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string; - getExpressionNamePrefix(node: Identifier): string; + getGeneratedNameForNode(node: ModuleDeclaration | EnumDeclaration | ImportDeclaration | ExportDeclaration): string; + getExpressionNameSubstitution(node: Identifier): string; getExportAssignmentName(node: SourceFile): string; - isReferencedImportDeclaration(node: ImportDeclaration): boolean; - isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; + isReferencedImportDeclaration(node: Node): boolean; + isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean; getNodeCheckFlags(node: Node): NodeCheckFlags; isDeclarationVisible(node: Declaration): boolean; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; @@ -949,8 +988,10 @@ declare module "typescript" { declaredType?: Type; mapper?: TypeMapper; referenced?: boolean; - exportAssignSymbol?: Symbol; + exportAssignmentChecked?: boolean; + exportAssignmentSymbol?: Symbol; unionType?: UnionType; + resolvedExports?: SymbolTable; } interface TransientSymbol extends Symbol, SymbolLinks { } @@ -975,7 +1016,8 @@ declare module "typescript" { enumMemberValue?: number; isIllegalTypeReferenceInConstraint?: boolean; isVisible?: boolean; - localModuleName?: string; + generatedName?: string; + generatedNames?: Map; assignmentChecks?: Map; hasReportedStatementInAmbientContext?: boolean; importOnRightSide?: Symbol; @@ -1560,6 +1602,7 @@ declare module "typescript" { kind: string; kindModifiers: string; matchKind: string; + isCaseSensitive: boolean; fileName: string; textSpan: TextSpan; containerName: string; diff --git a/bin/typescript.js b/bin/typescript.js index 1d2c9f37ac8..4ee694a8f19 100644 --- a/bin/typescript.js +++ b/bin/typescript.js @@ -117,132 +117,142 @@ var ts; SyntaxKind[SyntaxKind["VoidKeyword"] = 98] = "VoidKeyword"; SyntaxKind[SyntaxKind["WhileKeyword"] = 99] = "WhileKeyword"; SyntaxKind[SyntaxKind["WithKeyword"] = 100] = "WithKeyword"; - SyntaxKind[SyntaxKind["ImplementsKeyword"] = 101] = "ImplementsKeyword"; - SyntaxKind[SyntaxKind["InterfaceKeyword"] = 102] = "InterfaceKeyword"; - SyntaxKind[SyntaxKind["LetKeyword"] = 103] = "LetKeyword"; - SyntaxKind[SyntaxKind["PackageKeyword"] = 104] = "PackageKeyword"; - SyntaxKind[SyntaxKind["PrivateKeyword"] = 105] = "PrivateKeyword"; - SyntaxKind[SyntaxKind["ProtectedKeyword"] = 106] = "ProtectedKeyword"; - SyntaxKind[SyntaxKind["PublicKeyword"] = 107] = "PublicKeyword"; - SyntaxKind[SyntaxKind["StaticKeyword"] = 108] = "StaticKeyword"; - SyntaxKind[SyntaxKind["YieldKeyword"] = 109] = "YieldKeyword"; - SyntaxKind[SyntaxKind["AnyKeyword"] = 110] = "AnyKeyword"; - SyntaxKind[SyntaxKind["BooleanKeyword"] = 111] = "BooleanKeyword"; - SyntaxKind[SyntaxKind["ConstructorKeyword"] = 112] = "ConstructorKeyword"; - SyntaxKind[SyntaxKind["DeclareKeyword"] = 113] = "DeclareKeyword"; - SyntaxKind[SyntaxKind["GetKeyword"] = 114] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 115] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 116] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 117] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 118] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 119] = "StringKeyword"; - SyntaxKind[SyntaxKind["SymbolKeyword"] = 120] = "SymbolKeyword"; - SyntaxKind[SyntaxKind["TypeKeyword"] = 121] = "TypeKeyword"; - SyntaxKind[SyntaxKind["OfKeyword"] = 122] = "OfKeyword"; - SyntaxKind[SyntaxKind["QualifiedName"] = 123] = "QualifiedName"; - SyntaxKind[SyntaxKind["ComputedPropertyName"] = 124] = "ComputedPropertyName"; - SyntaxKind[SyntaxKind["TypeParameter"] = 125] = "TypeParameter"; - SyntaxKind[SyntaxKind["Parameter"] = 126] = "Parameter"; - SyntaxKind[SyntaxKind["PropertySignature"] = 127] = "PropertySignature"; - SyntaxKind[SyntaxKind["PropertyDeclaration"] = 128] = "PropertyDeclaration"; - SyntaxKind[SyntaxKind["MethodSignature"] = 129] = "MethodSignature"; - SyntaxKind[SyntaxKind["MethodDeclaration"] = 130] = "MethodDeclaration"; - SyntaxKind[SyntaxKind["Constructor"] = 131] = "Constructor"; - SyntaxKind[SyntaxKind["GetAccessor"] = 132] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 133] = "SetAccessor"; - SyntaxKind[SyntaxKind["CallSignature"] = 134] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 135] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 136] = "IndexSignature"; - SyntaxKind[SyntaxKind["TypeReference"] = 137] = "TypeReference"; - SyntaxKind[SyntaxKind["FunctionType"] = 138] = "FunctionType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 139] = "ConstructorType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 140] = "TypeQuery"; - SyntaxKind[SyntaxKind["TypeLiteral"] = 141] = "TypeLiteral"; - SyntaxKind[SyntaxKind["ArrayType"] = 142] = "ArrayType"; - SyntaxKind[SyntaxKind["TupleType"] = 143] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 144] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 145] = "ParenthesizedType"; - SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 146] = "ObjectBindingPattern"; - SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 147] = "ArrayBindingPattern"; - SyntaxKind[SyntaxKind["BindingElement"] = 148] = "BindingElement"; - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 149] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 150] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 151] = "PropertyAccessExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 152] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["CallExpression"] = 153] = "CallExpression"; - SyntaxKind[SyntaxKind["NewExpression"] = 154] = "NewExpression"; - SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 155] = "TaggedTemplateExpression"; - SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 156] = "TypeAssertionExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 157] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 158] = "FunctionExpression"; - SyntaxKind[SyntaxKind["ArrowFunction"] = 159] = "ArrowFunction"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 160] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 161] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 162] = "VoidExpression"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 163] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 164] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 165] = "BinaryExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 166] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["TemplateExpression"] = 167] = "TemplateExpression"; - SyntaxKind[SyntaxKind["YieldExpression"] = 168] = "YieldExpression"; - SyntaxKind[SyntaxKind["SpreadElementExpression"] = 169] = "SpreadElementExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 170] = "OmittedExpression"; - SyntaxKind[SyntaxKind["TemplateSpan"] = 171] = "TemplateSpan"; - SyntaxKind[SyntaxKind["Block"] = 172] = "Block"; - SyntaxKind[SyntaxKind["VariableStatement"] = 173] = "VariableStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 174] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 175] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["IfStatement"] = 176] = "IfStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 177] = "DoStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 178] = "WhileStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 179] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 180] = "ForInStatement"; - SyntaxKind[SyntaxKind["ForOfStatement"] = 181] = "ForOfStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 182] = "ContinueStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 183] = "BreakStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 184] = "ReturnStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 185] = "WithStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 186] = "SwitchStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 187] = "LabeledStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 188] = "ThrowStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 189] = "TryStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 190] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 191] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarationList"] = 192] = "VariableDeclarationList"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 193] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 194] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 195] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 196] = "TypeAliasDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 197] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 198] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ModuleBlock"] = 199] = "ModuleBlock"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 200] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 201] = "ExportAssignment"; - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 202] = "ExternalModuleReference"; - SyntaxKind[SyntaxKind["CaseClause"] = 203] = "CaseClause"; - SyntaxKind[SyntaxKind["DefaultClause"] = 204] = "DefaultClause"; - SyntaxKind[SyntaxKind["HeritageClause"] = 205] = "HeritageClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 206] = "CatchClause"; - SyntaxKind[SyntaxKind["PropertyAssignment"] = 207] = "PropertyAssignment"; - SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 208] = "ShorthandPropertyAssignment"; - SyntaxKind[SyntaxKind["EnumMember"] = 209] = "EnumMember"; - SyntaxKind[SyntaxKind["SourceFile"] = 210] = "SourceFile"; - SyntaxKind[SyntaxKind["SyntaxList"] = 211] = "SyntaxList"; - SyntaxKind[SyntaxKind["Count"] = 212] = "Count"; + SyntaxKind[SyntaxKind["AsKeyword"] = 101] = "AsKeyword"; + SyntaxKind[SyntaxKind["FromKeyword"] = 102] = "FromKeyword"; + SyntaxKind[SyntaxKind["ImplementsKeyword"] = 103] = "ImplementsKeyword"; + SyntaxKind[SyntaxKind["InterfaceKeyword"] = 104] = "InterfaceKeyword"; + SyntaxKind[SyntaxKind["LetKeyword"] = 105] = "LetKeyword"; + SyntaxKind[SyntaxKind["PackageKeyword"] = 106] = "PackageKeyword"; + SyntaxKind[SyntaxKind["PrivateKeyword"] = 107] = "PrivateKeyword"; + SyntaxKind[SyntaxKind["ProtectedKeyword"] = 108] = "ProtectedKeyword"; + SyntaxKind[SyntaxKind["PublicKeyword"] = 109] = "PublicKeyword"; + SyntaxKind[SyntaxKind["StaticKeyword"] = 110] = "StaticKeyword"; + SyntaxKind[SyntaxKind["YieldKeyword"] = 111] = "YieldKeyword"; + SyntaxKind[SyntaxKind["AnyKeyword"] = 112] = "AnyKeyword"; + SyntaxKind[SyntaxKind["BooleanKeyword"] = 113] = "BooleanKeyword"; + SyntaxKind[SyntaxKind["ConstructorKeyword"] = 114] = "ConstructorKeyword"; + SyntaxKind[SyntaxKind["DeclareKeyword"] = 115] = "DeclareKeyword"; + SyntaxKind[SyntaxKind["GetKeyword"] = 116] = "GetKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 117] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 118] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 119] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 120] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 121] = "StringKeyword"; + SyntaxKind[SyntaxKind["SymbolKeyword"] = 122] = "SymbolKeyword"; + SyntaxKind[SyntaxKind["TypeKeyword"] = 123] = "TypeKeyword"; + SyntaxKind[SyntaxKind["OfKeyword"] = 124] = "OfKeyword"; + SyntaxKind[SyntaxKind["QualifiedName"] = 125] = "QualifiedName"; + SyntaxKind[SyntaxKind["ComputedPropertyName"] = 126] = "ComputedPropertyName"; + SyntaxKind[SyntaxKind["TypeParameter"] = 127] = "TypeParameter"; + SyntaxKind[SyntaxKind["Parameter"] = 128] = "Parameter"; + SyntaxKind[SyntaxKind["PropertySignature"] = 129] = "PropertySignature"; + SyntaxKind[SyntaxKind["PropertyDeclaration"] = 130] = "PropertyDeclaration"; + SyntaxKind[SyntaxKind["MethodSignature"] = 131] = "MethodSignature"; + SyntaxKind[SyntaxKind["MethodDeclaration"] = 132] = "MethodDeclaration"; + SyntaxKind[SyntaxKind["Constructor"] = 133] = "Constructor"; + SyntaxKind[SyntaxKind["GetAccessor"] = 134] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 135] = "SetAccessor"; + SyntaxKind[SyntaxKind["CallSignature"] = 136] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 137] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 138] = "IndexSignature"; + SyntaxKind[SyntaxKind["TypeReference"] = 139] = "TypeReference"; + SyntaxKind[SyntaxKind["FunctionType"] = 140] = "FunctionType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 141] = "ConstructorType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 142] = "TypeQuery"; + SyntaxKind[SyntaxKind["TypeLiteral"] = 143] = "TypeLiteral"; + SyntaxKind[SyntaxKind["ArrayType"] = 144] = "ArrayType"; + SyntaxKind[SyntaxKind["TupleType"] = 145] = "TupleType"; + SyntaxKind[SyntaxKind["UnionType"] = 146] = "UnionType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 147] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 148] = "ObjectBindingPattern"; + SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 149] = "ArrayBindingPattern"; + SyntaxKind[SyntaxKind["BindingElement"] = 150] = "BindingElement"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 151] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 152] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 153] = "PropertyAccessExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 154] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["CallExpression"] = 155] = "CallExpression"; + SyntaxKind[SyntaxKind["NewExpression"] = 156] = "NewExpression"; + SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 157] = "TaggedTemplateExpression"; + SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 158] = "TypeAssertionExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 159] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 160] = "FunctionExpression"; + SyntaxKind[SyntaxKind["ArrowFunction"] = 161] = "ArrowFunction"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 162] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 163] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 164] = "VoidExpression"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 165] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 166] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 167] = "BinaryExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 168] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 169] = "TemplateExpression"; + SyntaxKind[SyntaxKind["YieldExpression"] = 170] = "YieldExpression"; + SyntaxKind[SyntaxKind["SpreadElementExpression"] = 171] = "SpreadElementExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 172] = "OmittedExpression"; + SyntaxKind[SyntaxKind["TemplateSpan"] = 173] = "TemplateSpan"; + SyntaxKind[SyntaxKind["Block"] = 174] = "Block"; + SyntaxKind[SyntaxKind["VariableStatement"] = 175] = "VariableStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 176] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 177] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["IfStatement"] = 178] = "IfStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 179] = "DoStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 180] = "WhileStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 181] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 182] = "ForInStatement"; + SyntaxKind[SyntaxKind["ForOfStatement"] = 183] = "ForOfStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 184] = "ContinueStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 185] = "BreakStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 186] = "ReturnStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 187] = "WithStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 188] = "SwitchStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 189] = "LabeledStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 190] = "ThrowStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 191] = "TryStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 192] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 193] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarationList"] = 194] = "VariableDeclarationList"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 195] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 196] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 197] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 198] = "TypeAliasDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 199] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 200] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ModuleBlock"] = 201] = "ModuleBlock"; + SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 202] = "ImportEqualsDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 203] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ImportClause"] = 204] = "ImportClause"; + SyntaxKind[SyntaxKind["NamespaceImport"] = 205] = "NamespaceImport"; + SyntaxKind[SyntaxKind["NamedImports"] = 206] = "NamedImports"; + SyntaxKind[SyntaxKind["ImportSpecifier"] = 207] = "ImportSpecifier"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 208] = "ExportAssignment"; + SyntaxKind[SyntaxKind["ExportDeclaration"] = 209] = "ExportDeclaration"; + SyntaxKind[SyntaxKind["NamedExports"] = 210] = "NamedExports"; + SyntaxKind[SyntaxKind["ExportSpecifier"] = 211] = "ExportSpecifier"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 212] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["CaseClause"] = 213] = "CaseClause"; + SyntaxKind[SyntaxKind["DefaultClause"] = 214] = "DefaultClause"; + SyntaxKind[SyntaxKind["HeritageClause"] = 215] = "HeritageClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 216] = "CatchClause"; + SyntaxKind[SyntaxKind["PropertyAssignment"] = 217] = "PropertyAssignment"; + SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 218] = "ShorthandPropertyAssignment"; + SyntaxKind[SyntaxKind["EnumMember"] = 219] = "EnumMember"; + SyntaxKind[SyntaxKind["SourceFile"] = 220] = "SourceFile"; + SyntaxKind[SyntaxKind["SyntaxList"] = 221] = "SyntaxList"; + SyntaxKind[SyntaxKind["Count"] = 222] = "Count"; SyntaxKind[SyntaxKind["FirstAssignment"] = 52] = "FirstAssignment"; SyntaxKind[SyntaxKind["LastAssignment"] = 63] = "LastAssignment"; SyntaxKind[SyntaxKind["FirstReservedWord"] = 65] = "FirstReservedWord"; SyntaxKind[SyntaxKind["LastReservedWord"] = 100] = "LastReservedWord"; SyntaxKind[SyntaxKind["FirstKeyword"] = 65] = "FirstKeyword"; - SyntaxKind[SyntaxKind["LastKeyword"] = 122] = "LastKeyword"; - SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 101] = "FirstFutureReservedWord"; - SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 109] = "LastFutureReservedWord"; - SyntaxKind[SyntaxKind["FirstTypeNode"] = 137] = "FirstTypeNode"; - SyntaxKind[SyntaxKind["LastTypeNode"] = 145] = "LastTypeNode"; + SyntaxKind[SyntaxKind["LastKeyword"] = 124] = "LastKeyword"; + SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 103] = "FirstFutureReservedWord"; + SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 111] = "LastFutureReservedWord"; + SyntaxKind[SyntaxKind["FirstTypeNode"] = 139] = "FirstTypeNode"; + SyntaxKind[SyntaxKind["LastTypeNode"] = 147] = "LastTypeNode"; SyntaxKind[SyntaxKind["FirstPunctuation"] = 14] = "FirstPunctuation"; SyntaxKind[SyntaxKind["LastPunctuation"] = 63] = "LastPunctuation"; SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken"; - SyntaxKind[SyntaxKind["LastToken"] = 122] = "LastToken"; + SyntaxKind[SyntaxKind["LastToken"] = 124] = "LastToken"; SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken"; SyntaxKind[SyntaxKind["LastTriviaToken"] = 6] = "LastTriviaToken"; SyntaxKind[SyntaxKind["FirstLiteralToken"] = 7] = "FirstLiteralToken"; @@ -251,7 +261,7 @@ var ts; SyntaxKind[SyntaxKind["LastTemplateToken"] = 13] = "LastTemplateToken"; SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 24] = "FirstBinaryOperator"; SyntaxKind[SyntaxKind["LastBinaryOperator"] = 63] = "LastBinaryOperator"; - SyntaxKind[SyntaxKind["FirstNode"] = 123] = "FirstNode"; + SyntaxKind[SyntaxKind["FirstNode"] = 125] = "FirstNode"; })(ts.SyntaxKind || (ts.SyntaxKind = {})); var SyntaxKind = ts.SyntaxKind; (function (NodeFlags) { @@ -1595,6 +1605,10 @@ var ts; Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: 1, key: "Only a single variable declaration is allowed in a 'for...of' statement." }, The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: 1, key: "The variable declaration of a 'for...in' statement cannot have an initializer." }, The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: 1, key: "The variable declaration of a 'for...of' statement cannot have an initializer." }, + An_import_declaration_cannot_have_modifiers: { code: 1191, category: 1, key: "An import declaration cannot have modifiers." }, + External_module_0_has_no_default_export_or_export_assignment: { code: 1192, category: 1, key: "External module '{0}' has no default export or export assignment." }, + An_export_declaration_cannot_have_modifiers: { code: 1193, category: 1, key: "An export declaration cannot have modifiers." }, + Export_declarations_are_not_permitted_in_an_internal_module: { code: 1194, category: 1, key: "Export declarations are not permitted in an internal module." }, Duplicate_identifier_0: { code: 2300, category: 1, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: 1, 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: 1, key: "Static members cannot reference class type parameters." }, @@ -1723,7 +1737,7 @@ var ts; Ambient_external_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: 1, key: "Ambient external module declaration cannot specify relative module name." }, Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: 1, key: "Module '{0}' is hidden by a local declaration with the same name" }, Import_name_cannot_be_0: { code: 2438, category: 1, key: "Import name cannot be '{0}'" }, - Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name." }, + Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import or export declaration in an ambient external module declaration cannot reference external module through relative external module name." }, Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: 1, key: "Import declaration conflicts with local declaration of '{0}'" }, Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: { code: 2441, category: 1, key: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module." }, Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: 1, key: "Types have separate declarations of a private property '{0}'." }, @@ -1767,6 +1781,7 @@ var ts; Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: 1, key: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." }, for_of_statements_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 2482, category: 1, key: "'for...of' statements are only available when targeting ECMAScript 6 or higher." }, The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: 1, key: "The left-hand side of a 'for...of' statement cannot use a type annotation." }, + Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: 1, key: "Export declaration conflicts with exported declaration of '{0}'" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: 1, 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: 1, 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: 1, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -1918,17 +1933,18 @@ var ts; var ts; (function (ts) { var textToToken = { - "any": 110, - "boolean": 111, + "any": 112, + "as": 101, + "boolean": 113, "break": 65, "case": 66, "catch": 67, "class": 68, "continue": 70, "const": 69, - "constructor": 112, + "constructor": 114, "debugger": 71, - "declare": 113, + "declare": 115, "default": 72, "delete": 73, "do": 74, @@ -1939,43 +1955,44 @@ var ts; "false": 79, "finally": 80, "for": 81, + "from": 102, "function": 82, - "get": 114, + "get": 116, "if": 83, - "implements": 101, + "implements": 103, "import": 84, "in": 85, "instanceof": 86, - "interface": 102, - "let": 103, - "module": 115, + "interface": 104, + "let": 105, + "module": 117, "new": 87, "null": 88, - "number": 117, - "package": 104, - "private": 105, - "protected": 106, - "public": 107, - "require": 116, + "number": 119, + "package": 106, + "private": 107, + "protected": 108, + "public": 109, + "require": 118, "return": 89, - "set": 118, - "static": 108, - "string": 119, + "set": 120, + "static": 110, + "string": 121, "super": 90, "switch": 91, - "symbol": 120, + "symbol": 122, "this": 92, "throw": 93, "true": 94, "try": 95, - "type": 121, + "type": 123, "typeof": 96, "var": 97, "void": 98, "while": 99, "with": 100, - "yield": 109, - "of": 122, + "yield": 111, + "of": 124, "{": 14, "}": 15, "(": 16, @@ -3116,7 +3133,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 210) { + while (node && node.kind !== 220) { node = node.parent; } return node; @@ -3182,6 +3199,10 @@ var ts; return identifier.length >= 3 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 && identifier.charCodeAt(2) === 95 ? identifier.substr(1) : identifier; } ts.unescapeIdentifier = unescapeIdentifier; + function makeIdentifierFromModuleName(moduleName) { + return ts.getBaseFileName(moduleName).replace(/\W/g, "_"); + } + ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; function declarationNameToString(name) { return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); } @@ -3212,13 +3233,13 @@ var ts; function getErrorSpanForNode(node) { var errorSpan; switch (node.kind) { - case 191: - case 148: - case 194: - case 195: - case 198: + case 193: + case 150: + case 196: case 197: - case 209: + case 200: + case 199: + case 219: errorSpan = node.name; break; } @@ -3234,11 +3255,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 197 && isConst(node); + return node.kind === 199 && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 148 || isBindingPattern(node))) { + while (node && (node.kind === 150 || isBindingPattern(node))) { node = node.parent; } return node; @@ -3246,14 +3267,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 191) { + if (node.kind === 193) { node = node.parent; } - if (node && node.kind === 192) { + if (node && node.kind === 194) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 173) { + if (node && node.kind === 175) { flags |= node.flags; } return flags; @@ -3268,12 +3289,12 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 175 && node.expression.kind === 8; + return node.kind === 177 && node.expression.kind === 8; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node); - if (node.kind === 126 || node.kind === 125) { + if (node.kind === 128 || node.kind === 127) { return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); } else { @@ -3295,22 +3316,22 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 184: + case 186: return visitor(node); - case 172: - case 176: - case 177: + case 174: case 178: case 179: case 180: case 181: - case 185: - case 186: - case 203: - case 204: + case 182: + case 183: case 187: + case 188: + case 213: + case 214: case 189: - case 206: + case 191: + case 216: return ts.forEachChild(node, traverse); } } @@ -3319,22 +3340,22 @@ var ts; function isAnyFunction(node) { if (node) { switch (node.kind) { - case 131: - case 158: - case 193: - case 159: - case 130: - case 129: - case 132: case 133: + case 160: + case 195: + case 161: + case 132: + case 131: case 134: case 135: case 136: + case 137: case 138: - case 139: - case 158: - case 159: - case 193: + case 140: + case 141: + case 160: + case 161: + case 195: return true; } } @@ -3342,11 +3363,11 @@ var ts; } ts.isAnyFunction = isAnyFunction; function isFunctionBlock(node) { - return node && node.kind === 172 && isAnyFunction(node.parent); + return node && node.kind === 174 && isAnyFunction(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 130 && node.parent.kind === 150; + return node && node.kind === 132 && node.parent.kind === 152; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -3365,28 +3386,28 @@ var ts; return undefined; } switch (node.kind) { - case 124: - if (node.parent.parent.kind === 194) { + case 126: + if (node.parent.parent.kind === 196) { return node; } node = node.parent; break; - case 159: + case 161: if (!includeArrowFunctions) { continue; } - case 193: - case 158: - case 198: - case 128: - case 127: + case 195: + case 160: + case 200: case 130: case 129: - case 131: case 132: + case 131: case 133: - case 197: - case 210: + case 134: + case 135: + case 199: + case 220: return node; } } @@ -3398,32 +3419,32 @@ var ts; if (!node) return node; switch (node.kind) { - case 124: - if (node.parent.parent.kind === 194) { + case 126: + if (node.parent.parent.kind === 196) { return node; } node = node.parent; break; - case 193: - case 158: - case 159: + case 195: + case 160: + case 161: if (!includeFunctions) { continue; } - case 128: - case 127: case 130: case 129: - case 131: case 132: + case 131: case 133: + case 134: + case 135: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 155) { + if (node.kind === 157) { return node.tag; } return node.expression; @@ -3437,8 +3458,6 @@ var ts; case 94: case 79: case 9: - case 149: - case 150: case 151: case 152: case 153: @@ -3448,65 +3467,67 @@ var ts; case 157: case 158: case 159: - case 162: case 160: case 161: - case 163: case 164: + case 162: + case 163: case 165: case 166: - case 169: case 167: + case 168: + case 171: + case 169: case 10: - case 170: + case 172: return true; - case 123: - while (node.parent.kind === 123) { + case 125: + while (node.parent.kind === 125) { node = node.parent; } - return node.parent.kind === 140; + return node.parent.kind === 142; case 64: - if (node.parent.kind === 140) { + if (node.parent.kind === 142) { return true; } case 7: case 8: var parent = node.parent; switch (parent.kind) { - case 191: - case 126: + case 193: case 128: - case 127: - case 209: - case 207: - case 148: + case 130: + case 129: + case 219: + case 217: + case 150: return parent.initializer === node; - case 175: - case 176: case 177: case 178: - case 184: - case 185: - case 186: - case 203: - case 188: - case 186: - return parent.expression === node; case 179: + case 180: + case 186: + case 187: + case 188: + case 213: + case 190: + case 188: + return parent.expression === node; + case 181: var forStatement = parent; - return (forStatement.initializer === node && forStatement.initializer.kind !== 192) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 194) || forStatement.condition === node || forStatement.iterator === node; - case 180: - case 181: + case 182: + case 183: var forInStatement = parent; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 192) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 194) || forInStatement.expression === node; - case 156: + case 158: return node === parent.expression; - case 171: + case 173: return node === parent.expression; - case 124: + case 126: return node === parent.expression; default: if (isExpression(parent)) { @@ -3523,36 +3544,51 @@ var ts; (preserveConstEnums && moduleState === 2); } ts.isInstantiatedModule = isInstantiatedModule; - function isExternalModuleImportDeclaration(node) { - return node.kind === 200 && node.moduleReference.kind === 202; + function isExternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind === 212; } - ts.isExternalModuleImportDeclaration = isExternalModuleImportDeclaration; - function getExternalModuleImportDeclarationExpression(node) { - ts.Debug.assert(isExternalModuleImportDeclaration(node)); + ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; + function getExternalModuleImportEqualsDeclarationExpression(node) { + ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node)); return node.moduleReference.expression; } - ts.getExternalModuleImportDeclarationExpression = getExternalModuleImportDeclarationExpression; - function isInternalModuleImportDeclaration(node) { - return node.kind === 200 && node.moduleReference.kind !== 202; + ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; + function isInternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind !== 212; } - ts.isInternalModuleImportDeclaration = isInternalModuleImportDeclaration; + ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; + function getExternalModuleName(node) { + if (node.kind === 203) { + return node.moduleSpecifier; + } + if (node.kind === 202) { + var reference = node.moduleReference; + if (reference.kind === 212) { + return reference.expression; + } + } + if (node.kind === 209) { + return node.moduleSpecifier; + } + } + ts.getExternalModuleName = getExternalModuleName; function hasDotDotDotToken(node) { - return node && node.kind === 126 && node.dotDotDotToken !== undefined; + return node && node.kind === 128 && node.dotDotDotToken !== undefined; } ts.hasDotDotDotToken = hasDotDotDotToken; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 126: + case 128: return node.questionToken !== undefined; + case 132: + case 131: + return node.questionToken !== undefined; + case 218: + case 217: case 130: case 129: return node.questionToken !== undefined; - case 208: - case 207: - case 128: - case 127: - return node.questionToken !== undefined; } } return false; @@ -3575,7 +3611,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return node.kind === 147 || node.kind === 146; + return node.kind === 149 || node.kind === 148; } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -3590,27 +3626,31 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 125: - case 126: - case 191: - case 148: - case 128: case 127: - case 207: - case 208: - case 209: + case 128: + case 193: + case 150: case 130: case 129: - case 193: + case 217: + case 218: + case 219: case 132: - case 133: case 131: - case 194: case 195: + case 134: + case 135: + case 133: case 196: case 197: case 198: + case 199: case 200: + case 202: + case 204: + case 207: + case 205: + case 211: return true; } return false; @@ -3618,25 +3658,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 183: - case 182: - case 190: - case 177: - case 175: - case 174: - case 180: - case 181: - case 179: - case 176: - case 187: - case 184: - case 186: - case 93: - case 189: - case 173: - case 178: case 185: - case 201: + case 184: + case 192: + case 179: + case 177: + case 176: + case 182: + case 183: + case 181: + case 178: + case 189: + case 186: + case 188: + case 93: + case 191: + case 175: + case 180: + case 187: + case 208: return true; default: return false; @@ -3648,10 +3688,10 @@ var ts; return false; } var parent = name.parent; - if (isDeclaration(parent) || parent.kind === 158) { + if (isDeclaration(parent) || parent.kind === 160) { return parent.name === name; } - if (parent.kind === 206) { + if (parent.kind === 216) { return parent.name === name; } return false; @@ -3663,7 +3703,7 @@ var ts; } ts.getClassBaseTypeNode = getClassBaseTypeNode; function getClassImplementedTypeNodes(node) { - var heritageClause = getHeritageClause(node.heritageClauses, 101); + var heritageClause = getHeritageClause(node.heritageClauses, 103); return heritageClause ? heritageClause.types : undefined; } ts.getClassImplementedTypeNodes = getClassImplementedTypeNodes; @@ -3692,32 +3732,11 @@ var ts; } ts.tryResolveScriptReference = tryResolveScriptReference; function getAncestor(node, kind) { - switch (kind) { - case 194: - while (node) { - switch (node.kind) { - case 194: - return node; - case 197: - case 195: - case 196: - case 198: - case 200: - return undefined; - default: - node = node.parent; - continue; - } - } - break; - default: - while (node) { - if (node.kind === kind) { - return node; - } - node = node.parent; - } - break; + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; } return undefined; } @@ -3757,7 +3776,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 65 <= token && token <= 122; + return 65 <= token && token <= 124; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -3766,19 +3785,19 @@ var ts; ts.isTrivia = isTrivia; function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 124 && + declaration.name.kind === 126 && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; function isWellKnownSymbolSyntactically(node) { - return node.kind === 151 && isESSymbolIdentifier(node.expression); + return node.kind === 153 && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 64 || name.kind === 8 || name.kind === 7) { return name.text; } - if (name.kind === 124) { + if (name.kind === 126) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -3798,12 +3817,12 @@ var ts; ts.isESSymbolIdentifier = isESSymbolIdentifier; function isModifier(token) { switch (token) { + case 109: case 107: - case 105: - case 106: case 108: + case 110: case 77: - case 113: + case 115: case 69: return true; } @@ -3987,7 +4006,7 @@ var ts; })(ts || (ts = {})); var ts; (function (ts) { - var nodeConstructors = new Array(212); + var nodeConstructors = new Array(222); ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -4024,20 +4043,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 123: + case 125: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 125: + case 127: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 126: case 128: - case 127: - case 207: - case 208: - case 191: - case 148: + case 130: + case 129: + case 217: + case 218: + case 193: + case 150: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.dotDotDotToken) || @@ -4045,23 +4064,23 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 138: - case 139: - case 134: - case 135: + case 140: + case 141: case 136: + case 137: + case 138: return visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 130: - case 129: - case 131: case 132: + case 131: case 133: - case 158: - case 193: - case 159: + case 134: + case 135: + case 160: + case 195: + case 161: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || @@ -4070,178 +4089,198 @@ var ts; visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type) || visitNode(cbNode, node.body); - case 137: + case 139: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 140: - return visitNode(cbNode, node.exprName); - case 141: - return visitNodes(cbNodes, node.members); case 142: - return visitNode(cbNode, node.elementType); + return visitNode(cbNode, node.exprName); case 143: - return visitNodes(cbNodes, node.elementTypes); + return visitNodes(cbNodes, node.members); case 144: - return visitNodes(cbNodes, node.types); + return visitNode(cbNode, node.elementType); case 145: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.elementTypes); case 146: + return visitNodes(cbNodes, node.types); case 147: - return visitNodes(cbNodes, node.elements); + return visitNode(cbNode, node.type); + case 148: case 149: return visitNodes(cbNodes, node.elements); - case 150: - return visitNodes(cbNodes, node.properties); case 151: + return visitNodes(cbNodes, node.elements); + case 152: + return visitNodes(cbNodes, node.properties); + case 153: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.name); - case 152: + case 154: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 153: - case 154: + case 155: + case 156: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 155: + case 157: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 156: + case 158: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 157: - return visitNode(cbNode, node.expression); - case 160: - return visitNode(cbNode, node.expression); - case 161: + case 159: return visitNode(cbNode, node.expression); case 162: return visitNode(cbNode, node.expression); case 163: + return visitNode(cbNode, node.expression); + case 164: + return visitNode(cbNode, node.expression); + case 165: return visitNode(cbNode, node.operand); - case 168: + case 170: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 164: + case 166: return visitNode(cbNode, node.operand); - case 165: + case 167: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 166: + case 168: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.whenFalse); - case 169: + case 171: return visitNode(cbNode, node.expression); - case 172: - case 199: + case 174: + case 201: return visitNodes(cbNodes, node.statements); - case 210: + case 220: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 173: + case 175: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 192: + case 194: return visitNodes(cbNodes, node.declarations); - case 175: + case 177: return visitNode(cbNode, node.expression); - case 176: + case 178: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 177: + case 179: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 178: + case 180: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 179: + case 181: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.iterator) || visitNode(cbNode, node.statement); - case 180: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); - case 181: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); case 182: - case 183: - return visitNode(cbNode, node.label); - case 184: - return visitNode(cbNode, node.expression); - case 185: - return visitNode(cbNode, node.expression) || + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); + case 183: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 184: + case 185: + return visitNode(cbNode, node.label); case 186: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.clauses); - case 203: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.statements); - case 204: - return visitNodes(cbNodes, node.statements); + return visitNode(cbNode, node.expression); case 187: - return visitNode(cbNode, node.label) || + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 188: - return visitNode(cbNode, node.expression); + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.clauses); + case 213: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.statements); + case 214: + return visitNodes(cbNodes, node.statements); case 189: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 190: + return visitNode(cbNode, node.expression); + case 191: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 206: + case 216: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type) || visitNode(cbNode, node.block); - case 194: - return visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); - case 195: - return visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); case 196: return 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 197: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 209: - return visitNode(cbNode, node.name) || - visitNode(cbNode, node.initializer); case 198: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || - visitNode(cbNode, node.body); + visitNode(cbNode, node.type); + case 199: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.members); + case 219: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); case 200: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + case 202: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 201: + case 203: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier); + case 204: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + case 205: + return visitNode(cbNode, node.name); + case 206: + case 210: + return visitNodes(cbNodes, node.elements); + case 209: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier); + case 207: + case 211: + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + case 208: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportName); - case 167: + case 169: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 171: + case 173: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 124: + case 126: return visitNode(cbNode, node.expression); - case 205: + case 215: return visitNodes(cbNodes, node.types); - case 202: + case 212: return visitNode(cbNode, node.expression); } } @@ -4268,7 +4307,8 @@ var ts; ParsingContext[ParsingContext["TypeArguments"] = 17] = "TypeArguments"; ParsingContext[ParsingContext["TupleElementTypes"] = 18] = "TupleElementTypes"; ParsingContext[ParsingContext["HeritageClauses"] = 19] = "HeritageClauses"; - ParsingContext[ParsingContext["Count"] = 20] = "Count"; + ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 20] = "ImportOrExportSpecifiers"; + ParsingContext[ParsingContext["Count"] = 21] = "Count"; })(ParsingContext || (ParsingContext = {})); var Tristate; (function (Tristate) { @@ -4298,17 +4338,18 @@ var ts; 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; } } ; function modifierToFlag(token) { switch (token) { - case 108: return 128; - case 107: return 16; - case 106: return 64; - case 105: return 32; + case 110: return 128; + case 109: return 16; + case 108: return 64; + case 107: return 32; case 77: return 1; - case 113: return 2; + case 115: return 2; case 69: return 4096; } return 0; @@ -4627,7 +4668,7 @@ var ts; var identifierCount = 0; var nodeCount = 0; var token; - var sourceFile = createNode(210, 0); + var sourceFile = createNode(220, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -4782,10 +4823,10 @@ var ts; if (token === 64) { return true; } - if (token === 109 && inYieldContext()) { + if (token === 111 && inYieldContext()) { return false; } - return inStrictModeContext() ? token > 109 : token > 100; + return inStrictModeContext() ? token > 111 : token > 100; } function parseExpected(kind, diagnosticMessage) { if (token === kind) { @@ -4904,7 +4945,7 @@ var ts; return parseIdentifierName(); } function parseComputedPropertyName() { - var node = createNode(124); + var node = createNode(126); parseExpected(18); var yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { @@ -4931,6 +4972,10 @@ var ts; if (token === 69) { return nextToken() === 76; } + if (token === 77) { + nextToken(); + return token !== 35 && token !== 14 && canFollowModifier(); + } nextToken(); return canFollowModifier(); } @@ -4979,6 +5024,8 @@ var ts; return token === 23 || isStartOfType(); case 19: return isHeritageClause(); + case 20: + return isIdentifierOrKeyword(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); } @@ -4987,7 +5034,7 @@ var ts; return isIdentifier(); } function isNotHeritageClauseTypeName() { - if (token === 101 || + if (token === 103 || token === 78) { return lookAhead(nextTokenIsIdentifier); } @@ -5006,15 +5053,16 @@ var ts; case 7: case 13: case 10: + case 20: return token === 15; case 4: return token === 15 || token === 66 || token === 72; case 8: - return token === 14 || token === 78 || token === 101; + return token === 14 || token === 78 || token === 103; case 9: return isVariableDeclaratorListTerminator(); case 16: - return token === 25 || token === 16 || token === 14 || token === 78 || token === 101; + return token === 25 || token === 16 || token === 14 || token === 78 || token === 103; case 12: return token === 17 || token === 22; case 14: @@ -5042,7 +5090,7 @@ var ts; return false; } function isInSomeParsingContext() { - for (var kind = 0; kind < 20; kind++) { + for (var kind = 0; kind < 21; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -5153,12 +5201,14 @@ var ts; function isReusableModuleElement(node) { if (node) { switch (node.kind) { - case 200: - case 201: - case 194: - case 195: - case 198: + case 203: + case 202: + case 209: + case 208: + case 196: case 197: + case 200: + case 199: return true; } return isReusableStatement(node); @@ -5168,12 +5218,12 @@ var ts; function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 131: - case 136: - case 130: - case 132: case 133: - case 128: + case 138: + case 132: + case 134: + case 135: + case 130: return true; } } @@ -5182,8 +5232,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 203: - case 204: + case 213: + case 214: return true; } } @@ -5192,56 +5242,56 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 193: - case 173: - case 172: - case 176: + case 195: case 175: - case 188: - case 184: - case 186: - case 183: - case 182: - case 180: - case 181: - case 179: - case 178: - case 185: case 174: - case 189: - case 187: + case 178: case 177: case 190: + case 186: + case 188: + case 185: + case 184: + case 182: + case 183: + case 181: + case 180: + case 187: + case 176: + case 191: + case 189: + case 179: + case 192: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 209; + return node.kind === 219; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 135: + case 137: + case 131: + case 138: case 129: case 136: - case 127: - case 134: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 191) { + if (node.kind !== 193) { return false; } var variableDeclarator = node; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 126) { + if (node.kind !== 128) { return false; } var parameter = node; @@ -5310,7 +5360,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20)) { - var node = createNode(123, entity.pos); + var node = createNode(125, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -5327,7 +5377,7 @@ var ts; return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(167); + var template = createNode(169); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); var templateSpans = []; @@ -5340,7 +5390,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(171); + var span = createNode(173); span.expression = allowInAnd(parseExpression); var literal; if (token === 15) { @@ -5369,7 +5419,7 @@ var ts; return node; } function parseTypeReference() { - var node = createNode(137); + var node = createNode(139); node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); if (!scanner.hasPrecedingLineBreak() && token === 24) { node.typeArguments = parseBracketedList(17, parseType, 24, 25); @@ -5377,13 +5427,13 @@ var ts; return finishNode(node); } function parseTypeQuery() { - var node = createNode(140); + var node = createNode(142); parseExpected(96); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(125); + var node = createNode(127); node.name = parseIdentifier(); if (parseOptional(78)) { if (isStartOfType() || !isStartOfExpression()) { @@ -5416,7 +5466,7 @@ var ts; } } function parseParameter() { - var node = createNode(126); + var node = createNode(128); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21); node.name = inGeneratorParameterContext() ? doInYieldContext(parseIdentifierOrPattern) : parseIdentifierOrPattern(); @@ -5460,14 +5510,14 @@ var ts; return requireCompleteParameterList ? undefined : createMissingList(); } function parseTypeMemberSemicolon() { - if (parseSemicolon()) { + if (parseOptional(23)) { return; } - parseOptional(23); + parseSemicolon(); } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 135) { + if (kind === 137) { parseExpected(87); } fillSignature(51, false, false, node); @@ -5508,7 +5558,7 @@ var ts; } function parseIndexSignatureDeclaration(modifiers) { var fullStart = modifiers ? modifiers.pos : scanner.getStartPos(); - var node = createNode(136, fullStart); + var node = createNode(138, fullStart); setModifiers(node, modifiers); node.parameters = parseBracketedList(15, parseParameter, 18, 19); node.type = parseTypeAnnotation(); @@ -5520,7 +5570,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50); if (token === 16 || token === 24) { - var method = createNode(129, fullStart); + var method = createNode(131, fullStart); method.name = name; method.questionToken = questionToken; fillSignature(51, false, false, method); @@ -5528,7 +5578,7 @@ var ts; return finishNode(method); } else { - var property = createNode(127, fullStart); + var property = createNode(129, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -5570,12 +5620,12 @@ var ts; switch (token) { case 16: case 24: - return parseSignatureMember(134); + return parseSignatureMember(136); case 18: return isIndexSignature() ? parseIndexSignatureDeclaration(undefined) : parsePropertyOrMethodSignature(); case 87: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(135); + return parseSignatureMember(137); } case 8: case 7: @@ -5601,7 +5651,7 @@ var ts; return token === 16 || token === 24; } function parseTypeLiteral() { - var node = createNode(141); + var node = createNode(143); node.members = parseObjectTypeMembers(); return finishNode(node); } @@ -5617,12 +5667,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(143); + var node = createNode(145); node.elementTypes = parseBracketedList(18, parseType, 18, 19); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(145); + var node = createNode(147); parseExpected(16); node.type = parseType(); parseExpected(17); @@ -5630,7 +5680,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 139) { + if (kind === 141) { parseExpected(87); } fillSignature(32, false, false, node); @@ -5642,11 +5692,11 @@ var ts; } function parseNonArrayType() { switch (token) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: var node = tryParse(parseKeywordAndNoDot); return node || parseTypeReference(); case 98: @@ -5665,11 +5715,11 @@ var ts; } function isStartOfType() { switch (token) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: case 98: case 96: case 14: @@ -5691,7 +5741,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { parseExpected(19); - var node = createNode(142, type.pos); + var node = createNode(144, type.pos); node.elementType = type; type = finishNode(node); } @@ -5706,7 +5756,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(144, type.pos); + var node = createNode(146, type.pos); node.types = types; type = finishNode(node); } @@ -5751,10 +5801,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(138); + return parseFunctionOrConstructorType(140); } if (token === 87) { - return parseFunctionOrConstructorType(139); + return parseFunctionOrConstructorType(141); } return parseUnionTypeOrHigher(); } @@ -5790,7 +5840,7 @@ var ts; case 39: case 24: case 64: - case 109: + case 111: return true; default: if (isBinaryOperator()) { @@ -5837,7 +5887,7 @@ var ts; return parseConditionalExpressionRest(expr); } function isYieldExpression() { - if (token === 109) { + if (token === 111) { if (inYieldContext()) { return true; } @@ -5853,7 +5903,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(168); + var node = createNode(170); nextToken(); if (!scanner.hasPrecedingLineBreak() && (token === 35 || isStartOfExpression())) { @@ -5867,8 +5917,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(159, identifier.pos); - var parameter = createNode(126, identifier.pos); + var node = createNode(161, identifier.pos); + var parameter = createNode(128, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -5942,7 +5992,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(159); + var node = createNode(161); fillSignature(51, false, !allowAmbiguity, node); if (!node.parameters) { return undefined; @@ -5965,7 +6015,7 @@ var ts; if (!parseOptional(50)) { return leftOperand; } - var node = createNode(166, leftOperand.pos); + var node = createNode(168, leftOperand.pos); node.condition = leftOperand; node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(51); @@ -5977,7 +6027,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 85 || t === 122; + return t === 85 || t === 124; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -6038,33 +6088,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(165, left.pos); + var node = createNode(167, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(163); + var node = createNode(165); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(160); + var node = createNode(162); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(161); + var node = createNode(163); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(162); + var node = createNode(164); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -6094,7 +6144,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(isLeftHandSideExpression(expression)); if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(164, expression.pos); + var node = createNode(166, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -6115,14 +6165,14 @@ var ts; if (token === 16 || token === 20) { return expression; } - var node = createNode(151, expression.pos); + var node = createNode(153, expression.pos); node.expression = expression; parseExpected(20, 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(156); + var node = createNode(158); parseExpected(24); node.type = parseType(); parseExpected(25); @@ -6133,14 +6183,14 @@ var ts; while (true) { var dotOrBracketStart = scanner.getTokenPos(); if (parseOptional(20)) { - var propertyAccess = createNode(151, expression.pos); + var propertyAccess = createNode(153, expression.pos); propertyAccess.expression = expression; propertyAccess.name = parseRightSideOfDot(true); expression = finishNode(propertyAccess); continue; } if (parseOptional(18)) { - var indexedAccess = createNode(152, expression.pos); + var indexedAccess = createNode(154, expression.pos); indexedAccess.expression = expression; if (token !== 19) { indexedAccess.argumentExpression = allowInAnd(parseExpression); @@ -6154,7 +6204,7 @@ var ts; continue; } if (token === 10 || token === 11) { - var tagExpression = createNode(155, expression.pos); + var tagExpression = createNode(157, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 ? parseLiteralNode() : parseTemplateExpression(); expression = finishNode(tagExpression); @@ -6171,7 +6221,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(153, expression.pos); + var callExpr = createNode(155, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -6179,7 +6229,7 @@ var ts; continue; } else if (token === 16) { - var callExpr = createNode(153, expression.pos); + var callExpr = createNode(155, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -6264,26 +6314,26 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(157); + var node = createNode(159); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); return finishNode(node); } function parseSpreadElement() { - var node = createNode(169); + var node = createNode(171); parseExpected(21); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { - return token === 21 ? parseSpreadElement() : token === 23 ? createNode(170) : parseAssignmentExpressionOrHigher(); + return token === 21 ? parseSpreadElement() : token === 23 ? createNode(172) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return allowInAnd(parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(149); + var node = createNode(151); parseExpected(18); if (scanner.hasPrecedingLineBreak()) node.flags |= 256; @@ -6292,11 +6342,11 @@ var ts; return finishNode(node); } function tryParseAccessorDeclaration(fullStart, modifiers) { - if (parseContextualModifier(114)) { - return parseAccessorDeclaration(132, fullStart, modifiers); + if (parseContextualModifier(116)) { + return parseAccessorDeclaration(134, fullStart, modifiers); } - else if (parseContextualModifier(118)) { - return parseAccessorDeclaration(133, fullStart, modifiers); + else if (parseContextualModifier(120)) { + return parseAccessorDeclaration(135, fullStart, modifiers); } return undefined; } @@ -6316,13 +6366,13 @@ var ts; return parseMethodDeclaration(fullStart, modifiers, asteriskToken, propertyName, questionToken); } if ((token === 23 || token === 15) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(208, fullStart); + var shorthandDeclaration = createNode(218, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(207, fullStart); + var propertyAssignment = createNode(217, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51); @@ -6331,7 +6381,7 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(150); + var node = createNode(152); parseExpected(14); if (scanner.hasPrecedingLineBreak()) { node.flags |= 256; @@ -6341,7 +6391,7 @@ var ts; return finishNode(node); } function parseFunctionExpression() { - var node = createNode(158); + var node = createNode(160); parseExpected(82); node.asteriskToken = parseOptionalToken(35); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -6353,7 +6403,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(154); + var node = createNode(156); parseExpected(87); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -6363,7 +6413,7 @@ var ts; return finishNode(node); } function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(172); + var node = createNode(174); if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { node.statements = parseList(2, checkForStrictMode, parseStatement); parseExpected(15); @@ -6381,12 +6431,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(174); + var node = createNode(176); parseExpected(22); return finishNode(node); } function parseIfStatement() { - var node = createNode(176); + var node = createNode(178); parseExpected(83); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6396,7 +6446,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(177); + var node = createNode(179); parseExpected(74); node.statement = parseStatement(); parseExpected(99); @@ -6407,7 +6457,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(178); + var node = createNode(180); parseExpected(99); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6421,7 +6471,7 @@ var ts; parseExpected(16); var initializer = undefined; if (token !== 22) { - if (token === 97 || token === 103 || token === 69) { + if (token === 97 || token === 105 || token === 69) { initializer = parseVariableDeclarationList(true); } else { @@ -6430,21 +6480,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(85)) { - var forInStatement = createNode(180, pos); + var forInStatement = createNode(182, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(122)) { - var forOfStatement = createNode(181, pos); + else if (parseOptional(124)) { + var forOfStatement = createNode(183, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(179, pos); + var forStatement = createNode(181, pos); forStatement.initializer = initializer; parseExpected(22); if (token !== 22 && token !== 17) { @@ -6462,7 +6512,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 183 ? 65 : 70); + parseExpected(kind === 185 ? 65 : 70); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -6470,7 +6520,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(184); + var node = createNode(186); parseExpected(89); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -6479,7 +6529,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(185); + var node = createNode(187); parseExpected(100); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6488,7 +6538,7 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(203); + var node = createNode(213); parseExpected(66); node.expression = allowInAnd(parseExpression); parseExpected(51); @@ -6496,7 +6546,7 @@ var ts; return finishNode(node); } function parseDefaultClause() { - var node = createNode(204); + var node = createNode(214); parseExpected(72); parseExpected(51); node.statements = parseList(4, false, parseStatement); @@ -6506,7 +6556,7 @@ var ts; return token === 66 ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(186); + var node = createNode(188); parseExpected(91); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6517,14 +6567,14 @@ var ts; return finishNode(node); } function parseThrowStatement() { - var node = createNode(188); + var node = createNode(190); parseExpected(93); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); return finishNode(node); } function parseTryStatement() { - var node = createNode(189); + var node = createNode(191); parseExpected(95); node.tryBlock = parseBlock(false, false); node.catchClause = token === 67 ? parseCatchClause() : undefined; @@ -6535,7 +6585,7 @@ var ts; return finishNode(node); } function parseCatchClause() { - var result = createNode(206); + var result = createNode(216); parseExpected(67); parseExpected(16); result.name = parseIdentifier(); @@ -6545,7 +6595,7 @@ var ts; return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(190); + var node = createNode(192); parseExpected(71); parseSemicolon(); return finishNode(node); @@ -6554,13 +6604,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 64 && parseOptional(51)) { - var labeledStatement = createNode(187, fullStart); + var labeledStatement = createNode(189, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(175, fullStart); + var expressionStatement = createNode(177, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -6578,7 +6628,7 @@ var ts; return !inErrorRecovery; case 14: case 97: - case 103: + case 105: case 82: case 83: case 74: @@ -6598,18 +6648,18 @@ var ts; case 69: var isConstEnum = lookAhead(nextTokenIsEnumKeyword); return !isConstEnum; - case 102: + case 104: case 68: - case 115: + case 117: case 76: - case 121: + case 123: if (isDeclarationStart()) { return false; } + case 109: case 107: - case 105: - case 106: case 108: + case 110: if (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine)) { return false; } @@ -6645,9 +6695,9 @@ var ts; case 81: return parseForOrForInOrForOfStatement(); case 70: - return parseBreakOrContinueStatement(182); + return parseBreakOrContinueStatement(184); case 65: - return parseBreakOrContinueStatement(183); + return parseBreakOrContinueStatement(185); case 89: return parseReturnStatement(); case 100: @@ -6662,7 +6712,7 @@ var ts; return parseTryStatement(); case 71: return parseDebuggerStatement(); - case 103: + case 105: if (isLetDeclaration()) { return parseVariableStatement(scanner.getStartPos(), undefined); } @@ -6686,7 +6736,7 @@ var ts; return undefined; } return parseVariableStatement(start, modifiers); - case 103: + case 105: if (!isLetDeclaration()) { return undefined; } @@ -6707,16 +6757,16 @@ var ts; } function parseArrayBindingElement() { if (token === 23) { - return createNode(170); + return createNode(172); } - var node = createNode(148); + var node = createNode(150); node.dotDotDotToken = parseOptionalToken(21); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(148); + var node = createNode(150); var id = parsePropertyName(); if (id.kind === 64 && token !== 51) { node.name = id; @@ -6730,14 +6780,14 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(146); + var node = createNode(148); parseExpected(14); node.elements = parseDelimitedList(10, parseObjectBindingElement); parseExpected(15); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(147); + var node = createNode(149); parseExpected(18); node.elements = parseDelimitedList(11, parseArrayBindingElement); parseExpected(19); @@ -6756,7 +6806,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(191); + var node = createNode(193); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -6765,11 +6815,11 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(192); + var node = createNode(194); switch (token) { case 97: break; - case 103: + case 105: node.flags |= 2048; break; case 69: @@ -6779,7 +6829,7 @@ var ts; ts.Debug.fail(); } nextToken(); - if (token === 122 && lookAhead(canFollowContextualOfKeyword)) { + if (token === 124 && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { @@ -6794,14 +6844,14 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17; } function parseVariableStatement(fullStart, modifiers) { - var node = createNode(173, fullStart); + var node = createNode(175, fullStart); setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); parseSemicolon(); return finishNode(node); } function parseFunctionDeclaration(fullStart, modifiers) { - var node = createNode(193, fullStart); + var node = createNode(195, fullStart); setModifiers(node, modifiers); parseExpected(82); node.asteriskToken = parseOptionalToken(35); @@ -6811,15 +6861,15 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, modifiers) { - var node = createNode(131, pos); + var node = createNode(133, pos); setModifiers(node, modifiers); - parseExpected(112); + parseExpected(114); fillSignature(51, false, false, node); node.body = parseFunctionBlockOrSemicolon(false, ts.Diagnostics.or_expected); return finishNode(node); } function parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(130, fullStart); + var method = createNode(132, fullStart); setModifiers(method, modifiers); method.asteriskToken = asteriskToken; method.name = name; @@ -6836,7 +6886,7 @@ var ts; return parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected); } else { - var property = createNode(128, fullStart); + var property = createNode(130, fullStart); setModifiers(property, modifiers); property.name = name; property.questionToken = questionToken; @@ -6874,7 +6924,7 @@ var ts; return true; } if (idToken !== undefined) { - if (!ts.isKeyword(idToken) || idToken === 118 || idToken === 114) { + if (!ts.isKeyword(idToken) || idToken === 120 || idToken === 116) { return true; } switch (token) { @@ -6919,7 +6969,7 @@ var ts; if (accessor) { return accessor; } - if (token === 112) { + if (token === 114) { return parseConstructorDeclaration(fullStart, modifiers); } if (isIndexSignature()) { @@ -6935,7 +6985,7 @@ var ts; ts.Debug.fail("Should not have attempted to parse class member declaration."); } function parseClassDeclaration(fullStart, modifiers) { - var node = createNode(194, fullStart); + var node = createNode(196, fullStart); setModifiers(node, modifiers); parseExpected(68); node.name = parseIdentifier(); @@ -6960,8 +7010,8 @@ var ts; return parseList(19, false, parseHeritageClause); } function parseHeritageClause() { - if (token === 78 || token === 101) { - var node = createNode(205); + if (token === 78 || token === 103) { + var node = createNode(215); node.token = token; nextToken(); node.types = parseDelimitedList(8, parseTypeReference); @@ -6970,15 +7020,15 @@ var ts; return undefined; } function isHeritageClause() { - return token === 78 || token === 101; + return token === 78 || token === 103; } function parseClassMembers() { return parseList(6, false, parseClassElement); } function parseInterfaceDeclaration(fullStart, modifiers) { - var node = createNode(195, fullStart); + var node = createNode(197, fullStart); setModifiers(node, modifiers); - parseExpected(102); + parseExpected(104); node.name = parseIdentifier(); node.typeParameters = parseTypeParameters(); node.heritageClauses = parseHeritageClauses(false); @@ -6986,9 +7036,9 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, modifiers) { - var node = createNode(196, fullStart); + var node = createNode(198, fullStart); setModifiers(node, modifiers); - parseExpected(121); + parseExpected(123); node.name = parseIdentifier(); parseExpected(52); node.type = parseType(); @@ -6996,13 +7046,13 @@ var ts; return finishNode(node); } function parseEnumMember() { - var node = createNode(209, scanner.getStartPos()); + var node = createNode(219, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, modifiers) { - var node = createNode(197, fullStart); + var node = createNode(199, fullStart); setModifiers(node, modifiers); parseExpected(76); node.name = parseIdentifier(); @@ -7016,7 +7066,7 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(199, scanner.getStartPos()); + var node = createNode(201, scanner.getStartPos()); if (parseExpected(14)) { node.statements = parseList(1, false, parseModuleElement); parseExpected(15); @@ -7027,7 +7077,7 @@ var ts; return finishNode(node); } function parseInternalModuleTail(fullStart, modifiers, flags) { - var node = createNode(198, fullStart); + var node = createNode(200, fullStart); setModifiers(node, modifiers); node.flags |= flags; node.name = parseIdentifier(); @@ -7035,49 +7085,144 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, modifiers) { - var node = createNode(198, fullStart); + var node = createNode(200, fullStart); setModifiers(node, modifiers); node.name = parseLiteralNode(true); node.body = parseModuleBlock(); return finishNode(node); } function parseModuleDeclaration(fullStart, modifiers) { - parseExpected(115); + parseExpected(117); return token === 8 ? parseAmbientExternalModuleDeclaration(fullStart, modifiers) : parseInternalModuleTail(fullStart, modifiers, modifiers ? modifiers.flags : 0); } function isExternalModuleReference() { - return token === 116 && + return token === 118 && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { return nextToken() === 16; } - function parseImportDeclaration(fullStart, modifiers) { - var node = createNode(200, fullStart); - setModifiers(node, modifiers); + function nextTokenIsCommaOrFromKeyword() { + nextToken(); + return token === 23 || + token === 102; + } + function parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers) { parseExpected(84); - node.name = parseIdentifier(); - parseExpected(52); - node.moduleReference = parseModuleReference(); + var afterImportPos = scanner.getStartPos(); + var identifier; + if (isIdentifier()) { + identifier = parseIdentifier(); + if (token !== 23 && token !== 102) { + var importEqualsDeclaration = createNode(202, fullStart); + setModifiers(importEqualsDeclaration, modifiers); + importEqualsDeclaration.name = identifier; + parseExpected(52); + importEqualsDeclaration.moduleReference = parseModuleReference(); + parseSemicolon(); + return finishNode(importEqualsDeclaration); + } + } + var importDeclaration = createNode(203, fullStart); + setModifiers(importDeclaration, modifiers); + if (identifier || + token === 35 || + token === 14) { + importDeclaration.importClause = parseImportClause(identifier, afterImportPos); + parseExpected(102); + } + importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); - return finishNode(node); + return finishNode(importDeclaration); + } + function parseImportClause(identifier, fullStart) { + var importClause = createNode(204, fullStart); + if (identifier) { + importClause.name = identifier; + } + if (!importClause.name || + parseOptional(23)) { + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(206); + } + return finishNode(importClause); } function parseModuleReference() { return isExternalModuleReference() ? parseExternalModuleReference() : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(202); - parseExpected(116); + var node = createNode(212); + parseExpected(118); parseExpected(16); - node.expression = parseExpression(); - if (node.expression.kind === 8) { - internIdentifier(node.expression.text); - } + node.expression = parseModuleSpecifier(); parseExpected(17); return finishNode(node); } + function parseModuleSpecifier() { + var result = parseExpression(); + if (result.kind === 8) { + internIdentifier(result.text); + } + return result; + } + function parseNamespaceImport() { + var namespaceImport = createNode(205); + parseExpected(35); + parseExpected(101); + namespaceImport.name = parseIdentifier(); + return finishNode(namespaceImport); + } + function parseNamedImportsOrExports(kind) { + var node = createNode(kind); + node.elements = parseBracketedList(20, kind === 206 ? parseImportSpecifier : parseExportSpecifier, 14, 15); + return finishNode(node); + } + function parseExportSpecifier() { + return parseImportOrExportSpecifier(211); + } + function parseImportSpecifier() { + return parseImportOrExportSpecifier(207); + } + function parseImportOrExportSpecifier(kind) { + var node = createNode(kind); + var isFirstIdentifierNameNotAnIdentifier = ts.isKeyword(token) && !isIdentifier(); + var start = scanner.getTokenPos(); + var identifierName = parseIdentifierName(); + if (token === 101) { + node.propertyName = identifierName; + parseExpected(101); + if (isIdentifier()) { + node.name = parseIdentifierName(); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected); + } + } + else { + node.name = identifierName; + if (isFirstIdentifierNameNotAnIdentifier) { + parseErrorAtPosition(start, identifierName.end - start, ts.Diagnostics.Identifier_expected); + } + } + return finishNode(node); + } + function parseExportDeclaration(fullStart, modifiers) { + var node = createNode(209, fullStart); + setModifiers(node, modifiers); + if (parseOptional(35)) { + parseExpected(102); + node.moduleSpecifier = parseModuleSpecifier(); + } + else { + node.exportClause = parseNamedImportsOrExports(210); + if (parseOptional(102)) { + node.moduleSpecifier = parseModuleSpecifier(); + } + } + parseSemicolon(); + return finishNode(node); + } function parseExportAssignmentTail(fullStart, modifiers) { - var node = createNode(201, fullStart); + var node = createNode(208, fullStart); setModifiers(node, modifiers); node.exportName = parseIdentifier(); parseSemicolon(); @@ -7092,23 +7237,24 @@ var ts; case 69: case 82: return true; - case 103: + case 105: return isLetDeclaration(); case 68: - case 102: + case 104: case 76: - case 84: - case 121: + case 123: return lookAhead(nextTokenIsIdentifierOrKeyword); - case 115: + case 84: + return lookAhead(nextTokenCanFollowImportKeyword); + case 117: return lookAhead(nextTokenIsIdentifierOrKeywordOrStringLiteral); case 77: - return lookAhead(nextTokenIsEqualsTokenOrDeclarationStart); - case 113: + return lookAhead(nextTokenCanFollowExportKeyword); + case 115: + case 109: case 107: - case 105: - case 106: case 108: + case 110: return lookAhead(nextTokenIsDeclarationStart); } } @@ -7123,14 +7269,23 @@ var ts; nextToken(); return isIdentifierOrKeyword() || token === 8; } - function nextTokenIsEqualsTokenOrDeclarationStart() { + function nextTokenCanFollowImportKeyword() { nextToken(); - return token === 52 || isDeclarationStart(); + return isIdentifierOrKeyword() || token === 8 || + token === 35 || token === 14; + } + function nextTokenCanFollowExportKeyword() { + nextToken(); + return token === 52 || token === 35 || + token === 14 || isDeclarationStart(); } function nextTokenIsDeclarationStart() { nextToken(); return isDeclarationStart(); } + function nextTokenIsAsKeyword() { + return nextToken() === 101; + } function parseDeclaration() { var fullStart = getNodePos(); var modifiers = parseModifiers(); @@ -7139,26 +7294,29 @@ var ts; if (parseOptional(52)) { return parseExportAssignmentTail(fullStart, modifiers); } + if (token === 35 || token === 14) { + return parseExportDeclaration(fullStart, modifiers); + } } switch (token) { case 97: - case 103: + case 105: case 69: return parseVariableStatement(fullStart, modifiers); case 82: return parseFunctionDeclaration(fullStart, modifiers); case 68: return parseClassDeclaration(fullStart, modifiers); - case 102: + case 104: return parseInterfaceDeclaration(fullStart, modifiers); - case 121: + case 123: return parseTypeAliasDeclaration(fullStart, modifiers); case 76: return parseEnumDeclaration(fullStart, modifiers); - case 115: + case 117: return parseModuleDeclaration(fullStart, modifiers); case 84: - return parseImportDeclaration(fullStart, modifiers); + return parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers); default: ts.Debug.fail("Mismatch between isDeclarationStart and parseDeclaration"); } @@ -7231,28 +7389,28 @@ var ts; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { - return node.flags & 1 || node.kind === 200 && node.moduleReference.kind === 202 || node.kind === 201 ? node : undefined; + return node.flags & 1 || node.kind === 202 && node.moduleReference.kind === 212 || node.kind === 203 || node.kind === 208 || node.kind === 209 ? node : undefined; }); } } function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 151: - case 152: - case 154: case 153: + case 154: + case 156: case 155: - case 149: case 157: - case 150: - case 158: + case 151: + case 159: + case 152: + case 160: case 64: case 9: case 7: case 8: case 10: - case 167: + case 169: case 79: case 88: case 92: @@ -7279,16 +7437,16 @@ var ts; })(ts.ModuleInstanceState || (ts.ModuleInstanceState = {})); var ModuleInstanceState = ts.ModuleInstanceState; function getModuleInstanceState(node) { - if (node.kind === 195 || node.kind === 196) { + if (node.kind === 197 || node.kind === 198) { return 0; } else if (ts.isConstEnumDeclaration(node)) { return 2; } - else if (node.kind === 200 && !(node.flags & 1)) { + else if ((node.kind === 203 || node.kind === 202) && !(node.flags & 1)) { return 0; } - else if (node.kind === 199) { + else if (node.kind === 201) { var state = 0; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -7304,7 +7462,7 @@ var ts; }); return state; } - else if (node.kind === 198) { + else if (node.kind === 200) { return getModuleInstanceState(node.body); } else { @@ -7350,10 +7508,10 @@ var ts; } function getDeclarationName(node) { if (node.name) { - if (node.kind === 198 && node.name.kind === 8) { + if (node.kind === 200 && node.name.kind === 8) { return '"' + node.name.text + '"'; } - if (node.name.kind === 124) { + if (node.name.kind === 126) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -7361,15 +7519,15 @@ var ts; return node.name.text; } switch (node.kind) { - case 139: - case 131: + case 141: + case 133: return "__constructor"; - case 138: - case 134: - return "__call"; - case 135: - return "__new"; + case 140: case 136: + return "__call"; + case 137: + return "__new"; + case 138: return "__index"; } } @@ -7398,7 +7556,7 @@ var ts; } addDeclarationToSymbol(symbol, node, includes); symbol.parent = parent; - if (node.kind === 194 && symbol.exports) { + if (node.kind === 196 && symbol.exports) { var prototypeSymbol = createSymbol(4 | 134217728, "prototype"); if (ts.hasProperty(symbol.exports, prototypeSymbol.name)) { if (node.name) { @@ -7420,29 +7578,28 @@ var ts; return false; } function declareModuleMember(node, symbolKind, symbolExcludes) { - var exportKind = 0; - if (symbolKind & 107455) { - exportKind |= 1048576; + var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; + if (symbolKind & 8388608) { + if (node.kind === 211 || (node.kind === 202 && hasExportModifier)) { + declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + } + else { + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); + } } - if (symbolKind & 793056) { - exportKind |= 2097152; - } - if (symbolKind & 1536) { - exportKind |= 4194304; - } - if (ts.getCombinedNodeFlags(node) & 1 || (node.kind !== 200 && isAmbientContext(container))) { - if (exportKind) { + else { + if (hasExportModifier || isAmbientContext(container)) { + var exportKind = (symbolKind & 107455 ? 1048576 : 0) | + (symbolKind & 793056 ? 2097152 : 0) | + (symbolKind & 1536 ? 4194304 : 0); var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes); local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); node.localSymbol = local; } else { - declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); } } - else { - declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); - } } function bindChildren(node, symbolKind, isBlockScopeContainer) { if (symbolKind & 255504) { @@ -7469,40 +7626,40 @@ var ts; } function bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer) { switch (container.kind) { - case 198: + case 200: declareModuleMember(node, symbolKind, symbolExcludes); break; - case 210: + case 220: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolKind, symbolExcludes); break; } + case 140: + case 141: + case 136: + case 137: case 138: - case 139: + case 132: + case 131: + case 133: case 134: case 135: - case 136: - case 130: - case 129: - case 131: - case 132: - case 133: - case 193: - case 158: - case 159: + case 195: + case 160: + case 161: declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); break; - case 194: + case 196: if (node.flags & 128) { declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } - case 141: - case 150: - case 195: + case 143: + case 152: + case 197: declareSymbol(container.symbol.members, container.symbol, node, symbolKind, symbolExcludes); break; - case 197: + case 199: declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } @@ -7528,6 +7685,12 @@ var ts; } } } + function bindExportDeclaration(node) { + if (!node.exportClause) { + (container.exportStars || (container.exportStars = [])).push(node); + } + bindChildren(node, 0, false); + } function bindFunctionOrConstructorType(node) { var symbol = createSymbol(131072, getDeclarationName(node)); addDeclarationToSymbol(symbol, node, 131072); @@ -7535,7 +7698,7 @@ var ts; var typeLiteralSymbol = createSymbol(2048, "__type"); addDeclarationToSymbol(typeLiteralSymbol, node, 2048); typeLiteralSymbol.members = {}; - typeLiteralSymbol.members[node.kind === 138 ? "__call" : "__new"] = symbol; + typeLiteralSymbol.members[node.kind === 140 ? "__call" : "__new"] = symbol; } function bindAnonymousDeclaration(node, symbolKind, name, isBlockScopeContainer) { var symbol = createSymbol(symbolKind, name); @@ -7554,10 +7717,10 @@ var ts; } function bindBlockScopedVariableDeclaration(node) { switch (blockScopeContainer.kind) { - case 198: + case 200: declareModuleMember(node, 2, 107455); break; - case 210: + case 220: if (ts.isExternalModule(container)) { declareModuleMember(node, 2, 107455); break; @@ -7576,14 +7739,14 @@ var ts; function bind(node) { node.parent = parent; switch (node.kind) { - case 125: + case 127: bindDeclaration(node, 262144, 530912, false); break; - case 126: + case 128: bindParameter(node); break; - case 191: - case 148: + case 193: + case 150: if (ts.isBindingPattern(node.name)) { bindChildren(node, 0, false); } @@ -7594,65 +7757,65 @@ var ts; bindDeclaration(node, 1, 107454, false); } break; - case 128: - case 127: - bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); - break; - case 207: - case 208: - bindPropertyOrMethodOrAccessor(node, 4, 107455, false); - break; - case 209: - bindPropertyOrMethodOrAccessor(node, 8, 107455, false); - break; - case 134: - case 135: - case 136: - bindDeclaration(node, 131072, 0, false); - break; case 130: case 129: - bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); + bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); break; - case 193: - bindDeclaration(node, 16, 106927, true); + case 217: + case 218: + bindPropertyOrMethodOrAccessor(node, 4, 107455, false); break; - case 131: - bindDeclaration(node, 16384, 0, true); + case 219: + bindPropertyOrMethodOrAccessor(node, 8, 107455, false); + break; + case 136: + case 137: + case 138: + bindDeclaration(node, 131072, 0, false); break; case 132: - bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); - break; - case 133: - bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); - break; - case 138: - case 139: - bindFunctionOrConstructorType(node); - break; - case 141: - bindAnonymousDeclaration(node, 2048, "__type", false); - break; - case 150: - bindAnonymousDeclaration(node, 4096, "__object", false); - break; - case 158: - case 159: - bindAnonymousDeclaration(node, 16, "__function", true); - break; - case 206: - bindCatchVariableDeclaration(node); - break; - case 194: - bindDeclaration(node, 32, 899583, false); + case 131: + bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); break; case 195: - bindDeclaration(node, 64, 792992, false); + bindDeclaration(node, 16, 106927, true); + break; + case 133: + bindDeclaration(node, 16384, 0, true); + break; + case 134: + bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); + break; + case 135: + bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); + break; + case 140: + case 141: + bindFunctionOrConstructorType(node); + break; + case 143: + bindAnonymousDeclaration(node, 2048, "__type", false); + break; + case 152: + bindAnonymousDeclaration(node, 4096, "__object", false); + break; + case 160: + case 161: + bindAnonymousDeclaration(node, 16, "__function", true); + break; + case 216: + bindCatchVariableDeclaration(node); break; case 196: - bindDeclaration(node, 524288, 793056, false); + bindDeclaration(node, 32, 899583, false); break; case 197: + bindDeclaration(node, 64, 792992, false); + break; + case 198: + bindDeclaration(node, 524288, 793056, false); + break; + case 199: if (ts.isConst(node)) { bindDeclaration(node, 128, 899967, false); } @@ -7660,25 +7823,39 @@ var ts; bindDeclaration(node, 256, 899327, false); } break; - case 198: + case 200: bindModuleDeclaration(node); break; - case 200: + case 202: + case 205: + case 207: + case 211: bindDeclaration(node, 8388608, 8388608, false); break; - case 210: + case 209: + bindExportDeclaration(node); + break; + case 204: + if (node.name) { + bindDeclaration(node, 8388608, 8388608, false); + } + else { + bindChildren(node, 0, false); + } + break; + case 220: if (ts.isExternalModule(node)) { bindAnonymousDeclaration(node, 512, '"' + ts.removeFileExtension(node.fileName) + '"', true); break; } - case 172: + case 174: bindChildren(node, 0, !ts.isAnyFunction(node.parent)); break; - case 206: - case 179: - case 180: + case 216: case 181: - case 186: + case 182: + case 183: + case 188: bindChildren(node, 0, true); break; default: @@ -7696,8 +7873,8 @@ var ts; bindDeclaration(node, 1, 107455, false); } if (node.flags & 112 && - node.parent.kind === 131 && - node.parent.parent.kind === 194) { + node.parent.kind === 133 && + node.parent.parent.kind === 196) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -7890,7 +8067,7 @@ var ts; recordMergedSymbol(result, symbol); return result; } - function extendSymbol(target, source) { + function mergeSymbol(target, source) { if (!(target.flags & getExcludedSymbolFlags(source.flags))) { if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) { target.constEnumOnlyModule = false; @@ -7904,12 +8081,12 @@ var ts; if (source.members) { if (!target.members) target.members = {}; - extendSymbolTable(target.members, source.members); + mergeSymbolTable(target.members, source.members); } if (source.exports) { if (!target.exports) target.exports = {}; - extendSymbolTable(target.exports, source.exports); + mergeSymbolTable(target.exports, source.exports); } recordMergedSymbol(target, source); } @@ -7932,7 +8109,7 @@ var ts; } return result; } - function extendSymbolTable(target, source) { + function mergeSymbolTable(target, source) { for (var id in source) { if (ts.hasProperty(source, id)) { if (!ts.hasProperty(target, id)) { @@ -7943,11 +8120,18 @@ var ts; if (!(symbol.flags & 33554432)) { target[id] = symbol = cloneSymbol(symbol); } - extendSymbol(symbol, source[id]); + mergeSymbol(symbol, source[id]); } } } } + function extendSymbolTable(target, source) { + for (var id in source) { + if (!ts.hasProperty(target, id)) { + target[id] = source[id]; + } + } + } function getSymbolLinks(symbol) { if (symbol.flags & 67108864) return symbol; @@ -7961,10 +8145,10 @@ var ts; return nodeLinks[node.id] || (nodeLinks[node.id] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 210); + return ts.getAncestor(node, 220); } function isGlobalSourceFile(node) { - return node.kind === 210 && !ts.isExternalModule(node); + return node.kind === 220 && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -8005,22 +8189,25 @@ var ts; } } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) break; - case 198: + case 200: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - break loop; + if (!(result.flags & 8388608 && getDeclarationOfImportSymbol(result).kind === 211)) { + break loop; + } + result = undefined; } break; - case 197: + case 199: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { break loop; } break; - case 128: - case 127: - if (location.parent.kind === 194 && !(location.flags & 128)) { + case 130: + case 129: + if (location.parent.kind === 196 && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -8029,8 +8216,8 @@ var ts; } } break; - case 194: - case 195: + case 196: + case 197: 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); @@ -8039,28 +8226,28 @@ var ts; break loop; } break; - case 124: + case 126: var grandparent = location.parent.parent; - if (grandparent.kind === 194 || grandparent.kind === 195) { + if (grandparent.kind === 196 || grandparent.kind === 197) { 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 130: - case 129: - case 131: case 132: + case 131: case 133: - case 193: - case 159: + case 134: + case 135: + case 195: + case 161: if (name === "arguments") { result = argumentsSymbol; break loop; } break; - case 158: + case 160: if (name === "arguments") { result = argumentsSymbol; break loop; @@ -8071,7 +8258,7 @@ var ts; break loop; } break; - case 206: + case 216: var id = location.name; if (name === id.text) { result = location.symbol; @@ -8107,18 +8294,78 @@ var ts; } return result; } + function isImportSymbolDeclaration(node) { + return node.kind === 202 || + node.kind === 204 && !!node.name || + node.kind === 205 || + node.kind === 207 || + node.kind === 211; + } + function getDeclarationOfImportSymbol(symbol) { + return ts.forEach(symbol.declarations, function (d) { return isImportSymbolDeclaration(d) ? d : undefined; }); + } + function getTargetOfImportEqualsDeclaration(node) { + if (node.moduleReference.kind === 212) { + var moduleSymbol = resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node)); + var exportAssignmentSymbol = moduleSymbol && getResolvedExportAssignmentSymbol(moduleSymbol); + return exportAssignmentSymbol || moduleSymbol; + } + return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); + } + function getTargetOfImportClause(node) { + var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); + if (moduleSymbol) { + var exportAssignmentSymbol = getResolvedExportAssignmentSymbol(moduleSymbol); + if (!exportAssignmentSymbol) { + error(node.name, ts.Diagnostics.External_module_0_has_no_default_export_or_export_assignment, symbolToString(moduleSymbol)); + } + return exportAssignmentSymbol; + } + } + function getTargetOfNamespaceImport(node) { + return resolveExternalModuleName(node, node.parent.parent.moduleSpecifier); + } + function getExternalModuleMember(node, specifier) { + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleSymbol) { + var name = specifier.propertyName || specifier.name; + if (name.text) { + var symbol = getSymbol(getExportsOfSymbol(moduleSymbol), name.text, 107455 | 793056 | 1536); + if (!symbol) { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(moduleSymbol), ts.declarationNameToString(name)); + return; + } + return symbol.flags & (107455 | 793056 | 1536) ? symbol : resolveImport(symbol); + } + } + } + function getTargetOfImportSpecifier(node) { + return getExternalModuleMember(node.parent.parent.parent, node); + } + function getTargetOfExportSpecifier(node) { + return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : resolveEntityName(node, node.propertyName || node.name, 107455 | 793056 | 1536); + } + function getTargetOfImportDeclaration(node) { + switch (node.kind) { + case 202: + return getTargetOfImportEqualsDeclaration(node); + case 204: + return getTargetOfImportClause(node); + case 205: + return getTargetOfNamespaceImport(node); + case 207: + return getTargetOfImportSpecifier(node); + case 211: + return getTargetOfExportSpecifier(node); + } + } function resolveImport(symbol) { ts.Debug.assert((symbol.flags & 8388608) !== 0, "Should only get Imports here."); var links = getSymbolLinks(symbol); if (!links.target) { links.target = resolvingSymbol; - var node = ts.getDeclarationOfKind(symbol, 200); - if (node.moduleReference.kind === 202) { - if (node.moduleReference.expression.kind !== 8) { - grammarErrorOnNode(node.moduleReference.expression, ts.Diagnostics.String_literal_expected); - } - } - var target = node.moduleReference.kind === 202 ? resolveExternalModuleName(node, ts.getExternalModuleImportDeclarationExpression(node)) : getSymbolOfPartOfRightHandSideOfImport(node.moduleReference, node); + var node = getDeclarationOfImportSymbol(symbol); + var target = getTargetOfImportDeclaration(node); if (links.target === resolvingSymbol) { links.target = target || unknownSymbol; } @@ -8131,19 +8378,19 @@ var ts; } return links.target; } - function getSymbolOfPartOfRightHandSideOfImport(entityName, importDeclaration) { + function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 200); + importDeclaration = ts.getAncestor(entityName, 202); ts.Debug.assert(importDeclaration !== undefined); } if (entityName.kind === 64 && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { entityName = entityName.parent; } - if (entityName.kind === 64 || entityName.parent.kind === 123) { + if (entityName.kind === 64 || entityName.parent.kind === 125) { return resolveEntityName(importDeclaration, entityName, 1536); } else { - ts.Debug.assert(entityName.parent.kind === 200); + ts.Debug.assert(entityName.parent.kind === 202); return resolveEntityName(importDeclaration, entityName, 107455 | 793056 | 1536); } } @@ -8160,11 +8407,11 @@ var ts; return; } } - else if (name.kind === 123) { + else if (name.kind === 125) { var namespace = resolveEntityName(location, name.left, 1536); if (!namespace || namespace === unknownSymbol || ts.getFullWidth(name.right) === 0) return; - var symbol = getSymbol(namespace.exports, name.right.text, meaning); + var symbol = getSymbol(getExportsOfSymbol(namespace), name.right.text, meaning); if (!symbol) { error(location, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(name.right)); return; @@ -8189,7 +8436,7 @@ var ts; if (!isRelative) { var symbol = getSymbol(globals, '"' + moduleName + '"', 512); if (symbol) { - return getResolvedExportSymbol(symbol); + return symbol; } } while (true) { @@ -8204,14 +8451,14 @@ var ts; } if (sourceFile) { if (sourceFile.symbol) { - return getResolvedExportSymbol(sourceFile.symbol); + return sourceFile.symbol; } error(moduleReferenceLiteral, ts.Diagnostics.File_0_is_not_an_external_module, sourceFile.fileName); return; } error(moduleReferenceLiteral, ts.Diagnostics.Cannot_find_external_module_0, moduleName); } - function getResolvedExportSymbol(moduleSymbol) { + function getResolvedExportAssignmentSymbol(moduleSymbol) { var symbol = getExportAssignmentSymbol(moduleSymbol); if (symbol) { if (symbol.flags & (107455 | 793056 | 1536)) { @@ -8221,16 +8468,14 @@ var ts; return resolveImport(symbol); } } - return moduleSymbol; } function getExportAssignmentSymbol(symbol) { checkTypeOfExportAssignmentSymbol(symbol); - var symbolLinks = getSymbolLinks(symbol); - return symbolLinks.exportAssignSymbol === unknownSymbol ? undefined : symbolLinks.exportAssignSymbol; + return getSymbolLinks(symbol).exportAssignmentSymbol; } function checkTypeOfExportAssignmentSymbol(containerSymbol) { var symbolLinks = getSymbolLinks(containerSymbol); - if (!symbolLinks.exportAssignSymbol) { + if (!symbolLinks.exportAssignmentChecked) { var exportInformation = collectExportInformationForSourceFileOrModule(containerSymbol); if (exportInformation.exportAssignments.length) { if (exportInformation.exportAssignments.length > 1) { @@ -8244,17 +8489,18 @@ var ts; var meaning = 107455 | 793056 | 1536; var exportSymbol = resolveName(node, node.exportName.text, meaning, ts.Diagnostics.Cannot_find_name_0, node.exportName); } + symbolLinks.exportAssignmentSymbol = exportSymbol || unknownSymbol; } - symbolLinks.exportAssignSymbol = exportSymbol || unknownSymbol; + symbolLinks.exportAssignmentChecked = true; } } function collectExportInformationForSourceFileOrModule(symbol) { var seenExportedMember = false; var result = []; ts.forEach(symbol.declarations, function (declaration) { - var block = (declaration.kind === 210 ? declaration : declaration.body); + var block = (declaration.kind === 220 ? declaration : declaration.body); ts.forEach(block.statements, function (node) { - if (node.kind === 201) { + if (node.kind === 208) { result.push(node); } else { @@ -8267,6 +8513,37 @@ var ts; exportAssignments: result }; } + function getExportsOfSymbol(symbol) { + return symbol.flags & 1536 ? getExportsOfModule(symbol) : symbol.exports; + } + function getExportsOfModule(symbol) { + var links = getSymbolLinks(symbol); + return links.resolvedExports || (links.resolvedExports = getExportsForModule(symbol)); + } + function getExportsForModule(symbol) { + var result; + var visitedSymbols = []; + visit(symbol); + return result; + function visit(symbol) { + if (!ts.contains(visitedSymbols, symbol)) { + visitedSymbols.push(symbol); + if (!result) { + result = symbol.exports; + } + else { + extendSymbolTable(result, symbol.exports); + } + ts.forEach(symbol.declarations, function (node) { + if (node.kind === 220 || node.kind === 200) { + ts.forEach(node.exportStars, function (exportStar) { + visit(resolveExternalModuleName(exportStar, exportStar.moduleSpecifier)); + }); + } + }); + } + } + } function getMergedSymbol(symbol) { var merged; return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol; @@ -8296,7 +8573,7 @@ var ts; var members = node.members; for (var i = 0; i < members.length; i++) { var member = members[i]; - if (member.kind === 131 && ts.nodeIsPresent(member.body)) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { return member; } } @@ -8361,17 +8638,17 @@ var ts; } } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) { break; } - case 198: + case 200: if (result = callback(getSymbolOfNode(location).exports)) { return result; } break; - case 194: - case 195: + case 196: + case 197: if (result = callback(getSymbolOfNode(location).members)) { return result; } @@ -8404,7 +8681,7 @@ var ts; return ts.forEachValue(symbols, function (symbolFromSymbolTable) { if (symbolFromSymbolTable.flags & 8388608) { if (!useOnlyExternalAliasing || - ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportDeclaration)) { + ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) { var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable); if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) { return [symbolFromSymbolTable]; @@ -8486,8 +8763,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 198 && declaration.name.kind === 8) || - (declaration.kind === 210 && ts.isExternalModule(declaration)); + return (declaration.kind === 200 && declaration.name.kind === 8) || + (declaration.kind === 220 && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -8497,7 +8774,7 @@ var ts; return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible }; function getIsDeclarationVisible(declaration) { if (!isDeclarationVisible(declaration)) { - if (declaration.kind === 200 && + if (declaration.kind === 202 && !(declaration.flags & 1) && isDeclarationVisible(declaration.parent)) { getNodeLinks(declaration).isVisible = true; @@ -8518,11 +8795,11 @@ var ts; } function isEntityNameVisible(entityName, enclosingDeclaration) { var meaning; - if (entityName.parent.kind === 140) { + if (entityName.parent.kind === 142) { meaning = 107455 | 1048576; } - else if (entityName.kind === 123 || - entityName.parent.kind === 200) { + else if (entityName.kind === 125 || + entityName.parent.kind === 202) { meaning = 1536; } else { @@ -8566,10 +8843,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048) { var node = type.symbol.declarations[0].parent; - while (node.kind === 145) { + while (node.kind === 147) { node = node.parent; } - if (node.kind === 196) { + if (node.kind === 198) { return getSymbolOfNode(node); } } @@ -8722,7 +8999,7 @@ var ts; buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056, 0, flags); } else { - writeKeyword(writer, 110); + writeKeyword(writer, 112); } } else { @@ -8740,7 +9017,7 @@ var ts; var isNonLocalFunctionSymbol = !!(type.symbol.flags & 16) && (type.symbol.parent || ts.forEach(type.symbol.declarations, function (declaration) { - return declaration.parent.kind === 210 || declaration.parent.kind === 199; + return declaration.parent.kind === 220 || declaration.parent.kind === 201; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { return !!(flags & 2) || @@ -8813,7 +9090,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 119); + writeKeyword(writer, 121); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -8826,7 +9103,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 117); + writeKeyword(writer, 119); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -8969,12 +9246,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 198) { + if (node.kind === 200) { if (node.name.kind === 8) { return node; } } - else if (node.kind === 210) { + else if (node.kind === 220) { return ts.isExternalModule(node) ? node : undefined; } } @@ -9016,47 +9293,47 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 191: - case 148: - case 198: - case 194: - case 195: - case 196: case 193: - case 197: + case 150: case 200: + case 196: + case 197: + case 198: + case 195: + case 199: + case 202: var parent = getDeclarationContainer(node); if (!(ts.getCombinedNodeFlags(node) & 1) && - !(node.kind !== 200 && parent.kind !== 210 && ts.isInAmbientContext(parent))) { + !(node.kind !== 202 && parent.kind !== 220 && ts.isInAmbientContext(parent))) { return isGlobalSourceFile(parent) || isUsedInExportAssignment(node); } return isDeclarationVisible(parent); - case 128: - case 127: - case 132: - case 133: case 130: case 129: + case 134: + case 135: + case 132: + case 131: if (node.flags & (32 | 64)) { return false; } - case 131: - case 135: - case 134: - case 136: - case 126: - case 199: - case 138: - case 139: - case 141: + case 133: case 137: - case 142: + case 136: + case 138: + case 128: + case 201: + case 140: + case 141: case 143: + case 139: case 144: case 145: + case 146: + case 147: return isDeclarationVisible(node.parent); - case 125: - case 210: + case 127: + case 220: return true; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -9071,14 +9348,14 @@ var ts; } } function getRootDeclaration(node) { - while (node.kind === 148) { + while (node.kind === 150) { node = node.parent.parent; } return node; } function getDeclarationContainer(node) { node = getRootDeclaration(node); - return node.kind === 191 ? node.parent.parent.parent : node.parent; + return node.kind === 193 ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { var classType = getDeclaredTypeOfSymbol(prototype.parent); @@ -9100,7 +9377,7 @@ var ts; } return parentType; } - if (pattern.kind === 146) { + if (pattern.kind === 148) { var name = declaration.propertyName || declaration.name; var type = getTypeOfPropertyOfType(parentType, name.text) || isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, 1) || @@ -9130,7 +9407,7 @@ var ts; return type; } function getTypeForVariableLikeDeclaration(declaration) { - if (declaration.parent.parent.kind === 180) { + if (declaration.parent.parent.kind === 182) { return anyType; } if (ts.isBindingPattern(declaration.parent)) { @@ -9139,10 +9416,10 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 126) { + if (declaration.kind === 128) { var func = declaration.parent; - if (func.kind === 133 && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 132); + if (func.kind === 135 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 134); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -9155,7 +9432,7 @@ var ts; if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - if (declaration.kind === 208) { + if (declaration.kind === 218) { return checkIdentifier(declaration.name); } return undefined; @@ -9184,7 +9461,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 170 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 172 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -9192,7 +9469,7 @@ var ts; return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes); } function getTypeFromBindingPattern(pattern) { - return pattern.kind === 146 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); + return pattern.kind === 148 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { var type = getTypeForVariableLikeDeclaration(declaration); @@ -9200,7 +9477,7 @@ var ts; if (reportErrors) { reportErrorsFromWidening(declaration, type); } - return declaration.kind !== 207 ? getWidenedType(type) : type; + return declaration.kind !== 217 ? getWidenedType(type) : type; } if (ts.isBindingPattern(declaration.name)) { return getTypeFromBindingPattern(declaration.name); @@ -9208,7 +9485,7 @@ var ts; type = declaration.dotDotDotToken ? anyArrayType : anyType; if (reportErrors && compilerOptions.noImplicitAny) { var root = getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 126 && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 128 && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -9221,7 +9498,7 @@ var ts; return links.type = getTypeOfPrototypeProperty(symbol); } var declaration = symbol.valueDeclaration; - if (declaration.kind === 206) { + if (declaration.kind === 216) { return links.type = anyType; } links.type = resolvingType; @@ -9244,7 +9521,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 132) { + if (accessor.kind === 134) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -9263,8 +9540,8 @@ var ts; links = links || getSymbolLinks(symbol); if (!links.type) { links.type = resolvingType; - var getter = ts.getDeclarationOfKind(symbol, 132); - var setter = ts.getDeclarationOfKind(symbol, 133); + var getter = ts.getDeclarationOfKind(symbol, 134); + var setter = ts.getDeclarationOfKind(symbol, 135); var type; var getterReturnType = getAnnotatedAccessorType(getter); if (getterReturnType) { @@ -9294,7 +9571,7 @@ var ts; else if (links.type === resolvingType) { links.type = anyType; if (compilerOptions.noImplicitAny) { - var getter = ts.getDeclarationOfKind(symbol, 132); + var getter = ts.getDeclarationOfKind(symbol, 134); error(getter, 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)); } } @@ -9361,7 +9638,7 @@ var ts; function getTypeParametersOfClassOrInterface(symbol) { var result; ts.forEach(symbol.declarations, function (node) { - if (node.kind === 195 || node.kind === 194) { + if (node.kind === 197 || node.kind === 196) { var declaration = node; if (declaration.typeParameters && declaration.typeParameters.length) { ts.forEach(declaration.typeParameters, function (node) { @@ -9392,7 +9669,7 @@ var ts; type.typeArguments = type.typeParameters; } type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(symbol, 194); + var declaration = ts.getDeclarationOfKind(symbol, 196); var baseTypeNode = ts.getClassBaseTypeNode(declaration); if (baseTypeNode) { var baseType = getTypeFromTypeReferenceNode(baseTypeNode); @@ -9433,7 +9710,7 @@ var ts; } type.baseTypes = []; ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 195 && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 197 && ts.getInterfaceBaseTypeNodes(declaration)) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), function (node) { var baseType = getTypeFromTypeReferenceNode(node); if (baseType !== unknownType) { @@ -9464,7 +9741,7 @@ var ts; var links = getSymbolLinks(symbol); if (!links.declaredType) { links.declaredType = resolvingType; - var declaration = ts.getDeclarationOfKind(symbol, 196); + var declaration = ts.getDeclarationOfKind(symbol, 198); var type = getTypeFromTypeNode(declaration.type); if (links.declaredType === resolvingType) { links.declaredType = type; @@ -9472,7 +9749,7 @@ var ts; } else if (links.declaredType === resolvingType) { links.declaredType = unknownType; - var declaration = ts.getDeclarationOfKind(symbol, 196); + var declaration = ts.getDeclarationOfKind(symbol, 198); error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } return links.declaredType; @@ -9491,7 +9768,7 @@ var ts; if (!links.declaredType) { var type = createType(512); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 125).constraint) { + if (!ts.getDeclarationOfKind(symbol, 127).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -9700,7 +9977,7 @@ var ts; var callSignatures = emptyArray; var constructSignatures = emptyArray; if (symbol.flags & 1952) { - members = symbol.exports; + members = getExportsOfSymbol(symbol); } if (symbol.flags & (16 | 8192)) { callSignatures = getSignaturesOfSymbol(symbol); @@ -9897,7 +10174,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 131 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 133 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.typeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; var hasStringLiterals = false; @@ -9925,8 +10202,8 @@ var ts; returnType = getTypeFromTypeNode(declaration.type); } else { - if (declaration.kind === 132 && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 133); + if (declaration.kind === 134 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 135); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { @@ -9944,19 +10221,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 138: - case 139: - case 193: - case 130: - case 129: + case 140: + case 141: + case 195: + case 132: case 131: + case 133: + case 136: + case 137: + case 138: case 134: case 135: - case 136: - case 132: - case 133: - case 158: - case 159: + case 160: + case 161: if (i > 0 && node.body) { var previous = symbol.declarations[i - 1]; if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { @@ -10025,7 +10302,7 @@ var ts; } function getOrCreateTypeFromSignature(signature) { if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 131 || signature.declaration.kind === 135; + var isConstructor = signature.declaration.kind === 133 || signature.declaration.kind === 137; var type = createObjectType(32768 | 65536); type.members = emptySymbols; type.properties = emptyArray; @@ -10039,7 +10316,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 ? 117 : 119; + var syntaxKind = kind === 1 ? 119 : 121; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -10066,7 +10343,7 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 125).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 127).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; @@ -10114,13 +10391,13 @@ var ts; while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { currentNode = currentNode.parent; } - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 125; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 127; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 137 && n.typeName.kind === 64) { + if (n.kind === 139 && n.typeName.kind === 64) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056, undefined, undefined); @@ -10185,9 +10462,9 @@ var ts; for (var i = 0; i < declarations.length; i++) { var declaration = declarations[i]; switch (declaration.kind) { - case 194: - case 195: + case 196: case 197: + case 199: return declaration; } } @@ -10360,38 +10637,38 @@ var ts; } function getTypeFromTypeNode(node) { switch (node.kind) { - case 110: + case 112: return anyType; - case 119: + case 121: return stringType; - case 117: + case 119: return numberType; - case 111: + case 113: return booleanType; - case 120: + case 122: return esSymbolType; case 98: return voidType; case 8: return getTypeFromStringLiteral(node); - case 137: - return getTypeFromTypeReferenceNode(node); - case 140: - return getTypeFromTypeQueryNode(node); - case 142: - return getTypeFromArrayTypeNode(node); - case 143: - return getTypeFromTupleTypeNode(node); - case 144: - return getTypeFromUnionTypeNode(node); - case 145: - return getTypeFromTypeNode(node.type); - case 138: case 139: + return getTypeFromTypeReferenceNode(node); + case 142: + return getTypeFromTypeQueryNode(node); + case 144: + return getTypeFromArrayTypeNode(node); + case 145: + return getTypeFromTupleTypeNode(node); + case 146: + return getTypeFromUnionTypeNode(node); + case 147: + return getTypeFromTypeNode(node.type); + case 140: case 141: + case 143: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); case 64: - case 123: + case 125: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -10535,27 +10812,27 @@ var ts; return type; } function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 158: - case 159: + case 160: + case 161: return isContextSensitiveFunctionLikeDeclaration(node); - case 150: + case 152: return ts.forEach(node.properties, isContextSensitive); - case 149: + case 151: return ts.forEach(node.elements, isContextSensitive); - case 166: + case 168: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 165: + case 167: return node.operatorToken.kind === 49 && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 207: + case 217: return isContextSensitive(node.initializer); - case 130: - case 129: + case 132: + case 131: return isContextSensitiveFunctionLikeDeclaration(node); - case 157: + case 159: return isContextSensitive(node.expression); } return false; @@ -11314,20 +11591,20 @@ var ts; function reportImplicitAnyError(declaration, type) { var typeAsString = typeToString(getWidenedType(type)); switch (declaration.kind) { - case 128: - case 127: - var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; - break; - case 126: - var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; - break; - case 193: case 130: case 129: + var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; + break; + case 128: + var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; + break; + case 195: case 132: - case 133: - case 158: - case 159: + case 131: + case 134: + case 135: + case 160: + case 161: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -11556,10 +11833,10 @@ var ts; function isInTypeQuery(node) { while (node) { switch (node.kind) { - case 140: + case 142: return true; case 64: - case 123: + case 125: node = node.parent; continue; default: @@ -11598,7 +11875,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 52 && node.operatorToken.kind <= 63) { var n = node.left; - while (n.kind === 157) { + while (n.kind === 159) { n = n.expression; } if (n.kind === 64 && getResolvedSymbol(n) === symbol) { @@ -11615,46 +11892,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 165: + case 167: return isAssignedInBinaryExpression(node); - case 191: - case 148: - return isAssignedInVariableDeclaration(node); - case 146: - case 147: - case 149: + case 193: case 150: + return isAssignedInVariableDeclaration(node); + case 148: + case 149: case 151: case 152: case 153: case 154: + case 155: case 156: - case 157: - case 163: - case 160: - case 161: + case 158: + case 159: + case 165: case 162: + case 163: case 164: case 166: - case 169: - case 172: - case 173: + case 168: + case 171: + case 174: case 175: - case 176: case 177: case 178: case 179: case 180: case 181: - case 184: - case 185: + case 182: + case 183: case 186: - case 203: - case 204: case 187: case 188: + case 213: + case 214: case 189: - case 206: + case 190: + case 191: + case 216: return ts.forEachChild(node, isAssignedIn); } return false; @@ -11690,17 +11967,17 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 176: + case 178: if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 166: + case 168: if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 165: + case 167: if (child === node.right) { if (node.operatorToken.kind === 48) { narrowedType = narrowType(type, node.left, true); @@ -11710,14 +11987,14 @@ var ts; } } break; - case 210: - case 198: - case 193: - case 130: - case 129: + case 220: + case 200: + case 195: case 132: - case 133: case 131: + case 134: + case 135: + case 133: break loop; } if (narrowedType !== type) { @@ -11730,7 +12007,7 @@ var ts; } return type; function narrowTypeByEquality(type, expr, assumeTrue) { - if (expr.left.kind !== 161 || expr.right.kind !== 8) { + if (expr.left.kind !== 163 || expr.right.kind !== 8) { return type; } var left = expr.left; @@ -11803,9 +12080,9 @@ var ts; } function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 157: + case 159: return narrowType(type, expr.expression, assumeTrue); - case 165: + case 167: var operator = expr.operatorToken.kind; if (operator === 30 || operator === 31) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -11820,7 +12097,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 163: + case 165: if (expr.operator === 46) { return narrowType(type, expr.operand, !assumeTrue); } @@ -11830,27 +12107,29 @@ var ts; } } function markLinkedImportsAsReferenced(node) { - var nodeLinks = getNodeLinks(node); - while (nodeLinks.importOnRightSide) { - var rightSide = nodeLinks.importOnRightSide; - nodeLinks.importOnRightSide = undefined; - getSymbolLinks(rightSide).referenced = true; - ts.Debug.assert((rightSide.flags & 8388608) !== 0); - nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 200)); + if (node) { + var nodeLinks = getNodeLinks(node); + while (nodeLinks.importOnRightSide) { + var rightSide = nodeLinks.importOnRightSide; + nodeLinks.importOnRightSide = undefined; + getSymbolLinks(rightSide).referenced = true; + ts.Debug.assert((rightSide.flags & 8388608) !== 0); + nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 202)); + } } } function checkIdentifier(node) { var symbol = getResolvedSymbol(node); - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 159) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 161) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608) { var symbolLinks = getSymbolLinks(symbol); if (!symbolLinks.referenced) { - var importOrExportAssignment = getLeftSideOfImportOrExportAssignment(node); + var importOrExportAssignment = getLeftSideOfImportEqualsOrExportAssignment(node); if (!importOrExportAssignment || (importOrExportAssignment.flags & 1) || - (importOrExportAssignment.kind === 201)) { + (importOrExportAssignment.kind === 208)) { symbolLinks.referenced = !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveImport(symbol)); } else { @@ -11860,7 +12139,7 @@ var ts; } } if (symbolLinks.referenced) { - markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 200)); + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); } } checkCollisionWithCapturedSuperVariable(node, node); @@ -11868,9 +12147,9 @@ var ts; return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 194 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; getNodeLinks(node).flags |= 2; - if (container.kind === 128 || container.kind === 131) { + if (container.kind === 130 || container.kind === 133) { getNodeLinks(classNode).flags |= 4; } else { @@ -11880,36 +12159,36 @@ var ts; function checkThisExpression(node) { var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; - if (container.kind === 159) { + if (container.kind === 161) { container = ts.getThisContainer(container, false); needToCaptureLexicalThis = (languageVersion < 2); } switch (container.kind) { - case 198: + case 200: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_body); break; - case 197: + case 199: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); break; - case 131: + case 133: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; - case 128: - case 127: + case 130: + case 129: if (container.flags & 128) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 124: + case 126: 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 === 194 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -11918,15 +12197,15 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 126) { + if (n.kind === 128) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 153 && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 194); + var isCallExpression = node.parent.kind === 155 && node.parent.expression === node; + var enclosingClass = ts.getAncestor(node, 196); var baseClass; if (enclosingClass && ts.getClassBaseTypeNode(enclosingClass)) { var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); @@ -11940,31 +12219,31 @@ var ts; if (container) { var canUseSuperExpression = false; if (isCallExpression) { - canUseSuperExpression = container.kind === 131; + canUseSuperExpression = container.kind === 133; } else { var needToCaptureLexicalThis = false; - while (container && container.kind === 159) { + while (container && container.kind === 161) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = true; } - if (container && container.parent && container.parent.kind === 194) { + if (container && container.parent && container.parent.kind === 196) { if (container.flags & 128) { canUseSuperExpression = - container.kind === 130 || - container.kind === 129 || container.kind === 132 || - container.kind === 133; + container.kind === 131 || + container.kind === 134 || + container.kind === 135; } else { canUseSuperExpression = + container.kind === 132 || + container.kind === 131 || + container.kind === 134 || + container.kind === 135 || container.kind === 130 || container.kind === 129 || - container.kind === 132 || - container.kind === 133 || - container.kind === 128 || - container.kind === 127 || - container.kind === 131; + container.kind === 133; } } } @@ -11978,7 +12257,7 @@ var ts; getNodeLinks(node).flags |= 16; returnType = baseClass; } - if (container.kind === 131 && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 133 && isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; } @@ -11988,7 +12267,7 @@ var ts; return returnType; } } - if (container.kind === 124) { + if (container.kind === 126) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -12026,7 +12305,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 126) { + if (declaration.kind === 128) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -12041,7 +12320,7 @@ var ts; function getContextualTypeForReturnExpression(node) { var func = ts.getContainingFunction(node); if (func) { - if (func.type || func.kind === 131 || func.kind === 132 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 133))) { + if (func.type || func.kind === 133 || func.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 135))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(func)); } var signature = getContextualSignatureForFunctionLikeDeclaration(func); @@ -12061,7 +12340,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 155) { + if (template.parent.kind === 157) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -12166,32 +12445,32 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 191: - case 126: + case 193: case 128: - case 127: - case 148: + case 130: + case 129: + case 150: return getContextualTypeForInitializerExpression(node); - case 159: - case 184: + case 161: + case 186: return getContextualTypeForReturnExpression(node); - case 153: - case 154: - return getContextualTypeForArgument(parent, node); + case 155: case 156: + return getContextualTypeForArgument(parent, node); + case 158: return getTypeFromTypeNode(parent.type); - case 165: + case 167: return getContextualTypeForBinaryOperand(node); - case 207: + case 217: return getContextualTypeForObjectLiteralElement(parent); - case 149: + case 151: return getContextualTypeForElementExpression(node); - case 166: + case 168: return getContextualTypeForConditionalOperand(node); - case 171: - ts.Debug.assert(parent.parent.kind === 167); + case 173: + ts.Debug.assert(parent.parent.kind === 169); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 157: + case 159: return getContextualType(parent); } return undefined; @@ -12206,13 +12485,13 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 158 || node.kind === 159; + return node.kind === 160 || node.kind === 161; } function getContextualSignatureForFunctionLikeDeclaration(node) { return isFunctionExpressionOrArrowFunction(node) ? getContextualSignature(node) : undefined; } function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); if (!type) { return undefined; @@ -12253,13 +12532,13 @@ var ts; } function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 165 && parent.operatorToken.kind === 52 && parent.left === node) { + if (parent.kind === 167 && parent.operatorToken.kind === 52 && parent.left === node) { return true; } - if (parent.kind === 207) { + if (parent.kind === 217) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 149) { + if (parent.kind === 151) { return isAssignmentTarget(parent); } return false; @@ -12281,7 +12560,7 @@ var ts; var elementTypes = []; ts.forEach(elements, function (e) { var type = checkExpression(e, contextualMapper); - if (e.kind === 169) { + if (e.kind === 171) { elementTypes.push(getIndexTypeOfType(type, 1) || anyType); hasSpreadElement = true; } @@ -12298,7 +12577,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 124 ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 126 ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { return allConstituentTypesHaveKind(checkComputedPropertyName(name), 1 | 132); @@ -12328,18 +12607,18 @@ var ts; for (var i = 0; i < node.properties.length; i++) { var memberDecl = node.properties[i]; var member = memberDecl.symbol; - if (memberDecl.kind === 207 || - memberDecl.kind === 208 || + if (memberDecl.kind === 217 || + memberDecl.kind === 218 || ts.isObjectLiteralMethod(memberDecl)) { - if (memberDecl.kind === 207) { + if (memberDecl.kind === 217) { var type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 130) { + else if (memberDecl.kind === 132) { var type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 208); - var type = memberDecl.name.kind === 124 ? unknownType : checkExpression(memberDecl.name, contextualMapper); + ts.Debug.assert(memberDecl.kind === 218); + var type = memberDecl.name.kind === 126 ? unknownType : checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; var prop = createSymbol(4 | 67108864 | member.flags, member.name); @@ -12353,7 +12632,7 @@ var ts; member = prop; } else { - ts.Debug.assert(memberDecl.kind === 132 || memberDecl.kind === 133); + ts.Debug.assert(memberDecl.kind === 134 || memberDecl.kind === 135); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -12386,7 +12665,7 @@ var ts; } } function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 128; + return s.valueDeclaration ? s.valueDeclaration.kind : 130; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; @@ -12396,7 +12675,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 194); + var enclosingClassDeclaration = ts.getAncestor(node, 196); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -12443,7 +12722,7 @@ var ts; } getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & 32) { - if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 130) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -12455,12 +12734,12 @@ var ts; return anyType; } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 151 ? node.expression : node.left; + var left = node.kind === 153 ? node.expression : node.left; var type = checkExpressionOrQualifiedName(left); if (type !== unknownType && type !== anyType) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32) { - if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 130) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { return false; } else { @@ -12475,7 +12754,7 @@ var ts; function checkIndexedAccess(node) { if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 154 && node.parent.expression === node) { + if (node.parent.kind === 156 && 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); @@ -12571,7 +12850,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 155) { + if (node.kind === 157) { checkExpression(node.template); } else { @@ -12624,7 +12903,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 169) { + if (args[i].kind === 171) { return i; } } @@ -12634,11 +12913,11 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; - if (node.kind === 155) { + if (node.kind === 157) { var tagExpression = node; adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 167) { + if (tagExpression.template.kind === 169) { var templateExpression = tagExpression.template; var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); ts.Debug.assert(lastSpan !== undefined); @@ -12653,7 +12932,7 @@ var ts; else { var callExpression = node; if (!callExpression.arguments) { - ts.Debug.assert(callExpression.kind === 154); + ts.Debug.assert(callExpression.kind === 156); return signature.minArgumentCount === 0; } adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; @@ -12698,9 +12977,9 @@ var ts; var inferenceMapper = createInferenceMapper(context); for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 170) { - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); - if (i === 0 && args[i].parent.kind === 155) { + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + if (i === 0 && args[i].parent.kind === 157) { var argType = globalTemplateStringsArrayType; } else { @@ -12714,7 +12993,7 @@ var ts; for (var i = 0; i < args.length; i++) { if (excludeArgument[i] === false) { var arg = args[i]; - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType); } } @@ -12747,9 +13026,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 !== 170) { - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); - var argType = i === 0 && node.kind === 155 ? globalTemplateStringsArrayType : arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + var argType = i === 0 && node.kind === 157 ? globalTemplateStringsArrayType : 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)) { return false; } @@ -12759,10 +13038,10 @@ var ts; } function getEffectiveCallArguments(node) { var args; - if (node.kind === 155) { + if (node.kind === 157) { var template = node.template; args = [template]; - if (template.kind === 167) { + if (template.kind === 169) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -12775,7 +13054,7 @@ var ts; } function getEffectiveTypeArguments(callExpression) { if (callExpression.expression.kind === 90) { - var containingClass = ts.getAncestor(callExpression, 194); + var containingClass = ts.getAncestor(callExpression, 196); var baseClassTypeNode = containingClass && ts.getClassBaseTypeNode(containingClass); return baseClassTypeNode && baseClassTypeNode.typeArguments; } @@ -12784,7 +13063,7 @@ var ts; } } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 155; + var isTaggedTemplate = node.kind === 157; var typeArguments; if (!isTaggedTemplate) { typeArguments = getEffectiveTypeArguments(node); @@ -12990,13 +13269,13 @@ var ts; var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 153) { + if (node.kind === 155) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 154) { + else if (node.kind === 156) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 155) { + else if (node.kind === 157) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -13011,12 +13290,12 @@ var ts; if (node.expression.kind === 90) { return voidType; } - if (node.kind === 154) { + if (node.kind === 156) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 131 && - declaration.kind !== 135 && - declaration.kind !== 139) { + declaration.kind !== 133 && + declaration.kind !== 137 && + declaration.kind !== 141) { if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); } @@ -13066,7 +13345,7 @@ var ts; if (!func.body) { return unknownType; } - if (func.body.kind !== 172) { + if (func.body.kind !== 174) { var type = checkExpressionCached(func.body, contextualMapper); } else { @@ -13104,7 +13383,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 188); + return (body.statements.length === 1) && (body.statements[0].kind === 190); } function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { if (!produceDiagnostics) { @@ -13113,7 +13392,7 @@ var ts; if (returnType === voidType || returnType === anyType) { return; } - if (ts.nodeIsMissing(func.body) || func.body.kind !== 172) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 174) { return; } var bodyBlock = func.body; @@ -13126,9 +13405,9 @@ 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 !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 158) { + if (!hasGrammarError && node.kind === 160) { checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); } if (contextualMapper === identityMapper && isContextSensitive(node)) { @@ -13156,19 +13435,19 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 130 && node.kind !== 129) { + if (produceDiagnostics && node.kind !== 132 && node.kind !== 131) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); if (node.type) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } if (node.body) { - if (node.body.kind === 172) { + if (node.body.kind === 174) { checkSourceElement(node.body); } else { @@ -13197,12 +13476,12 @@ var ts; case 64: var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; - case 151: + case 153: var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; - case 152: + case 154: return true; - case 157: + case 159: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -13211,10 +13490,10 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 64: - case 151: + case 153: var symbol = findSymbol(n); return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 4096) !== 0; - case 152: + case 154: var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8) { @@ -13223,7 +13502,7 @@ var ts; return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 4096) !== 0; } return false; - case 157: + case 159: return isConstVariableReference(n.expression); default: return false; @@ -13346,7 +13625,7 @@ var ts; var properties = node.properties; for (var i = 0; i < properties.length; i++) { var p = properties[i]; - if (p.kind === 207 || p.kind === 208) { + if (p.kind === 217 || p.kind === 218) { var name = p.name; var type = sourceType.flags & 1 ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, 1) || @@ -13372,8 +13651,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 170) { - if (e.kind !== 169) { + if (e.kind !== 172) { + if (e.kind !== 171) { var propName = "" + i; var type = sourceType.flags & 1 ? sourceType : isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) : getIndexTypeOfType(sourceType, 1); if (type) { @@ -13396,14 +13675,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 165 && target.operatorToken.kind === 52) { + if (target.kind === 167 && target.operatorToken.kind === 52) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 150) { + if (target.kind === 152) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 149) { + if (target.kind === 151) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -13420,7 +13699,7 @@ var ts; checkGrammarEvalOrArgumentsInStrictMode(node, node.left); } var operator = node.operatorToken.kind; - if (operator === 52 && (node.left.kind === 150 || node.left.kind === 149)) { + if (operator === 52 && (node.left.kind === 152 || node.left.kind === 151)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -13592,14 +13871,14 @@ var ts; return links.resolvedType; } function checkPropertyAssignment(node, contextualMapper) { - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); } function checkObjectLiteralMethod(node, contextualMapper) { checkGrammarMethod(node); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -13625,7 +13904,7 @@ var ts; } function checkExpressionOrQualifiedName(node, contextualMapper) { var type; - if (node.kind == 123) { + if (node.kind == 125) { type = checkQualifiedName(node); } else { @@ -13633,9 +13912,9 @@ var ts; type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); } if (isConstEnumObjectType(type)) { - var ok = (node.parent.kind === 151 && node.parent.expression === node) || - (node.parent.kind === 152 && node.parent.expression === node) || - ((node.kind === 64 || node.kind === 123) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 153 && node.parent.expression === node) || + (node.parent.kind === 154 && node.parent.expression === node) || + ((node.kind === 64 || node.kind === 125) && 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); } @@ -13661,52 +13940,52 @@ var ts; return booleanType; case 7: return checkNumericLiteral(node); - case 167: + case 169: return checkTemplateExpression(node); case 8: case 10: return stringType; case 9: return globalRegExpType; - case 149: - return checkArrayLiteral(node, contextualMapper); - case 150: - return checkObjectLiteral(node, contextualMapper); case 151: - return checkPropertyAccessExpression(node); + return checkArrayLiteral(node, contextualMapper); case 152: - return checkIndexedAccess(node); + return checkObjectLiteral(node, contextualMapper); case 153: + return checkPropertyAccessExpression(node); case 154: - return checkCallExpression(node); + return checkIndexedAccess(node); case 155: - return checkTaggedTemplateExpression(node); case 156: - return checkTypeAssertion(node); + return checkCallExpression(node); case 157: - return checkExpression(node.expression, contextualMapper); + return checkTaggedTemplateExpression(node); case 158: + return checkTypeAssertion(node); case 159: - return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 161: - return checkTypeOfExpression(node); + return checkExpression(node.expression, contextualMapper); case 160: - return checkDeleteExpression(node); - case 162: - return checkVoidExpression(node); + case 161: + return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); case 163: - return checkPrefixUnaryExpression(node); + return checkTypeOfExpression(node); + case 162: + return checkDeleteExpression(node); case 164: - return checkPostfixUnaryExpression(node); + return checkVoidExpression(node); case 165: - return checkBinaryExpression(node, contextualMapper); + return checkPrefixUnaryExpression(node); case 166: - return checkConditionalExpression(node, contextualMapper); - case 169: - return checkSpreadElementExpression(node, contextualMapper); - case 170: - return undefinedType; + return checkPostfixUnaryExpression(node); + case 167: + return checkBinaryExpression(node, contextualMapper); case 168: + return checkConditionalExpression(node, contextualMapper); + case 171: + return checkSpreadElementExpression(node, contextualMapper); + case 172: + return undefinedType; + case 170: checkYieldExpression(node); return unknownType; } @@ -13728,7 +14007,7 @@ var ts; var func = ts.getContainingFunction(node); if (node.flags & 112) { func = ts.getContainingFunction(node); - if (!(func.kind === 131 && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 133 && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -13742,12 +14021,12 @@ var ts; } } function checkSignatureDeclaration(node) { - if (node.kind === 136) { + if (node.kind === 138) { checkGrammarIndexSignature(node); } - else if (node.kind === 138 || node.kind === 193 || node.kind === 139 || - node.kind === 134 || node.kind === 131 || - node.kind === 135) { + else if (node.kind === 140 || node.kind === 195 || node.kind === 141 || + node.kind === 136 || node.kind === 133 || + node.kind === 137) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); @@ -13759,10 +14038,10 @@ var ts; checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 135: + case 137: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 134: + case 136: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -13771,7 +14050,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 195) { + if (node.kind === 197) { var nodeSymbol = getSymbolOfNode(node); if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { return; @@ -13785,7 +14064,7 @@ var ts; var declaration = indexSymbol.declarations[i]; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 119: + case 121: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -13793,7 +14072,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 117: + case 119: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -13830,17 +14109,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 153 && n.expression.kind === 90; + return n.kind === 155 && n.expression.kind === 90; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 158: - case 193: - case 159: - case 150: return false; + case 160: + case 195: + case 161: + case 152: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -13848,12 +14127,12 @@ var ts; if (n.kind === 92) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 158 && n.kind !== 193) { + else if (n.kind !== 160 && n.kind !== 195) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 128 && + return n.kind === 130 && !(n.flags & 128) && !!n.initializer; } @@ -13863,7 +14142,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 !== 175 || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 177 || !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 { @@ -13879,13 +14158,13 @@ var ts; function checkAccessorDeclaration(node) { if (produceDiagnostics) { checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 132) { + if (node.kind === 134) { 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 === 132 ? 133 : 132; + var otherKind = node.kind === 134 ? 135 : 134; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112) !== (otherAccessor.flags & 112))) { @@ -13959,9 +14238,9 @@ var ts; return; } var signaturesToCheck; - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 195) { - ts.Debug.assert(signatureDeclarationNode.kind === 134 || signatureDeclarationNode.kind === 135); - var signatureKind = signatureDeclarationNode.kind === 134 ? 0 : 1; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 197) { + ts.Debug.assert(signatureDeclarationNode.kind === 136 || signatureDeclarationNode.kind === 137); + var signatureKind = signatureDeclarationNode.kind === 136 ? 0 : 1; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -13979,7 +14258,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 195 && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 197 && ts.isInAmbientContext(n)) { if (!(flags & 2)) { flags |= 1; } @@ -14052,7 +14331,7 @@ var ts; if (subsequentNode.kind === node.kind) { var errorNode = subsequentNode.name || subsequentNode; if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { - ts.Debug.assert(node.kind === 130 || node.kind === 129); + ts.Debug.assert(node.kind === 132 || node.kind === 131); 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, diagnostic); @@ -14078,11 +14357,11 @@ var ts; for (var i = 0; i < declarations.length; i++) { var node = declarations[i]; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 195 || node.parent.kind === 141 || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 197 || node.parent.kind === 143 || inAmbientContext; if (inAmbientContextOrInterface) { previousDeclaration = undefined; } - if (node.kind === 193 || node.kind === 130 || node.kind === 129 || node.kind === 131) { + if (node.kind === 195 || node.kind === 132 || node.kind === 131 || node.kind === 133) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -14179,14 +14458,14 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 195: - return 2097152; - case 198: - return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; - case 194: case 197: - return 2097152 | 1048576; + return 2097152; case 200: + return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; + case 196: + case 199: + return 2097152 | 1048576; + case 202: var result = 0; var target = resolveImport(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -14209,7 +14488,7 @@ var ts; } function checkFunctionLikeDeclaration(node) { checkSignatureDeclaration(node); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } if (!ts.hasDynamicName(node)) { @@ -14234,11 +14513,11 @@ var ts; } } function checkBlock(node) { - if (node.kind === 172) { + if (node.kind === 174) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 199) { + if (ts.isFunctionBlock(node) || node.kind === 201) { checkFunctionExpressionBodies(node); } } @@ -14256,19 +14535,19 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 128 || - node.kind === 127 || - node.kind === 130 || + if (node.kind === 130 || node.kind === 129 || node.kind === 132 || - node.kind === 133) { + node.kind === 131 || + node.kind === 134 || + node.kind === 135) { return false; } if (ts.isInAmbientContext(node)) { return false; } var root = getRootDeclaration(node); - if (root.kind === 126 && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 128 && ts.nodeIsMissing(root.parent.body)) { return false; } return true; @@ -14298,7 +14577,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 194); + var enclosingClass = ts.getAncestor(node, 196); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -14316,11 +14595,11 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { return; } - if (node.kind === 198 && ts.getModuleInstanceState(node) !== 1) { + if (node.kind === 200 && ts.getModuleInstanceState(node) !== 1) { return; } var parent = getDeclarationContainer(node); - if (parent.kind === 210 && ts.isExternalModule(parent)) { + if (parent.kind === 220 && ts.isExternalModule(parent)) { error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } } @@ -14333,13 +14612,13 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 6144) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 192); - var container = varDeclList.parent.kind === 173 && + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 194); + var container = varDeclList.parent.kind === 175 && varDeclList.parent.parent; var namesShareScope = container && - (container.kind === 172 && ts.isAnyFunction(container.parent) || - (container.kind === 199 && container.kind === 198) || - container.kind === 210); + (container.kind === 174 && ts.isAnyFunction(container.parent) || + (container.kind === 201 && container.kind === 200) || + container.kind === 220); if (!namesShareScope) { var name = symbolToString(localDeclarationSymbol); error(ts.getErrorSpanForNode(node), ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name); @@ -14350,13 +14629,13 @@ var ts; } } function isParameterDeclaration(node) { - while (node.kind === 148) { + while (node.kind === 150) { node = node.parent.parent; } - return node.kind === 126; + return node.kind === 128; } function checkParameterInitializer(node) { - if (getRootDeclaration(node).kind === 126) { + if (getRootDeclaration(node).kind === 128) { var func = ts.getContainingFunction(node); visit(node.initializer); } @@ -14364,7 +14643,7 @@ var ts; if (n.kind === 64) { var referencedSymbol = getNodeLinks(n).resolvedSymbol; if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 126) { + if (referencedSymbol.valueDeclaration.kind === 128) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -14383,7 +14662,7 @@ var ts; } function checkVariableLikeDeclaration(node) { checkSourceElement(node.type); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -14392,7 +14671,7 @@ var ts; if (ts.isBindingPattern(node.name)) { ts.forEach(node.name.elements, checkSourceElement); } - if (node.initializer && getRootDeclaration(node).kind === 126 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && getRootDeclaration(node).kind === 128 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -14420,9 +14699,9 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 128 && node.kind !== 127) { + if (node.kind !== 130 && node.kind !== 129) { checkExportsOnMergedDeclarations(node); - if (node.kind === 191 || node.kind === 148) { + if (node.kind === 193 || node.kind === 150) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -14451,7 +14730,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 172 || node.kind === 150) { + if (node.kind === 174 || node.kind === 152) { return true; } node = node.parent; @@ -14479,12 +14758,12 @@ var ts; } function checkForStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 192) { + if (node.initializer && node.initializer.kind == 194) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -14502,7 +14781,7 @@ var ts; } function checkForInStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; @@ -14529,7 +14808,7 @@ var ts; checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 132 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 133))); + return !!(node.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 135))); } function checkReturnStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { @@ -14543,11 +14822,11 @@ var ts; if (func) { var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); var exprType = checkExpressionCached(node.expression); - if (func.kind === 133) { + if (func.kind === 135) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } else { - if (func.kind === 131) { + if (func.kind === 133) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } @@ -14574,7 +14853,7 @@ var ts; var hasDuplicateDefaultClause = false; var expressionType = checkExpression(node.expression); ts.forEach(node.clauses, function (clause) { - if (clause.kind === 204 && !hasDuplicateDefaultClause) { + if (clause.kind === 214 && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -14586,7 +14865,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 203) { + if (produceDiagnostics && clause.kind === 213) { var caseClause = clause; var caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { @@ -14603,7 +14882,7 @@ var ts; if (ts.isAnyFunction(current)) { break; } - if (current.kind === 187 && current.label.text === node.label.text) { + if (current.kind === 189 && 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; @@ -14650,7 +14929,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 === 194) { + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 196) { var classDeclaration = type.symbol.valueDeclaration; for (var i = 0; i < classDeclaration.members.length; i++) { var member = classDeclaration.members[i]; @@ -14681,7 +14960,7 @@ var ts; return; } var errorNode; - if (prop.valueDeclaration.name.kind === 124 || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 126 || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -14822,7 +15101,7 @@ var ts; } } function isAccessor(kind) { - return kind === 132 || kind === 133; + return kind === 134 || kind === 135; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -14887,7 +15166,7 @@ var ts; checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 195); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 197); 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); @@ -14923,7 +15202,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 124 && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 126 && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -14959,7 +15238,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 163: + case 165: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -14970,7 +15249,7 @@ var ts; case 47: return enumIsConst ? ~value : undefined; } return undefined; - case 165: + case 167: if (!enumIsConst) { return undefined; } @@ -14998,11 +15277,11 @@ var ts; return undefined; case 7: return +e.text; - case 157: + case 159: return enumIsConst ? evalConstant(e.expression) : undefined; case 64: - case 152: - case 151: + case 154: + case 153: if (!enumIsConst) { return undefined; } @@ -15015,7 +15294,7 @@ var ts; propertyName = e.text; } else { - if (e.kind === 152) { + if (e.kind === 154) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8) { return undefined; @@ -15073,7 +15352,7 @@ var ts; } var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { - if (declaration.kind !== 197) { + if (declaration.kind !== 199) { return false; } var enumDeclaration = declaration; @@ -15096,7 +15375,7 @@ var ts; var declarations = symbol.declarations; for (var i = 0; i < declarations.length; i++) { var declaration = declarations[i]; - if ((declaration.kind === 194 || (declaration.kind === 193 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { + if ((declaration.kind === 196 || (declaration.kind === 195 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } } @@ -15108,16 +15387,13 @@ var ts; if (!ts.isInAmbientContext(node) && node.name.kind === 8) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } - else if (node.name.kind === 64 && node.body.kind === 199) { + else if (node.name.kind === 64 && node.body.kind === 201) { var statements = node.body.statements; for (var i = 0, n = statements.length; i < n; i++) { var statement = statements[i]; - if (statement.kind === 201) { + if (statement.kind === 208) { grammarErrorOnNode(statement, ts.Diagnostics.An_export_assignment_cannot_be_used_in_an_internal_module); } - else if (ts.isExternalModuleImportDeclaration(statement)) { - grammarErrorOnNode(ts.getExternalModuleImportDeclarationExpression(statement), ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); - } } } } @@ -15148,19 +15424,73 @@ var ts; checkSourceElement(node.body); } function getFirstIdentifier(node) { - while (node.kind === 123) { + while (node.kind === 125) { node = node.left; } return node; } - function checkImportDeclaration(node) { - checkGrammarModifiers(node); + function checkExternalImportOrExportDeclaration(node) { + var moduleName = ts.getExternalModuleName(node); + if (ts.getFullWidth(moduleName) !== 0 && moduleName.kind !== 8) { + error(moduleName, ts.Diagnostics.String_literal_expected); + return false; + } + var inAmbientExternalModule = node.parent.kind === 201 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 220 && !inAmbientExternalModule) { + error(moduleName, node.kind === 209 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_an_internal_module : ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); + return false; + } + if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) { + error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); + return false; + } + return true; + } + function checkImportSymbol(node) { + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); + if (target !== unknownSymbol) { + var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | + (symbol.flags & 793056 ? 793056 : 0) | + (symbol.flags & 1536 ? 1536 : 0); + if (target.flags & excludedMeanings) { + var message = node.kind === 211 ? 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)); + } + } + } + function checkImportBinding(node) { checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); - var symbol = getSymbolOfNode(node); - var target; - if (ts.isInternalModuleImportDeclaration(node)) { - target = resolveImport(symbol); + checkImportSymbol(node); + } + function checkImportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); + } + if (checkExternalImportOrExportDeclaration(node)) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + checkImportBinding(importClause); + } + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 205) { + checkImportBinding(importClause.namedBindings); + } + else { + ts.forEach(importClause.namedBindings.elements, checkImportBinding); + } + } + } + } + } + function checkImportEqualsDeclaration(node) { + checkGrammarModifiers(node); + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + checkImportBinding(node); + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); if (target !== unknownSymbol) { if (target.flags & 107455) { var moduleName = getFirstIdentifier(node.moduleReference); @@ -15177,33 +15507,18 @@ var ts; } } else { - if (node.parent.kind === 210) { - target = resolveImport(symbol); - } - else if (node.parent.kind === 199 && node.parent.parent.name.kind === 8) { - if (ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - if (isExternalModuleNameRelative(ts.getExternalModuleImportDeclarationExpression(node).text)) { - error(node, ts.Diagnostics.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); - target = unknownSymbol; - } - else { - target = resolveImport(symbol); - } - } - else { - target = unknownSymbol; - } - } - else { - target = unknownSymbol; + if (checkExternalImportOrExportDeclaration(node)) { + checkImportBinding(node); } } - if (target !== unknownSymbol) { - var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | - (symbol.flags & 793056 ? 793056 : 0) | - (symbol.flags & 1536 ? 1536 : 0); - if (target.flags & excludedMeanings) { - error(node, ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0, symbolToString(symbol)); + } + function checkExportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); + } + if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { + if (node.exportClause) { + ts.forEach(node.exportClause.elements, checkImportSymbol); } } } @@ -15212,7 +15527,7 @@ var ts; grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); } var container = node.parent; - if (container.kind !== 210) { + if (container.kind !== 220) { container = container.parent; } checkTypeOfExportAssignmentSymbol(getSymbolOfNode(container)); @@ -15221,158 +15536,160 @@ var ts; if (!node) return; switch (node.kind) { - case 125: - return checkTypeParameter(node); - case 126: - return checkParameter(node); - case 128: case 127: - return checkPropertyDeclaration(node); - case 138: - case 139: - case 134: - case 135: - return checkSignatureDeclaration(node); - case 136: - return checkSignatureDeclaration(node); + return checkTypeParameter(node); + case 128: + return checkParameter(node); case 130: case 129: - return checkMethodDeclaration(node); - case 131: - return checkConstructorDeclaration(node); - case 132: - case 133: - return checkAccessorDeclaration(node); - case 137: - return checkTypeReference(node); + return checkPropertyDeclaration(node); case 140: - return checkTypeQuery(node); case 141: - return checkTypeLiteral(node); + case 136: + case 137: + return checkSignatureDeclaration(node); + case 138: + return checkSignatureDeclaration(node); + case 132: + case 131: + return checkMethodDeclaration(node); + case 133: + return checkConstructorDeclaration(node); + case 134: + case 135: + return checkAccessorDeclaration(node); + case 139: + return checkTypeReference(node); case 142: - return checkArrayType(node); + return checkTypeQuery(node); case 143: - return checkTupleType(node); + return checkTypeLiteral(node); case 144: - return checkUnionType(node); + return checkArrayType(node); case 145: + return checkTupleType(node); + case 146: + return checkUnionType(node); + case 147: return checkSourceElement(node.type); - case 193: - return checkFunctionDeclaration(node); - case 172: - case 199: - return checkBlock(node); - case 173: - return checkVariableStatement(node); - case 175: - return checkExpressionStatement(node); - case 176: - return checkIfStatement(node); - case 177: - return checkDoStatement(node); - case 178: - return checkWhileStatement(node); - case 179: - return checkForStatement(node); - case 180: - return checkForInStatement(node); - case 181: - return checkForOfStatement(node); - case 182: - case 183: - return checkBreakOrContinueStatement(node); - case 184: - return checkReturnStatement(node); - case 185: - return checkWithStatement(node); - case 186: - return checkSwitchStatement(node); - case 187: - return checkLabeledStatement(node); - case 188: - return checkThrowStatement(node); - case 189: - return checkTryStatement(node); - case 191: - return checkVariableDeclaration(node); - case 148: - return checkBindingElement(node); - case 194: - return checkClassDeclaration(node); case 195: - return checkInterfaceDeclaration(node); - case 196: - return checkTypeAliasDeclaration(node); - case 197: - return checkEnumDeclaration(node); - case 198: - return checkModuleDeclaration(node); - case 200: - return checkImportDeclaration(node); - case 201: - return checkExportAssignment(node); + return checkFunctionDeclaration(node); case 174: + case 201: + return checkBlock(node); + case 175: + return checkVariableStatement(node); + case 177: + return checkExpressionStatement(node); + case 178: + return checkIfStatement(node); + case 179: + return checkDoStatement(node); + case 180: + return checkWhileStatement(node); + case 181: + return checkForStatement(node); + case 182: + return checkForInStatement(node); + case 183: + return checkForOfStatement(node); + case 184: + case 185: + return checkBreakOrContinueStatement(node); + case 186: + return checkReturnStatement(node); + case 187: + return checkWithStatement(node); + case 188: + return checkSwitchStatement(node); + case 189: + return checkLabeledStatement(node); + case 190: + return checkThrowStatement(node); + case 191: + return checkTryStatement(node); + case 193: + return checkVariableDeclaration(node); + case 150: + return checkBindingElement(node); + case 196: + return checkClassDeclaration(node); + case 197: + return checkInterfaceDeclaration(node); + case 198: + return checkTypeAliasDeclaration(node); + case 199: + return checkEnumDeclaration(node); + case 200: + return checkModuleDeclaration(node); + case 203: + return checkImportDeclaration(node); + case 202: + return checkImportEqualsDeclaration(node); + case 209: + return checkExportDeclaration(node); + case 208: + return checkExportAssignment(node); + case 176: checkGrammarStatementInAmbientContext(node); return; - case 190: + case 192: checkGrammarStatementInAmbientContext(node); return; } } function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 158: - case 159: + case 160: + case 161: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; - case 130: - case 129: + case 132: + case 131: ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 131: - case 132: case 133: - case 193: + case 134: + case 135: + case 195: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 185: + case 187: checkFunctionExpressionBodies(node.expression); break; - case 126: case 128: - case 127: - case 146: - case 147: + case 130: + case 129: case 148: case 149: case 150: - case 207: case 151: case 152: + case 217: case 153: case 154: case 155: - case 167: - case 171: case 156: case 157: - case 161: - case 162: - case 160: + case 169: + case 173: + case 158: + case 159: case 163: case 164: + case 162: case 165: case 166: - case 169: - case 172: - case 199: - case 173: + case 167: + case 168: + case 171: + case 174: + case 201: case 175: - case 176: case 177: case 178: case 179: @@ -15381,19 +15698,21 @@ var ts; case 182: case 183: case 184: + case 185: case 186: - case 203: - case 204: - case 187: case 188: + case 213: + case 214: case 189: - case 206: + case 190: case 191: - case 192: + case 216: + case 193: case 194: - case 197: - case 209: - case 210: + case 196: + case 199: + case 219: + case 220: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -15415,7 +15734,7 @@ var ts; var symbol = getExportAssignmentSymbol(node.symbol); if (symbol && symbol.flags & 8388608) { getSymbolLinks(symbol).referenced = true; - markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 200)); + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); } } if (potentialThisCollisions.length) { @@ -15449,7 +15768,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 185 && node.parent.statement === node) { + if (node.parent.kind === 187 && node.parent.statement === node) { return true; } node = node.parent; @@ -15485,27 +15804,27 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) break; - case 198: + case 200: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 197: + case 199: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 194: - case 195: + case 196: + case 197: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 158: + case 160: if (location.name) { copySymbol(location.symbol, meaning); } break; - case 206: + case 216: if (location.name.text) { copySymbol(location.symbol, meaning); } @@ -15524,109 +15843,109 @@ var ts; } function isTypeDeclaration(node) { switch (node.kind) { - case 125: - case 194: - case 195: + case 127: case 196: case 197: + case 198: + case 199: return true; } } function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 123) + while (node.parent && node.parent.kind === 125) node = node.parent; - return node.parent && node.parent.kind === 137; + return node.parent && node.parent.kind === 139; } function isTypeNode(node) { - if (137 <= node.kind && node.kind <= 145) { + if (139 <= node.kind && node.kind <= 147) { return true; } switch (node.kind) { - case 110: - case 117: + case 112: case 119: - case 111: - case 120: + case 121: + case 113: + case 122: return true; case 98: - return node.parent.kind !== 162; + return node.parent.kind !== 164; case 8: - return node.parent.kind === 126; + return node.parent.kind === 128; case 64: - if (node.parent.kind === 123 && node.parent.right === node) { + if (node.parent.kind === 125 && node.parent.right === node) { node = node.parent; } - case 123: - ts.Debug.assert(node.kind === 64 || node.kind === 123, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); + case 125: + ts.Debug.assert(node.kind === 64 || node.kind === 125, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); var parent = node.parent; - if (parent.kind === 140) { + if (parent.kind === 142) { return false; } - if (137 <= parent.kind && parent.kind <= 145) { + if (139 <= parent.kind && parent.kind <= 147) { return true; } switch (parent.kind) { - case 125: - return node === parent.constraint; - case 128: case 127: - case 126: - case 191: - return node === parent.type; - case 193: - case 158: - case 159: - case 131: + return node === parent.constraint; case 130: case 129: - case 132: - case 133: + case 128: + case 193: return node === parent.type; + case 195: + case 160: + case 161: + case 133: + case 132: + case 131: case 134: case 135: + return node === parent.type; case 136: + case 137: + case 138: return node === parent.type; - case 156: + case 158: return node === parent.type; - case 153: - case 154: - return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; case 155: + case 156: + return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; + case 157: return false; } } return false; } - function getLeftSideOfImportOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 123) { + function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { + while (nodeOnRightSide.parent.kind === 125) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 200) { + if (nodeOnRightSide.parent.kind === 202) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 201) { + if (nodeOnRightSide.parent.kind === 208) { return nodeOnRightSide.parent.exportName === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; } function isInRightSideOfImportOrExportAssignment(node) { - return getLeftSideOfImportOrExportAssignment(node) !== undefined; + return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 123 && node.parent.right === node) || - (node.parent.kind === 151 && node.parent.name === node); + return (node.parent.kind === 125 && node.parent.right === node) || + (node.parent.kind === 153 && node.parent.name === node); } function getSymbolOfEntityNameOrPropertyAccessExpression(entityName) { if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 201) { + if (entityName.parent.kind === 208) { return resolveEntityName(entityName.parent.parent, entityName, 107455 | 793056 | 1536 | 8388608); } - if (entityName.kind !== 151) { + if (entityName.kind !== 153) { if (isInRightSideOfImportOrExportAssignment(entityName)) { - return getSymbolOfPartOfRightHandSideOfImport(entityName); + return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); } } if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { @@ -15640,14 +15959,14 @@ var ts; var meaning = 107455 | 8388608; return resolveEntityName(entityName, entityName, meaning); } - else if (entityName.kind === 151) { + else if (entityName.kind === 153) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 123) { + else if (entityName.kind === 125) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -15656,7 +15975,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 137 ? 793056 : 1536; + var meaning = entityName.parent.kind === 139 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, entityName, meaning); } @@ -15670,32 +15989,32 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 64 && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 201 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImport(node); + return node.parent.kind === 208 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 64: - case 151: - case 123: + case 153: + case 125: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 92: case 90: var type = checkExpression(node); return type.symbol; - case 112: + case 114: var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 131) { + if (constructorDeclaration && constructorDeclaration.kind === 133) { return constructorDeclaration.parent.symbol; } return undefined; case 8: - if (ts.isExternalModuleImportDeclaration(node.parent.parent) && - ts.getExternalModuleImportDeclarationExpression(node.parent.parent) === node) { + if (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && + ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) { var importSymbol = getSymbolOfNode(node.parent.parent); var moduleType = getTypeOfSymbol(importSymbol); return moduleType ? moduleType.symbol : undefined; } case 7: - if (node.parent.kind == 152 && node.parent.argumentExpression === node) { + if (node.parent.kind == 154 && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -15709,7 +16028,7 @@ var ts; return undefined; } function getShorthandAssignmentValueSymbol(location) { - if (location && location.kind === 208) { + if (location && location.kind === 218) { return resolveEntityName(location, location.name, 107455); } return undefined; @@ -15783,7 +16102,7 @@ var ts; return [symbol]; } function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 210; + return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 220; } function isNodeDescendentOf(node, ancestor) { while (node) { @@ -15796,60 +16115,144 @@ var ts; function isUniqueLocalName(name, container) { for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) { if (node.locals && ts.hasProperty(node.locals, name)) { - var symbolWithRelevantName = node.locals[name]; - if (symbolWithRelevantName.flags & (107455 | 1048576)) { + if (node.locals[name].flags & (107455 | 1048576 | 8388608)) { return false; } - if (symbolWithRelevantName.flags & 8388608) { - var importDeclarationWithRelevantName = ts.getDeclarationOfKind(symbolWithRelevantName, 200); - if (isReferencedImportDeclaration(importDeclarationWithRelevantName)) { - return false; - } - } } } return true; } - function getLocalNameOfContainer(container) { - var links = getNodeLinks(container); - if (!links.localModuleName) { - var prefix = ""; - var name = ts.unescapeIdentifier(container.name.text); - while (!isUniqueLocalName(ts.escapeIdentifier(prefix + name), container)) { - prefix += "_"; - } - links.localModuleName = prefix + ts.getTextOfNode(container.name); + function getGeneratedNamesForSourceFile(sourceFile) { + var links = getNodeLinks(sourceFile); + var generatedNames = links.generatedNames; + if (!generatedNames) { + generatedNames = links.generatedNames = {}; + generateNames(sourceFile); + } + return generatedNames; + function generateNames(node) { + switch (node.kind) { + case 200: + generateNameForModuleOrEnum(node); + generateNames(node.body); + break; + case 199: + generateNameForModuleOrEnum(node); + break; + case 203: + generateNameForImportDeclaration(node); + break; + case 209: + generateNameForExportDeclaration(node); + break; + case 220: + case 201: + ts.forEach(node.statements, generateNames); + break; + } + } + function isExistingName(name) { + return ts.hasProperty(globals, name) || ts.hasProperty(sourceFile.identifiers, name) || ts.hasProperty(generatedNames, name); + } + function makeUniqueName(baseName) { + if (baseName.charCodeAt(0) !== 95) { + var baseName = "_" + baseName; + if (!isExistingName(baseName)) { + return generatedNames[baseName] = baseName; + } + } + if (baseName.charCodeAt(baseName.length - 1) !== 95) { + baseName += "_"; + } + var i = 1; + while (true) { + name = baseName + i; + if (!isExistingName(name)) { + return generatedNames[name] = name; + } + i++; + } + } + function assignGeneratedName(node, name) { + getNodeLinks(node).generatedName = ts.unescapeIdentifier(name); + } + function generateNameForModuleOrEnum(node) { + if (node.name.kind === 64) { + var name = node.name.text; + assignGeneratedName(node, 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)); + } + function generateNameForImportDeclaration(node) { + if (node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === 206) { + generateNameForImportOrExportDeclaration(node); + } + } + function generateNameForExportDeclaration(node) { + if (node.moduleSpecifier) { + generateNameForImportOrExportDeclaration(node); + } } - return links.localModuleName; } - function getLocalNameForSymbol(symbol, location) { + function getGeneratedNameForNode(node) { + var links = getNodeLinks(node); + if (!links.generatedName) { + getGeneratedNamesForSourceFile(getSourceFile(node)); + } + return links.generatedName; + } + function getLocalNameOfContainer(container) { + return getGeneratedNameForNode(container); + } + function getLocalNameForImportDeclaration(node) { + return getGeneratedNameForNode(node); + } + function getImportNameSubstitution(symbol) { + var declaration = getDeclarationOfImportSymbol(symbol); + if (declaration && declaration.kind === 207) { + var moduleName = getGeneratedNameForNode(declaration.parent.parent.parent); + var propertyName = declaration.propertyName || declaration.name; + return moduleName + "." + ts.unescapeIdentifier(propertyName.text); + } + } + function getExportNameSubstitution(symbol, location) { + if (isExternalModuleSymbol(symbol.parent)) { + return "exports." + ts.unescapeIdentifier(symbol.name); + } var node = location; + var containerSymbol = getParentOfSymbol(symbol); while (node) { - if ((node.kind === 198 || node.kind === 197) && getSymbolOfNode(node) === symbol) { - return getLocalNameOfContainer(node); + if ((node.kind === 200 || node.kind === 199) && getSymbolOfNode(node) === containerSymbol) { + return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); } node = node.parent; } - ts.Debug.fail("getLocalNameForSymbol failed"); } - function getExpressionNamePrefix(node) { + function getExpressionNameSubstitution(node) { var symbol = getNodeLinks(node).resolvedSymbol; if (symbol) { + if (symbol.parent) { + return getExportNameSubstitution(symbol, node.parent); + } var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { - symbol = exportSymbol; + return getExportNameSubstitution(exportSymbol, node.parent); } - if (symbol.parent) { - return isExternalModuleSymbol(symbol.parent) ? "exports" : getLocalNameForSymbol(getParentOfSymbol(symbol), node.parent); + if (symbol.flags & 8388608) { + return getImportNameSubstitution(symbol); } } } function getExportAssignmentName(node) { var symbol = getExportAssignmentSymbol(getSymbolOfNode(node)); - return symbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; + return symbol && symbol !== unknownSymbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; } - function isTopLevelValueImportWithEntityName(node) { - if (node.parent.kind !== 210 || !ts.isInternalModuleImportDeclaration(node)) { + function isTopLevelValueImportEqualsWithEntityName(node) { + if (node.parent.kind !== 220 || !ts.isInternalModuleImportEqualsDeclaration(node)) { return false; } return isImportResolvedToValue(getSymbolOfNode(node)); @@ -15862,14 +16265,16 @@ var ts; return isConstEnumSymbol(s) || s.constEnumOnlyModule; } function isReferencedImportDeclaration(node) { - var symbol = getSymbolOfNode(node); - if (getSymbolLinks(symbol).referenced) { - return true; + if (isImportSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + if (getSymbolLinks(symbol).referenced) { + return true; + } + if (node.kind === 202 && node.flags & 1 && isImportResolvedToValue(symbol)) { + return true; + } } - if (node.flags & 1) { - return isImportResolvedToValue(symbol); - } - return false; + return ts.forEachChild(node, isReferencedImportDeclaration); } function isImplementationOfOverload(node) { if (ts.nodeIsPresent(node.body)) { @@ -15888,14 +16293,14 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 209) { + if (node.kind === 219) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; if (symbol && (symbol.flags & 8)) { var declaration = symbol.valueDeclaration; var constantValue; - if (declaration.kind === 209) { + if (declaration.kind === 219) { return getEnumMemberValue(declaration); } } @@ -15911,16 +16316,17 @@ var ts; getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags); } function isUnknownIdentifier(location, name) { - return !resolveName(location, name, 107455, undefined, undefined); + return !resolveName(location, name, 107455, undefined, undefined) && + !ts.hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), name); } function createResolver() { return { - getLocalNameOfContainer: getLocalNameOfContainer, - getExpressionNamePrefix: getExpressionNamePrefix, + getGeneratedNameForNode: getGeneratedNameForNode, + getExpressionNameSubstitution: getExpressionNameSubstitution, getExportAssignmentName: getExportAssignmentName, isReferencedImportDeclaration: isReferencedImportDeclaration, getNodeCheckFlags: getNodeCheckFlags, - isTopLevelValueImportWithEntityName: isTopLevelValueImportWithEntityName, + isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName, isDeclarationVisible: isDeclarationVisible, isImplementationOfOverload: isImplementationOfOverload, writeTypeOfDeclaration: writeTypeOfDeclaration, @@ -15937,7 +16343,7 @@ var ts; }); ts.forEach(host.getSourceFiles(), function (file) { if (!ts.isExternalModule(file)) { - extendSymbolTable(globals, file.locals); + mergeSymbolTable(globals, file.locals); } }); getSymbolLinks(undefinedSymbol).type = undefinedType; @@ -15966,24 +16372,26 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 132: + case 134: + case 135: case 133: - case 131: - case 128: - case 127: case 130: case 129: - case 136: - case 194: + case 132: + case 131: + case 138: + case 196: + case 197: + case 200: + case 199: + case 175: case 195: case 198: - case 197: - case 201: - case 173: - case 193: - case 196: - case 200: - case 126: + case 203: + case 202: + case 209: + case 208: + case 128: break; default: return false; @@ -15996,14 +16404,14 @@ var ts; for (var i = 0, n = node.modifiers.length; i < n; i++) { var modifier = node.modifiers[i]; switch (modifier.kind) { + case 109: + case 108: case 107: - case 106: - case 105: var text; - if (modifier.kind === 107) { + if (modifier.kind === 109) { text = "public"; } - else if (modifier.kind === 106) { + else if (modifier.kind === 108) { text = "protected"; lastProtected = modifier; } @@ -16017,19 +16425,19 @@ var ts; else if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 199 || node.parent.kind === 210) { + else if (node.parent.kind === 201 || node.parent.kind === 220) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); break; - case 108: + case 110: if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 199 || node.parent.kind === 210) { + else if (node.parent.kind === 201 || node.parent.kind === 220) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128; @@ -16042,25 +16450,25 @@ var ts; else if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 194) { + else if (node.parent.kind === 196) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1; break; - case 113: + case 115: if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 194) { + else if (node.parent.kind === 196) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 199) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 201) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2; @@ -16068,7 +16476,7 @@ var ts; break; } } - if (node.kind === 131) { + if (node.kind === 133) { if (flags & 128) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -16079,13 +16487,13 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if (node.kind === 200 && flags & 2) { + else if ((node.kind === 203 || node.kind === 202) && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 195 && flags & 2) { + else if (node.kind === 197 && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); } - else if (node.kind === 126 && (flags & 112) && ts.isBindingPattern(node.name)) { + else if (node.kind === 128 && (flags & 112) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -16168,7 +16576,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 !== 119 && parameter.type.kind !== 117) { + if (parameter.type.kind !== 121 && parameter.type.kind !== 119) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -16200,7 +16608,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var i = 0, n = arguments.length; i < n; i++) { var arg = arguments[i]; - if (arg.kind === 170) { + if (arg.kind === 172) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -16241,7 +16649,7 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 101); + ts.Debug.assert(heritageClause.token === 103); if (seenImplementsClause) { return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); } @@ -16264,7 +16672,7 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 101); + ts.Debug.assert(heritageClause.token === 103); return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); } checkGrammarHeritageClause(heritageClause); @@ -16273,11 +16681,11 @@ var ts; return false; } function checkGrammarComputedPropertyName(node) { - if (node.kind !== 124) { + if (node.kind !== 126) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 165 && computedPropertyName.expression.operatorToken.kind === 23) { + if (computedPropertyName.expression.kind === 167 && computedPropertyName.expression.operatorToken.kind === 23) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } @@ -16304,26 +16712,26 @@ var ts; for (var i = 0, n = node.properties.length; i < n; i++) { var prop = node.properties[i]; var name = prop.name; - if (prop.kind === 170 || - name.kind === 124) { + if (prop.kind === 172 || + name.kind === 126) { checkGrammarComputedPropertyName(name); continue; } var currentKind; - if (prop.kind === 207 || prop.kind === 208) { + if (prop.kind === 217 || prop.kind === 218) { checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); if (name.kind === 7) { checkGrammarNumbericLiteral(name); } currentKind = Property; } - else if (prop.kind === 130) { + else if (prop.kind === 132) { currentKind = Property; } - else if (prop.kind === 132) { + else if (prop.kind === 134) { currentKind = GetAccessor; } - else if (prop.kind === 133) { + else if (prop.kind === 135) { currentKind = SetAccesor; } else { @@ -16357,20 +16765,20 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 192) { + if (forInOrOfStatement.initializer.kind === 194) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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); } } @@ -16398,10 +16806,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 132 && accessor.parameters.length) { + else if (kind === 134 && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 133) { + else if (kind === 135) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -16426,7 +16834,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 124 && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 126 && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -16436,7 +16844,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 150) { + if (node.parent.kind === 152) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -16444,7 +16852,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 194) { + if (node.parent.kind === 196) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -16455,22 +16863,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 === 195) { + else if (node.parent.kind === 197) { 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 === 141) { + else if (node.parent.kind === 143) { 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 181: + case 182: + case 183: case 179: case 180: - case 181: - case 177: - case 178: return true; - case 187: + case 189: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -16482,17 +16890,17 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 187: + case 189: if (node.label && current.label.text === node.label.text) { - var isMisplacedContinueLabel = node.kind === 182 && !isIterationStatement(current.statement, true); + var isMisplacedContinueLabel = node.kind === 184 && !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); } return false; } break; - case 186: - if (node.kind === 183 && !node.label) { + case 188: + if (node.kind === 185 && !node.label) { return false; } break; @@ -16505,11 +16913,11 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 183 ? 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; + var message = node.kind === 185 ? 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 === 183 ? 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; + var message = node.kind === 185 ? 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); } } @@ -16580,15 +16988,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 176: - case 177: case 178: - case 185: case 179: case 180: - case 181: - return false; case 187: + case 181: + case 182: + case 183: + return false; + case 189: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -16604,7 +17012,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 163) { + if (expression.kind === 165) { var unaryExpression = expression; if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { expression = unaryExpression.operand; @@ -16623,7 +17031,7 @@ var ts; var inAmbientContext = ts.isInAmbientContext(enumDecl); for (var i = 0, n = enumDecl.members.length; i < n; i++) { var node = enumDecl.members[i]; - if (node.name.kind === 124) { + if (node.name.kind === 126) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -16691,18 +17099,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 194) { + if (node.parent.kind === 196) { 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 === 195) { + else if (node.parent.kind === 197) { 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 === 141) { + else if (node.parent.kind === 143) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -16712,9 +17120,11 @@ var ts; } } function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { - if (node.kind === 195 || - node.kind === 200 || - node.kind === 201 || + if (node.kind === 197 || + node.kind === 203 || + node.kind === 202 || + node.kind === 209 || + node.kind === 208 || (node.flags & 2)) { return false; } @@ -16723,7 +17133,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var i = 0, n = file.statements.length; i < n; i++) { var decl = file.statements[i]; - if (ts.isDeclaration(decl) || decl.kind === 173) { + if (ts.isDeclaration(decl) || decl.kind === 175) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -16742,7 +17152,7 @@ var ts; if (!links.hasReportedStatementInAmbientContext && ts.isAnyFunction(node.parent)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); } - if (node.parent.kind === 172 || node.parent.kind === 199 || node.parent.kind === 210) { + if (node.parent.kind === 174 || node.parent.kind === 201 || node.parent.kind === 220) { var links = getNodeLinks(node.parent); if (!links.hasReportedStatementInAmbientContext) { return links.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); @@ -16951,7 +17361,7 @@ var ts; } function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 131 && ts.nodeIsPresent(member.body)) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { return member; } }); @@ -16962,10 +17372,10 @@ var ts; var setAccessor; if (ts.hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 132) { + if (accessor.kind === 134) { getAccessor = accessor; } - else if (accessor.kind === 133) { + else if (accessor.kind === 135) { setAccessor = accessor; } else { @@ -16974,17 +17384,17 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 132 || member.kind === 133) && (member.flags & 128) === (accessor.flags & 128)) { + if ((member.kind === 134 || member.kind === 135) && (member.flags & 128) === (accessor.flags & 128)) { var memberName = ts.getPropertyNameForPropertyNameNode(member.name); var accessorName = ts.getPropertyNameForPropertyNameNode(accessor.name); if (memberName === accessorName) { if (!firstAccessor) { firstAccessor = member; } - if (member.kind === 132 && !getAccessor) { + if (member.kind === 134 && !getAccessor) { getAccessor = member; } - if (member.kind === 133 && !setAccessor) { + if (member.kind === 135 && !setAccessor) { setAccessor = member; } } @@ -17110,16 +17520,16 @@ var ts; increaseIndent = newWriter.increaseIndent; decreaseIndent = newWriter.decreaseIndent; } - function writeAsychronousImportDeclarations(importDeclarations) { + function writeAsychronousImportEqualsDeclarations(importEqualsDeclarations) { var oldWriter = writer; - ts.forEach(importDeclarations, function (aliasToWrite) { + ts.forEach(importEqualsDeclarations, function (aliasToWrite) { var aliasEmitInfo = ts.forEach(aliasDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined; }); if (aliasEmitInfo) { createAndSetNewTextWriterWithSymbolWriter(); for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - writeImportDeclaration(aliasToWrite); + writeImportEqualsDeclaration(aliasToWrite); aliasEmitInfo.asynchronousOutput = writer.getText(); } }); @@ -17128,7 +17538,7 @@ var ts; function handleSymbolAccessibilityError(symbolAccesibilityResult) { if (symbolAccesibilityResult.accessibility === 0) { if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) { - writeAsychronousImportDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); + writeAsychronousImportEqualsDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); } } else { @@ -17198,40 +17608,40 @@ var ts; } function emitType(type) { switch (type.kind) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: case 98: case 8: return writeTextOfNode(currentSourceFile, type); - case 137: - return emitTypeReference(type); - case 140: - return emitTypeQuery(type); - case 142: - return emitArrayType(type); - case 143: - return emitTupleType(type); - case 144: - return emitUnionType(type); - case 145: - return emitParenType(type); - case 138: case 139: - return emitSignatureDeclarationWithJsDocComments(type); + return emitTypeReference(type); + case 142: + return emitTypeQuery(type); + case 144: + return emitArrayType(type); + case 145: + return emitTupleType(type); + case 146: + return emitUnionType(type); + case 147: + return emitParenType(type); + case 140: case 141: + return emitSignatureDeclarationWithJsDocComments(type); + case 143: return emitTypeLiteral(type); case 64: return emitEntityName(type); - case 123: + case 125: return emitEntityName(type); default: ts.Debug.fail("Unknown type annotation: " + type.kind); } function emitEntityName(entityName) { - var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 200 ? entityName.parent : enclosingDeclaration); + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 202 ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -17302,7 +17712,7 @@ var ts; if (node.flags & 1) { write("export "); } - if (node.kind !== 195) { + if (node.kind !== 197) { write("declare "); } } @@ -17318,7 +17728,7 @@ var ts; write("static "); } } - function emitImportDeclaration(node) { + function emitImportEqualsDeclaration(node) { var nodeEmitInfo = { declaration: node, outputPos: writer.getTextPos(), @@ -17327,10 +17737,10 @@ var ts; }; aliasDeclarationEmitInfo.push(nodeEmitInfo); if (nodeEmitInfo.hasWritten) { - writeImportDeclaration(node); + writeImportEqualsDeclaration(node); } } - function writeImportDeclaration(node) { + function writeImportEqualsDeclaration(node) { emitJsDocComments(node); if (node.flags & 1) { write("export "); @@ -17338,13 +17748,13 @@ var ts; write("import "); writeTextOfNode(currentSourceFile, node.name); write(" = "); - if (ts.isInternalModuleImportDeclaration(node)) { + if (ts.isInternalModuleImportEqualsDeclaration(node)) { emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.moduleReference, getImportEntityNameVisibilityError); write(";"); } else { write("require("); - writeTextOfNode(currentSourceFile, ts.getExternalModuleImportDeclarationExpression(node)); + writeTextOfNode(currentSourceFile, ts.getExternalModuleImportEqualsDeclarationExpression(node)); write(");"); } writer.writeLine(); @@ -17362,7 +17772,7 @@ var ts; emitModuleElementDeclarationFlags(node); write("module "); writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 199) { + while (node.body.kind !== 201) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -17428,7 +17838,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 130 && (node.parent.flags & 32); + return node.parent.kind === 132 && (node.parent.flags & 32); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -17438,15 +17848,15 @@ var ts; writeTextOfNode(currentSourceFile, node.name); if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 138 || - node.parent.kind === 139 || - (node.parent.parent && node.parent.parent.kind === 141)) { - ts.Debug.assert(node.parent.kind === 130 || - node.parent.kind === 129 || - node.parent.kind === 138 || - node.parent.kind === 139 || - node.parent.kind === 134 || - node.parent.kind === 135); + if (node.parent.kind === 140 || + node.parent.kind === 141 || + (node.parent.parent && node.parent.parent.kind === 143)) { + ts.Debug.assert(node.parent.kind === 132 || + node.parent.kind === 131 || + node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.kind === 136 || + node.parent.kind === 137); emitType(node.constraint); } else { @@ -17456,31 +17866,31 @@ var ts; function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 194: + case 196: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 195: + case 197: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 135: + case 137: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 134: + case 136: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 130: - case 129: + case 132: + case 131: 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 === 194) { + else if (node.parent.parent.kind === 196) { 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 193: + case 195: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -17508,7 +17918,7 @@ var ts; emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError); function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.parent.parent.kind === 194) { + if (node.parent.parent.kind === 196) { 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; } else { @@ -17587,12 +17997,12 @@ var ts; writeLine(); } function emitVariableDeclaration(node) { - if (node.kind !== 191 || resolver.isDeclarationVisible(node)) { + if (node.kind !== 193 || resolver.isDeclarationVisible(node)) { writeTextOfNode(currentSourceFile, node.name); - if ((node.kind === 128 || node.kind === 127) && ts.hasQuestionToken(node)) { + if ((node.kind === 130 || node.kind === 129) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 128 || node.kind === 127) && node.parent.kind === 141) { + if ((node.kind === 130 || node.kind === 129) && node.parent.kind === 143) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32)) { @@ -17601,14 +18011,14 @@ var ts; } function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.kind === 191) { + if (node.kind === 193) { diagnosticMessage = 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 === 128 || node.kind === 127) { + else if (node.kind === 130 || node.kind === 129) { if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 194) { + else if (node.parent.kind === 196) { diagnosticMessage = 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 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; } else { @@ -17661,7 +18071,7 @@ var ts; var accessorWithTypeAnnotation = node; var type = getTypeAnnotationFromAccessor(node); if (!type) { - var anotherAccessor = node.kind === 132 ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 134 ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -17674,12 +18084,12 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 132 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; + return accessor.kind === 134 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; } } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 133) { + if (accessorWithTypeAnnotation.kind === 135) { 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 : ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1; } @@ -17711,20 +18121,20 @@ var ts; if (ts.hasDynamicName(node)) { return; } - if ((node.kind !== 193 || resolver.isDeclarationVisible(node)) && + if ((node.kind !== 195 || resolver.isDeclarationVisible(node)) && !resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 193) { + if (node.kind === 195) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 130) { + else if (node.kind === 132) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 193) { + if (node.kind === 195) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 131) { + else if (node.kind === 133) { write("constructor"); } else { @@ -17741,11 +18151,11 @@ var ts; emitSignatureDeclaration(node); } function emitSignatureDeclaration(node) { - if (node.kind === 135 || node.kind === 139) { + if (node.kind === 137 || node.kind === 141) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 136) { + if (node.kind === 138) { write("["); } else { @@ -17754,20 +18164,20 @@ var ts; var prevEnclosingDeclaration = enclosingDeclaration; enclosingDeclaration = node; emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 136) { + if (node.kind === 138) { write("]"); } else { write(")"); } - var isFunctionTypeOrConstructorType = node.kind === 138 || node.kind === 139; - if (isFunctionTypeOrConstructorType || node.parent.kind === 141) { + var isFunctionTypeOrConstructorType = node.kind === 140 || node.kind === 141; + if (isFunctionTypeOrConstructorType || node.parent.kind === 143) { if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 131 && !(node.flags & 32)) { + else if (node.kind !== 133 && !(node.flags & 32)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -17778,28 +18188,28 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 135: + case 137: 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 134: + case 136: 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 136: + case 138: 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 130: - case 129: + case 132: + case 131: if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : 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 === 194) { + else if (node.parent.kind === 196) { 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 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 193: + case 195: 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 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; break; default: @@ -17827,9 +18237,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 138 || - node.parent.kind === 139 || - node.parent.parent.kind === 141) { + if (node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.parent.kind === 143) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32)) { @@ -17838,28 +18248,28 @@ var ts; function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 131: + case 133: diagnosticMessage = 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; break; - case 135: + case 137: diagnosticMessage = 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; break; - case 134: + case 136: diagnosticMessage = 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; break; - case 130: - case 129: + case 132: + case 131: if (node.parent.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 194) { + else if (node.parent.parent.kind === 196) { diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? 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; } break; - case 193: + case 195: diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -17874,40 +18284,40 @@ var ts; } function emitNode(node) { switch (node.kind) { + case 133: + case 195: + case 132: case 131: - case 193: + return emitFunctionDeclaration(node); + case 137: + case 136: + case 138: + return emitSignatureDeclarationWithJsDocComments(node); + case 134: + case 135: + return emitAccessorDeclaration(node); + case 175: + return emitVariableStatement(node); case 130: case 129: - return emitFunctionDeclaration(node); - case 135: - case 134: - case 136: - return emitSignatureDeclarationWithJsDocComments(node); - case 132: - case 133: - return emitAccessorDeclaration(node); - case 173: - return emitVariableStatement(node); - case 128: - case 127: return emitPropertyDeclaration(node); - case 195: - return emitInterfaceDeclaration(node); - case 194: - return emitClassDeclaration(node); - case 196: - return emitTypeAliasDeclaration(node); - case 209: - return emitEnumMemberDeclaration(node); case 197: - return emitEnumDeclaration(node); + return emitInterfaceDeclaration(node); + case 196: + return emitClassDeclaration(node); case 198: - return emitModuleDeclaration(node); + return emitTypeAliasDeclaration(node); + case 219: + return emitEnumMemberDeclaration(node); + case 199: + return emitEnumDeclaration(node); case 200: - return emitImportDeclaration(node); - case 201: + return emitModuleDeclaration(node); + case 202: + return emitImportEqualsDeclaration(node); + case 208: return emitExportAssignment(node); - case 210: + case 220: return emitSourceFile(node); } } @@ -17968,6 +18378,8 @@ var ts; var tempCount = 0; var tempVariables; var tempParameters; + var externalImports; + var exportSpecifiers; var writeEmittedFiles = writeJavaScriptFile; var emitLeadingComments = compilerOptions.removeComments ? function (node) { } : emitLeadingDeclarationComments; var emitTrailingComments = compilerOptions.removeComments ? function (node) { } : emitTrailingDeclarationComments; @@ -18124,7 +18536,7 @@ var ts; var parentIndex = getSourceMapNameIndex(); if (parentIndex !== -1) { var name = node.name; - if (!name || name.kind !== 124) { + if (!name || name.kind !== 126) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -18141,18 +18553,18 @@ var ts; if (scopeName) { recordScopeNameStart(scopeName); } - else if (node.kind === 193 || - node.kind === 158 || - node.kind === 130 || - node.kind === 129 || + else if (node.kind === 195 || + node.kind === 160 || node.kind === 132 || - node.kind === 133 || - node.kind === 198 || - node.kind === 194 || - node.kind === 197) { + node.kind === 131 || + node.kind === 134 || + node.kind === 135 || + node.kind === 200 || + node.kind === 196 || + node.kind === 199) { if (node.name) { var name = node.name; - scopeName = name.kind === 124 ? ts.getTextOfNode(name) : node.name.text; + scopeName = name.kind === 126 ? ts.getTextOfNode(name) : node.name.text; } recordScopeNameStart(scopeName); } @@ -18232,7 +18644,7 @@ var ts; } function emitNodeWithMap(node) { if (node) { - if (node.kind != 210) { + if (node.kind != 220) { recordEmitNodeStartSpan(node); emitNode(node); recordEmitNodeEndSpan(node); @@ -18436,7 +18848,7 @@ var ts; } for (var i = 0; i < node.templateSpans.length; i++) { var templateSpan = node.templateSpans[i]; - var needsParens = templateSpan.expression.kind !== 157 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; + var needsParens = templateSpan.expression.kind !== 159 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; if (i > 0 || headEmitted) { write(" + "); } @@ -18455,11 +18867,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 153: - case 154: - return parent.expression === template; case 155: + case 156: + return parent.expression === template; case 157: + case 159: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1; @@ -18467,7 +18879,7 @@ var ts; } function comparePrecedenceToBinaryPlus(expression) { switch (expression.kind) { - case 165: + case 167: switch (expression.operatorToken.kind) { case 35: case 36: @@ -18479,7 +18891,7 @@ var ts; default: return -1; } - case 166: + case 168: return -1; default: return 1; @@ -18491,11 +18903,11 @@ var ts; emit(span.literal); } function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 148); + ts.Debug.assert(node.kind !== 150); if (node.kind === 8) { emitLiteral(node); } - else if (node.kind === 124) { + else if (node.kind === 126) { emit(node.expression); } else { @@ -18512,43 +18924,44 @@ var ts; function isNotExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 126: - case 191: - case 148: case 128: - case 127: - case 207: - case 208: - case 209: + case 193: + case 150: case 130: case 129: - case 193: + case 217: + case 218: + case 219: case 132: - case 133: - case 158: - case 194: + case 131: case 195: + case 134: + case 135: + case 160: + case 196: case 197: - case 198: + case 199: case 200: + case 202: return parent.name === node; - case 183: - case 182: - case 201: + case 185: + case 184: + case 208: return false; - case 187: + case 189: return node.parent.label === node; - case 206: + case 216: return node.parent.name === node; } } function emitExpressionIdentifier(node) { - var prefix = resolver.getExpressionNamePrefix(node); - if (prefix) { - write(prefix); - write("."); + var substitution = resolver.getExpressionNameSubstitution(node); + if (substitution) { + write(substitution); + } + else { + writeTextOfNode(currentSourceFile, node); } - writeTextOfNode(currentSourceFile, node); } function emitIdentifier(node) { if (!node.parent) { @@ -18616,11 +19029,11 @@ var ts; function needsParenthesisForPropertyAccess(node) { switch (node.kind) { case 64: - case 149: case 151: - case 152: case 153: - case 157: + case 154: + case 155: + case 159: return false; } return true; @@ -18637,14 +19050,14 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 169) { + if (e.kind === 171) { e = e.expression; emitParenthesized(e, group === 0 && needsParenthesisForPropertyAccess(e)); pos++; } else { var i = pos; - while (i < length && elements[i].kind !== 169) { + while (i < length && elements[i].kind !== 171) { i++; } write("["); @@ -18665,7 +19078,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 169; + return node.kind === 171; } function emitArrayLiteral(node) { var elements = node.elements; @@ -18693,7 +19106,7 @@ var ts; } function createDownlevelObjectLiteralWithComputedProperties(originalObjectLiteral, firstComputedPropertyIndex) { var tempVar = createAndRecordTempVariable(originalObjectLiteral); - var initialObjectLiteral = createSynthesizedNode(150); + var initialObjectLiteral = createSynthesizedNode(152); initialObjectLiteral.properties = originalObjectLiteral.properties.slice(0, firstComputedPropertyIndex); initialObjectLiteral.flags |= 256; var propertyPatches = createBinaryExpression(tempVar, 52, initialObjectLiteral); @@ -18718,20 +19131,19 @@ var ts; } function tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral, property) { switch (property.kind) { - case 207: + case 217: return property.initializer; - case 208: - var prefix = createIdentifier(resolver.getExpressionNamePrefix(property.name)); - return createPropertyAccessExpression(prefix, property.name); - case 130: - return createFunctionExpression(property.parameters, property.body); + case 218: + return createIdentifier(resolver.getExpressionNameSubstitution(property.name)); case 132: - case 133: + return createFunctionExpression(property.parameters, property.body); + case 134: + case 135: var _a = getAllAccessorDeclarations(objectLiteral.properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; if (firstAccessor !== property) { return undefined; } - var propertyDescriptor = createSynthesizedNode(150); + var propertyDescriptor = createSynthesizedNode(152); var descriptorProperties = []; if (getAccessor) { var getProperty = createPropertyAssignment(createIdentifier("get"), createFunctionExpression(getAccessor.parameters, getAccessor.body)); @@ -18754,7 +19166,7 @@ var ts; } } function createParenthesizedExpression(expression) { - var result = createSynthesizedNode(157); + var result = createSynthesizedNode(159); result.expression = expression; return result; } @@ -18769,7 +19181,7 @@ var ts; return result; } function createBinaryExpression(left, operator, right) { - var result = createSynthesizedNode(165); + var result = createSynthesizedNode(167); result.operatorToken = createSynthesizedNode(operator); result.left = left; result.right = right; @@ -18782,7 +19194,7 @@ var ts; else if (memberName.kind === 8 || memberName.kind === 7) { return createElementAccessExpression(expression, memberName); } - else if (memberName.kind === 124) { + else if (memberName.kind === 126) { return createElementAccessExpression(expression, memberName.expression); } else { @@ -18790,25 +19202,25 @@ var ts; } } function createPropertyAssignment(name, initializer) { - var result = createSynthesizedNode(207); + var result = createSynthesizedNode(217); result.name = name; result.initializer = initializer; return result; } function createFunctionExpression(parameters, body) { - var result = createSynthesizedNode(158); + var result = createSynthesizedNode(160); result.parameters = parameters; result.body = body; return result; } function createPropertyAccessExpression(expression, name) { - var result = createSynthesizedNode(151); + var result = createSynthesizedNode(153); result.expression = expression; result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = createSynthesizedNode(152); + var result = createSynthesizedNode(154); result.expression = expression; result.argumentExpression = argumentExpression; return result; @@ -18819,7 +19231,7 @@ var ts; return result; } function createCallExpression(invokedExpression, arguments) { - var result = createSynthesizedNode(153); + var result = createSynthesizedNode(155); result.expression = invokedExpression; result.arguments = arguments; return result; @@ -18830,7 +19242,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 === 124) { + if (properties[i].name.kind === 126) { numInitialNonComputedProperties = i; break; } @@ -18867,7 +19279,7 @@ var ts; } function emitShorthandPropertyAssignment(node) { emit(node.name); - if (languageVersion <= 1 || resolver.getExpressionNamePrefix(node.name)) { + if (languageVersion < 2 || resolver.getExpressionNameSubstitution(node.name)) { write(": "); emitExpressionIdentifier(node.name); } @@ -18877,7 +19289,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 151 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 153 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -18907,10 +19319,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 169; }); + return ts.forEach(elements, function (e) { return e.kind === 171; }); } function skipParentheses(node) { - while (node.kind === 157 || node.kind === 156) { + while (node.kind === 159 || node.kind === 158) { node = node.expression; } return node; @@ -18931,12 +19343,12 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 151) { + if (expr.kind === 153) { target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 152) { + else if (expr.kind === 154) { target = emitCallTarget(expr.expression); write("["); emit(expr.argumentExpression); @@ -18977,7 +19389,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 151 && node.expression.expression.kind === 90; + superCall = node.expression.kind === 153 && node.expression.expression.kind === 90; } if (superCall) { write(".call("); @@ -19009,19 +19421,19 @@ var ts; emit(node.template); } function emitParenExpression(node) { - if (node.expression.kind === 156) { + if (node.expression.kind === 158) { var operand = node.expression.expression; - while (operand.kind == 156) { + while (operand.kind == 158) { operand = operand.expression; } - if (operand.kind !== 163 && - operand.kind !== 162 && - operand.kind !== 161 && - operand.kind !== 160 && + if (operand.kind !== 165 && operand.kind !== 164 && - operand.kind !== 154 && - !(operand.kind === 153 && node.parent.kind === 154) && - !(operand.kind === 158 && node.parent.kind === 153)) { + operand.kind !== 163 && + operand.kind !== 162 && + operand.kind !== 166 && + operand.kind !== 156 && + !(operand.kind === 155 && node.parent.kind === 156) && + !(operand.kind === 160 && node.parent.kind === 155)) { emit(operand); return; } @@ -19047,7 +19459,7 @@ var ts; } function emitPrefixUnaryExpression(node) { write(ts.tokenToString(node.operator)); - if (node.operand.kind === 163) { + if (node.operand.kind === 165) { var operand = node.operand; if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { write(" "); @@ -19064,7 +19476,7 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 && node.operatorToken.kind === 52 && - (node.left.kind === 150 || node.left.kind === 149)) { + (node.left.kind === 152 || node.left.kind === 151)) { emitDestructuring(node); } else { @@ -19113,7 +19525,7 @@ var ts; emit(node.whenFalse); } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 172) { + if (node && node.kind === 174) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -19128,12 +19540,12 @@ var ts; emitToken(14, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 199) { - ts.Debug.assert(node.parent.kind === 198); + if (node.kind === 201) { + ts.Debug.assert(node.parent.kind === 200); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 199) { + if (node.kind === 201) { emitTempDeclarations(true); } decreaseIndent(); @@ -19142,7 +19554,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 172) { + if (node.kind === 174) { write(" "); emit(node); } @@ -19154,7 +19566,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesized(node.expression, node.expression.kind === 159); + emitParenthesized(node.expression, node.expression.kind === 161); write(";"); } function emitIfStatement(node) { @@ -19167,7 +19579,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(75, node.thenStatement.end); - if (node.elseStatement.kind === 176) { + if (node.elseStatement.kind === 178) { write(" "); emit(node.elseStatement); } @@ -19179,7 +19591,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 172) { + if (node.statement.kind === 174) { write(" "); } else { @@ -19199,11 +19611,11 @@ var ts; var endPos = emitToken(81, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer && node.initializer.kind === 192) { + if (node.initializer && node.initializer.kind === 194) { var variableDeclarationList = node.initializer; var declarations = variableDeclarationList.declarations; if (declarations[0] && ts.isLet(declarations[0])) { - emitToken(103, endPos); + emitToken(105, endPos); } else if (declarations[0] && ts.isConst(declarations[0])) { emitToken(69, endPos); @@ -19228,12 +19640,12 @@ var ts; var endPos = emitToken(81, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; if (ts.isLet(decl)) { - emitToken(103, endPos); + emitToken(105, endPos); } else { emitToken(97, endPos); @@ -19245,7 +19657,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 180) { + if (node.kind === 182) { write(" in "); } else { @@ -19256,7 +19668,7 @@ var ts; emitEmbeddedStatement(node.statement); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 183 ? 65 : 70, node.pos); + emitToken(node.kind === 185 ? 65 : 70, node.pos); emitOptional(" ", node.label); write(";"); } @@ -19298,7 +19710,7 @@ var ts; getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 203) { + if (node.kind === 213) { write("case "); emit(node.expression); write(":"); @@ -19353,23 +19765,41 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 198); + } while (node && node.kind !== 200); return node; } + function emitContainingModuleName(node) { + var container = getContainingModule(node); + write(container ? resolver.getGeneratedNameForNode(container) : "exports"); + } function emitModuleMemberName(node) { emitStart(node.name); if (ts.getCombinedNodeFlags(node) & 1) { - var container = getContainingModule(node); - write(container ? resolver.getLocalNameOfContainer(container) : "exports"); + emitContainingModuleName(node); write("."); } emitNode(node.name); emitEnd(node.name); } + function emitExportMemberAssignments(name) { + if (exportSpecifiers && ts.hasProperty(exportSpecifiers, name.text)) { + ts.forEach(exportSpecifiers[name.text], function (specifier) { + writeLine(); + emitStart(specifier.name); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + emitEnd(specifier.name); + write(" = "); + emitNode(name); + write(";"); + }); + } + } function emitDestructuring(root, value) { var emitCount = 0; - var isDeclaration = (root.kind === 191 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 126; - if (root.kind === 165) { + var isDeclaration = (root.kind === 193 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 128; + if (root.kind === 167) { emitAssignmentExpression(root); } else { @@ -19379,7 +19809,7 @@ var ts; if (emitCount++) { write(", "); } - if (name.parent && (name.parent.kind === 191 || name.parent.kind === 148)) { + if (name.parent && (name.parent.kind === 193 || name.parent.kind === 150)) { emitModuleMemberName(name.parent); } else { @@ -19402,17 +19832,17 @@ var ts; function createVoidZero() { var zero = ts.createNode(7); zero.text = "0"; - var result = ts.createNode(162); + var result = ts.createNode(164); result.expression = zero; return result; } function createDefaultValueCheck(value, defaultValue) { value = ensureIdentifier(value); - var equals = ts.createNode(165); + var equals = ts.createNode(167); equals.left = value; equals.operatorToken = ts.createNode(30); equals.right = createVoidZero(); - var cond = ts.createNode(166); + var cond = ts.createNode(168); cond.condition = equals; cond.whenTrue = defaultValue; cond.whenFalse = value; @@ -19424,10 +19854,10 @@ var ts; return node; } function parenthesizeForAccess(expr) { - if (expr.kind === 64 || expr.kind === 151 || expr.kind === 152) { + if (expr.kind === 64 || expr.kind === 153 || expr.kind === 154) { return expr; } - var node = ts.createNode(157); + var node = ts.createNode(159); node.expression = expr; return node; } @@ -19435,13 +19865,13 @@ var ts; if (propName.kind !== 64) { return createElementAccess(object, propName); } - var node = ts.createNode(151); + var node = ts.createNode(153); node.expression = parenthesizeForAccess(object); node.name = propName; return node; } function createElementAccess(object, index) { - var node = ts.createNode(152); + var node = ts.createNode(154); node.expression = parenthesizeForAccess(object); node.argumentExpression = index; return node; @@ -19453,7 +19883,7 @@ var ts; } for (var i = 0; i < properties.length; i++) { var p = properties[i]; - if (p.kind === 207 || p.kind === 208) { + if (p.kind === 217 || p.kind === 218) { var propName = (p.name); emitDestructuringAssignment(p.initializer || propName, createPropertyAccess(value, propName)); } @@ -19466,8 +19896,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 170) { - if (e.kind !== 169) { + if (e.kind !== 172) { + if (e.kind !== 171) { emitDestructuringAssignment(e, createElementAccess(value, createNumericLiteral(i))); } else { @@ -19481,14 +19911,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 165 && target.operatorToken.kind === 52) { + if (target.kind === 167 && target.operatorToken.kind === 52) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 150) { + if (target.kind === 152) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 149) { + else if (target.kind === 151) { emitArrayLiteralAssignment(target, value); } else { @@ -19498,18 +19928,18 @@ var ts; function emitAssignmentExpression(root) { var target = root.left; var value = root.right; - if (root.parent.kind === 175) { + if (root.parent.kind === 177) { emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 157) { + if (root.parent.kind !== 159) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 157) { + if (root.parent.kind !== 159) { write(")"); } } @@ -19529,11 +19959,11 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 146) { + if (pattern.kind === 148) { var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccess(value, propName)); } - else if (element.kind !== 170) { + else if (element.kind !== 172) { if (!element.dotDotDotToken) { emitBindingElement(element, createElementAccess(value, createNumericLiteral(i))); } @@ -19567,6 +19997,15 @@ var ts; emitOptional(" = ", node.initializer); } } + function emitExportVariableAssignments(node) { + var name = node.name; + if (name.kind === 64) { + emitExportMemberAssignments(name); + } + else if (ts.isBindingPattern(name)) { + ts.forEach(name.elements, emitExportVariableAssignments); + } + } function emitVariableStatement(node) { if (!(node.flags & 1)) { if (ts.isLet(node.declarationList)) { @@ -19581,6 +20020,9 @@ var ts; } emitCommaList(node.declarationList.declarations); write(";"); + if (languageVersion < 2 && node.parent === currentSourceFile) { + ts.forEach(node.declarationList.declarations, emitExportVariableAssignments); + } } function emitParameter(node) { if (languageVersion < 2) { @@ -19672,28 +20114,31 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 132 ? "get " : "set "); + write(node.kind === 134 ? "get " : "set "); emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 159 && languageVersion >= 2; + return node.kind === 161 && languageVersion >= 2; } function emitFunctionDeclaration(node) { if (ts.nodeIsMissing(node.body)) { return emitPinnedOrTripleSlashComments(node); } - if (node.kind !== 130 && node.kind !== 129) { + if (node.kind !== 132 && node.kind !== 131) { emitLeadingComments(node); } if (!shouldEmitAsArrowFunction(node)) { write("function "); } - if (node.kind === 193 || (node.kind === 158 && node.name)) { + if (node.kind === 195 || (node.kind === 160 && node.name)) { emit(node.name); } emitSignatureAndBody(node); - if (node.kind !== 130 && node.kind !== 129) { + if (languageVersion < 2 && node.kind === 195 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + if (node.kind !== 132 && node.kind !== 131) { emitTrailingComments(node); } } @@ -19737,10 +20182,10 @@ var ts; else { emitSignatureParameters(node); } - if (isSingleLineEmptyBlock(node.body) || !node.body) { + if (!node.body) { write(" { }"); } - else if (node.body.kind === 172) { + else if (node.body.kind === 174) { emitBlockFunctionBody(node, node.body); } else { @@ -19765,6 +20210,14 @@ var ts; emitRestParameter(node); } function emitExpressionFunctionBody(node, body) { + if (languageVersion < 2) { + emitDownLevelExpressionFunctionBody(node, body); + return; + } + write(" "); + emit(body); + } + function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); scopeEmitStart(node); increaseIndent(); @@ -19801,6 +20254,36 @@ var ts; scopeEmitEnd(); } function emitBlockFunctionBody(node, body) { + if (body.statements.length === 0 && !anyParameterHasBindingPatternOrInitializer(node)) { + emitFunctionBodyWithNoStatements(node, body); + } + else { + emitFunctionBodyWithStatements(node, body); + } + } + function anyParameterHasBindingPatternOrInitializer(func) { + return ts.forEach(func.parameters, hasBindingPatternOrInitializer); + } + function hasBindingPatternOrInitializer(parameter) { + return parameter.initializer || ts.isBindingPattern(parameter.name); + } + function emitFunctionBodyWithNoStatements(node, body) { + var singleLine = isSingleLineEmptyBlock(node.body); + write(" {"); + if (singleLine) { + write(" "); + } + else { + increaseIndent(); + writeLine(); + } + emitLeadingCommentsOfPosition(body.statements.end); + if (!singleLine) { + decreaseIndent(); + } + emitToken(15, body.statements.end); + } + function emitFunctionBodyWithStatements(node, body) { write(" {"); scopeEmitStart(node); var outPos = writer.getTextPos(); @@ -19833,9 +20316,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 175) { + if (statement && statement.kind === 177) { var expr = statement.expression; - if (expr && expr.kind === 153) { + if (expr && expr.kind === 155) { var func = expr.expression; if (func && func.kind === 90) { return statement; @@ -19866,7 +20349,7 @@ var ts; emitNode(memberName); write("]"); } - else if (memberName.kind === 124) { + else if (memberName.kind === 126) { emitComputedPropertyName(memberName); } else { @@ -19876,7 +20359,7 @@ var ts; } function emitMemberAssignments(node, staticFlag) { ts.forEach(node.members, function (member) { - if (member.kind === 128 && (member.flags & 128) === staticFlag && member.initializer) { + if (member.kind === 130 && (member.flags & 128) === staticFlag && member.initializer) { writeLine(); emitLeadingComments(member); emitStart(member); @@ -19899,7 +20382,7 @@ var ts; } function emitMemberFunctions(node) { ts.forEach(node.members, function (member) { - if (member.kind === 130 || node.kind === 129) { + if (member.kind === 132 || node.kind === 131) { if (!member.body) { return emitPinnedOrTripleSlashComments(member); } @@ -19921,7 +20404,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 132 || member.kind === 133) { + else if (member.kind === 134 || member.kind === 135) { var accessors = getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -20021,6 +20504,9 @@ var ts; emitEnd(node); write(";"); } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } function emitConstructorOfClass() { var saveTempCount = tempCount; var saveTempVariables = tempVariables; @@ -20029,7 +20515,7 @@ var ts; tempVariables = undefined; tempParameters = undefined; ts.forEach(node.members, function (member) { - if (member.kind === 131 && !member.body) { + if (member.kind === 133 && !member.body) { emitPinnedOrTripleSlashComments(member); } }); @@ -20114,7 +20600,7 @@ var ts; emitStart(node); write("(function ("); emitStart(node.name); - write(resolver.getLocalNameOfContainer(node)); + write(resolver.getGeneratedNameForNode(node)); emitEnd(node.name); write(") {"); increaseIndent(); @@ -20140,13 +20626,16 @@ var ts; emitEnd(node); write(";"); } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } } function emitEnumMember(node) { var enumParent = node.parent; emitStart(node); - write(resolver.getLocalNameOfContainer(enumParent)); + write(resolver.getGeneratedNameForNode(enumParent)); write("["); - write(resolver.getLocalNameOfContainer(enumParent)); + write(resolver.getGeneratedNameForNode(enumParent)); write("["); emitExpressionForPropertyName(node.name); write("] = "); @@ -20172,7 +20661,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 198) { + if (moduleDeclaration.body.kind === 200) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -20194,10 +20683,10 @@ var ts; emitStart(node); write("(function ("); emitStart(node.name); - write(resolver.getLocalNameOfContainer(node)); + write(resolver.getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 199) { + if (node.body.kind === 201) { var saveTempCount = tempCount; var saveTempVariables = tempVariables; tempCount = 0; @@ -20229,63 +20718,194 @@ var ts; emitModuleMemberName(node); write(" = {}));"); emitEnd(node); + if (languageVersion < 2 && node.name.kind === 64 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + } + function emitRequire(moduleName) { + if (moduleName.kind === 8) { + write("require("); + emitStart(moduleName); + emitLiteral(moduleName); + emitEnd(moduleName); + emitToken(17, moduleName.end); + write(";"); + } + else { + write("require();"); + } } function emitImportDeclaration(node) { - var emitImportDeclaration = resolver.isReferencedImportDeclaration(node); - if (!emitImportDeclaration) { - emitImportDeclaration = !ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportWithEntityName(node); - } - if (emitImportDeclaration) { - if (ts.isExternalModuleImportDeclaration(node) && node.parent.kind === 210 && compilerOptions.module === 2) { - if (node.flags & 1) { - writeLine(); - emitLeadingComments(node); - emitStart(node); - emitModuleMemberName(node); - write(" = "); - emit(node.name); - write(";"); - emitEnd(node); - emitTrailingComments(node); - } - } - else { - writeLine(); + var info = getExternalImportInfo(node); + if (info) { + var declarationNode = info.declarationNode; + var namedImports = info.namedImports; + if (compilerOptions.module !== 2) { emitLeadingComments(node); emitStart(node); - if (!(node.flags & 1)) + var moduleName = ts.getExternalModuleName(node); + if (declarationNode) { + if (!(declarationNode.flags & 1)) + write("var "); + emitModuleMemberName(declarationNode); + write(" = "); + emitRequire(moduleName); + } + else if (namedImports) { write("var "); - emitModuleMemberName(node); - write(" = "); - if (ts.isInternalModuleImportDeclaration(node)) { - emit(node.moduleReference); + write(resolver.getGeneratedNameForNode(node)); + write(" = "); + emitRequire(moduleName); } else { - var literal = ts.getExternalModuleImportDeclarationExpression(node); - write("require("); - emitStart(literal); - emitLiteral(literal); - emitEnd(literal); - emitToken(17, literal.end); + emitRequire(moduleName); } - write(";"); emitEnd(node); emitTrailingComments(node); } + else { + if (declarationNode) { + if (declarationNode.flags & 1) { + emitModuleMemberName(declarationNode); + write(" = "); + emit(declarationNode.name); + write(";"); + } + } + } } } - function getExternalImportDeclarations(node) { - var result = []; - ts.forEach(node.statements, function (statement) { - if (ts.isExternalModuleImportDeclaration(statement) && resolver.isReferencedImportDeclaration(statement)) { - result.push(statement); + function emitImportEqualsDeclaration(node) { + if (ts.isExternalModuleImportEqualsDeclaration(node)) { + emitImportDeclaration(node); + return; + } + if (resolver.isReferencedImportDeclaration(node) || + (!ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node))) { + emitLeadingComments(node); + emitStart(node); + if (!(node.flags & 1)) + write("var "); + emitModuleMemberName(node); + write(" = "); + emit(node.moduleReference); + write(";"); + emitEnd(node); + emitTrailingComments(node); + } + } + function emitExportDeclaration(node) { + if (node.moduleSpecifier) { + emitStart(node); + var generatedName = resolver.getGeneratedNameForNode(node); + if (compilerOptions.module !== 2) { + write("var "); + write(generatedName); + write(" = "); + emitRequire(ts.getExternalModuleName(node)); + } + if (node.exportClause) { + ts.forEach(node.exportClause.elements, function (specifier) { + writeLine(); + emitStart(specifier); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + write(" = "); + write(generatedName); + write("."); + emitNode(specifier.propertyName || specifier.name); + write(";"); + emitEnd(specifier); + }); + } + else { + var tempName = createTempVariable(node).text; + writeLine(); + write("for (var " + tempName + " in " + generatedName + ") if (!"); + emitContainingModuleName(node); + write(".hasOwnProperty(" + tempName + ")) "); + emitContainingModuleName(node); + write("[" + tempName + "] = " + generatedName + "[" + tempName + "];"); + } + emitEnd(node); + } + } + function createExternalImportInfo(node) { + if (node.kind === 202) { + if (node.moduleReference.kind === 212) { + return { + rootNode: node, + declarationNode: node + }; + } + } + else if (node.kind === 203) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + return { + rootNode: node, + declarationNode: importClause + }; + } + if (importClause.namedBindings.kind === 205) { + return { + rootNode: node, + declarationNode: importClause.namedBindings + }; + } + return { + rootNode: node, + namedImports: importClause.namedBindings, + localName: resolver.getGeneratedNameForNode(node) + }; + } + return { + rootNode: node + }; + } + else if (node.kind === 209) { + if (node.moduleSpecifier) { + return { + rootNode: node + }; + } + } + } + function createExternalModuleInfo(sourceFile) { + externalImports = []; + exportSpecifiers = {}; + ts.forEach(sourceFile.statements, function (node) { + if (node.kind === 209 && !node.moduleSpecifier) { + ts.forEach(node.exportClause.elements, function (specifier) { + var name = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier); + }); + } + else { + var info = createExternalImportInfo(node); + if (info) { + if ((!info.declarationNode && !info.namedImports) || resolver.isReferencedImportDeclaration(node)) { + externalImports.push(info); + } + } } }); - return result; + } + function getExternalImportInfo(node) { + if (externalImports) { + for (var i = 0; i < externalImports.length; i++) { + var info = externalImports[i]; + if (info.rootNode === node) { + return info; + } + } + } } function getFirstExportAssignment(sourceFile) { return ts.forEach(sourceFile.statements, function (node) { - if (node.kind === 201) { + if (node.kind === 208) { return node; } }); @@ -20304,7 +20924,6 @@ var ts; }); } function emitAMDModule(node, startIndex) { - var imports = getExternalImportDeclarations(node); writeLine(); write("define("); sortAMDModules(node.amdDependencies); @@ -20312,9 +20931,15 @@ var ts; write("\"" + node.amdModuleName + "\", "); } write("[\"require\", \"exports\""); - ts.forEach(imports, function (imp) { + ts.forEach(externalImports, function (info) { write(", "); - emitLiteral(ts.getExternalModuleImportDeclarationExpression(imp)); + var moduleName = ts.getExternalModuleName(info.rootNode); + if (moduleName.kind === 8) { + emitLiteral(moduleName); + } + else { + write("\"\""); + } }); ts.forEach(node.amdDependencies, function (amdDependency) { var text = "\"" + amdDependency.path + "\""; @@ -20322,9 +20947,14 @@ var ts; write(text); }); write("], function (require, exports"); - ts.forEach(imports, function (imp) { + ts.forEach(externalImports, function (info) { write(", "); - emit(imp.name); + if (info.declarationNode) { + emit(info.declarationNode.name); + } + else { + write(resolver.getGeneratedNameForNode(info.rootNode)); + } }); ts.forEach(node.amdDependencies, function (amdDependency) { if (amdDependency.name) { @@ -20407,6 +21037,7 @@ var ts; extendsEmitted = true; } if (ts.isExternalModule(node)) { + createExternalModuleInfo(node); if (compilerOptions.module === 2) { emitAMDModule(node, startIndex); } @@ -20415,6 +21046,8 @@ var ts; } } else { + externalImports = undefined; + exportSpecifiers = undefined; emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); emitTempDeclarations(true); @@ -20439,15 +21072,16 @@ var ts; } function shouldEmitLeadingAndTrailingComments(node) { switch (node.kind) { - case 195: - case 193: - case 200: - case 196: - case 201: - return false; - case 198: - return shouldEmitModuleDeclaration(node); case 197: + case 195: + case 203: + case 202: + case 198: + case 208: + return false; + case 200: + return shouldEmitModuleDeclaration(node); + case 199: return shouldEmitEnumDeclaration(node); } return true; @@ -20456,13 +21090,13 @@ var ts; switch (node.kind) { case 64: return emitIdentifier(node); - case 126: + case 128: return emitParameter(node); - case 130: - case 129: - return emitMethod(node); case 132: - case 133: + case 131: + return emitMethod(node); + case 134: + case 135: return emitAccessor(node); case 92: return emitThis(node); @@ -20482,121 +21116,125 @@ var ts; case 12: case 13: return emitLiteral(node); - case 167: - return emitTemplateExpression(node); - case 171: - return emitTemplateSpan(node); - case 123: - return emitQualifiedName(node); - case 146: - return emitObjectBindingPattern(node); - case 147: - return emitArrayBindingPattern(node); - case 148: - return emitBindingElement(node); - case 149: - return emitArrayLiteral(node); - case 150: - return emitObjectLiteral(node); - case 207: - return emitPropertyAssignment(node); - case 208: - return emitShorthandPropertyAssignment(node); - case 124: - return emitComputedPropertyName(node); - case 151: - return emitPropertyAccess(node); - case 152: - return emitIndexedAccess(node); - case 153: - return emitCallExpression(node); - case 154: - return emitNewExpression(node); - case 155: - return emitTaggedTemplateExpression(node); - case 156: - return emit(node.expression); - case 157: - return emitParenExpression(node); - case 193: - case 158: - case 159: - return emitFunctionDeclaration(node); - case 160: - return emitDeleteExpression(node); - case 161: - return emitTypeOfExpression(node); - case 162: - return emitVoidExpression(node); - case 163: - return emitPrefixUnaryExpression(node); - case 164: - return emitPostfixUnaryExpression(node); - case 165: - return emitBinaryExpression(node); - case 166: - return emitConditionalExpression(node); case 169: - return emitSpreadElementExpression(node); - case 170: - return; - case 172: - case 199: - return emitBlock(node); + return emitTemplateExpression(node); case 173: - return emitVariableStatement(node); - case 174: - return write(";"); - case 175: - return emitExpressionStatement(node); - case 176: - return emitIfStatement(node); - case 177: - return emitDoStatement(node); - case 178: - return emitWhileStatement(node); - case 179: - return emitForStatement(node); - case 181: - case 180: - return emitForInOrForOfStatement(node); - case 182: - case 183: - return emitBreakOrContinueStatement(node); - case 184: - return emitReturnStatement(node); - case 185: - return emitWithStatement(node); - case 186: - return emitSwitchStatement(node); - case 203: - case 204: - return emitCaseOrDefaultClause(node); - case 187: - return emitLabelledStatement(node); - case 188: - return emitThrowStatement(node); - case 189: - return emitTryStatement(node); - case 206: - return emitCatchClause(node); - case 190: - return emitDebuggerStatement(node); - case 191: - return emitVariableDeclaration(node); - case 194: - return emitClassDeclaration(node); + return emitTemplateSpan(node); + case 125: + return emitQualifiedName(node); + case 148: + return emitObjectBindingPattern(node); + case 149: + return emitArrayBindingPattern(node); + case 150: + return emitBindingElement(node); + case 151: + return emitArrayLiteral(node); + case 152: + return emitObjectLiteral(node); + case 217: + return emitPropertyAssignment(node); + case 218: + return emitShorthandPropertyAssignment(node); + case 126: + return emitComputedPropertyName(node); + case 153: + return emitPropertyAccess(node); + case 154: + return emitIndexedAccess(node); + case 155: + return emitCallExpression(node); + case 156: + return emitNewExpression(node); + case 157: + return emitTaggedTemplateExpression(node); + case 158: + return emit(node.expression); + case 159: + return emitParenExpression(node); case 195: - return emitInterfaceDeclaration(node); + case 160: + case 161: + return emitFunctionDeclaration(node); + case 162: + return emitDeleteExpression(node); + case 163: + return emitTypeOfExpression(node); + case 164: + return emitVoidExpression(node); + case 165: + return emitPrefixUnaryExpression(node); + case 166: + return emitPostfixUnaryExpression(node); + case 167: + return emitBinaryExpression(node); + case 168: + return emitConditionalExpression(node); + case 171: + return emitSpreadElementExpression(node); + case 172: + return; + case 174: + case 201: + return emitBlock(node); + case 175: + return emitVariableStatement(node); + case 176: + return write(";"); + case 177: + return emitExpressionStatement(node); + case 178: + return emitIfStatement(node); + case 179: + return emitDoStatement(node); + case 180: + return emitWhileStatement(node); + case 181: + return emitForStatement(node); + case 183: + case 182: + return emitForInOrForOfStatement(node); + case 184: + case 185: + return emitBreakOrContinueStatement(node); + case 186: + return emitReturnStatement(node); + case 187: + return emitWithStatement(node); + case 188: + return emitSwitchStatement(node); + case 213: + case 214: + return emitCaseOrDefaultClause(node); + case 189: + return emitLabelledStatement(node); + case 190: + return emitThrowStatement(node); + case 191: + return emitTryStatement(node); + case 216: + return emitCatchClause(node); + case 192: + return emitDebuggerStatement(node); + case 193: + return emitVariableDeclaration(node); + case 196: + return emitClassDeclaration(node); case 197: + return emitInterfaceDeclaration(node); + case 199: return emitEnumDeclaration(node); - case 209: + case 219: return emitEnumMember(node); - case 198: - return emitModuleDeclaration(node); case 200: + return emitModuleDeclaration(node); + case 203: return emitImportDeclaration(node); - case 210: + case 202: + return emitImportEqualsDeclaration(node); + case 209: + return emitExportDeclaration(node); + case 220: return emitSourceFile(node); } } @@ -20615,7 +21253,7 @@ var ts; } function getLeadingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 210 || node.pos !== node.parent.pos) { + if (node.parent.kind === 220 || node.pos !== node.parent.pos) { var leadingComments; if (hasDetachedComments(node.pos)) { leadingComments = getLeadingCommentsWithoutDetachedComments(); @@ -20634,7 +21272,7 @@ var ts; } function emitTrailingDeclarationComments(node) { if (node.parent) { - if (node.parent.kind === 210 || node.end !== node.parent.end) { + if (node.parent.kind === 220 || node.end !== node.parent.end) { var trailingComments = ts.getTrailingCommentRanges(currentSourceFile.text, node.end); emitComments(currentSourceFile, writer, trailingComments, false, newLine, writeComment); } @@ -21014,30 +21652,31 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (ts.isExternalModuleImportDeclaration(node) && - ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - var nameLiteral = ts.getExternalModuleImportDeclarationExpression(node); - var moduleName = nameLiteral.text; - if (moduleName) { - var searchPath = basePath; - while (true) { - var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleName)); - if (findModuleSourceFile(searchName + ".ts", nameLiteral) || findModuleSourceFile(searchName + ".d.ts", nameLiteral)) { - break; + if (node.kind === 203 || node.kind === 202 || node.kind === 209) { + var moduleNameExpr = ts.getExternalModuleName(node); + if (moduleNameExpr && moduleNameExpr.kind === 8) { + var moduleNameText = moduleNameExpr.text; + if (moduleNameText) { + var searchPath = basePath; + while (true) { + var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleNameText)); + if (findModuleSourceFile(searchName + ".ts", moduleNameExpr) || findModuleSourceFile(searchName + ".d.ts", moduleNameExpr)) { + break; + } + var parentPath = ts.getDirectoryPath(searchPath); + if (parentPath === searchPath) { + break; + } + searchPath = parentPath; } - var parentPath = ts.getDirectoryPath(searchPath); - if (parentPath === searchPath) { - break; - } - searchPath = parentPath; } } } - else if (node.kind === 198 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { + else if (node.kind === 200 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { ts.forEachChild(node.body, function (node) { - if (ts.isExternalModuleImportDeclaration(node) && - ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - var nameLiteral = ts.getExternalModuleImportDeclarationExpression(node); + if (ts.isExternalModuleImportEqualsDeclaration(node) && + ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8) { + var nameLiteral = ts.getExternalModuleImportEqualsDeclarationExpression(node); var moduleName = nameLiteral.text; if (moduleName) { var searchName = ts.normalizePath(ts.combinePaths(basePath, moduleName)); @@ -21474,14 +22113,7 @@ var ts; } } function autoCollapse(node) { - switch (node.kind) { - case 199: - case 194: - case 195: - case 197: - return false; - } - return true; + return ts.isFunctionBlock(node) && node.parent.kind !== 161; } var depth = 0; var maxDepth = 20; @@ -21490,23 +22122,23 @@ var ts; return; } switch (n.kind) { - case 172: + case 174: if (!ts.isFunctionBlock(n)) { var parent = n.parent; var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); - if (parent.kind === 177 || - parent.kind === 180 || + if (parent.kind === 179 || + parent.kind === 182 || + parent.kind === 183 || parent.kind === 181 || - parent.kind === 179 || - parent.kind === 176 || parent.kind === 178 || - parent.kind === 185 || - parent.kind === 206) { + parent.kind === 180 || + parent.kind === 187 || + parent.kind === 216) { addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n)); break; } - if (parent.kind === 189) { + if (parent.kind === 191) { var tryStatement = parent; if (tryStatement.tryBlock === n) { addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n)); @@ -21529,21 +22161,21 @@ var ts; }); break; } - case 199: + case 201: var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); break; - case 194: - case 195: + case 196: case 197: - case 150: - case 186: + case 199: + case 152: + case 188: var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); break; - case 149: + case 151: var openBracket = ts.findChildOfKind(n, 18, sourceFile); var closeBracket = ts.findChildOfKind(n, 19, sourceFile); addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); @@ -21563,27 +22195,33 @@ var ts; (function (ts) { var NavigateTo; (function (NavigateTo) { - var MatchKind; - (function (MatchKind) { - MatchKind[MatchKind["none"] = 0] = "none"; - MatchKind[MatchKind["exact"] = 1] = "exact"; - MatchKind[MatchKind["substring"] = 2] = "substring"; - MatchKind[MatchKind["prefix"] = 3] = "prefix"; - })(MatchKind || (MatchKind = {})); function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) { - var terms = searchValue.split(" "); - var searchTerms = ts.map(terms, function (t) { return ({ caseSensitive: hasAnyUpperCaseCharacter(t), term: t }); }); + var patternMatcher = ts.createPatternMatcher(searchValue); var rawItems = []; ts.forEach(program.getSourceFiles(), function (sourceFile) { cancellationToken.throwIfCancellationRequested(); - var fileName = sourceFile.fileName; var declarations = sourceFile.getNamedDeclarations(); for (var i = 0, n = declarations.length; i < n; i++) { var declaration = declarations[i]; - var name = declaration.name.text; - var matchKind = getMatchKind(searchTerms, name); - if (matchKind !== 0) { - rawItems.push({ name: name, fileName: fileName, matchKind: matchKind, declaration: declaration }); + var name = getDeclarationName(declaration); + if (name !== undefined) { + var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name); + if (!matches) { + continue; + } + if (patternMatcher.patternContainsDots) { + var containers = getContainers(declaration); + if (!containers) { + return undefined; + } + matches = patternMatcher.getMatches(containers, name); + if (!matches) { + continue; + } + } + var fileName = sourceFile.fileName; + var matchKind = bestMatchKind(matches); + rawItems.push({ name: name, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); } } }); @@ -21593,6 +22231,96 @@ var ts; } var items = ts.map(rawItems, createNavigateToItem); return items; + function allMatchesAreCaseSensitive(matches) { + ts.Debug.assert(matches.length > 0); + for (var i = 0, n = matches.length; i < n; i++) { + if (!matches[i].isCaseSensitive) { + return false; + } + } + return true; + } + function getDeclarationName(declaration) { + var result = getTextOfIdentifierOrLiteral(declaration.name); + if (result !== undefined) { + return result; + } + if (declaration.name.kind === 126) { + var expr = declaration.name.expression; + if (expr.kind === 153) { + return expr.name.text; + } + return getTextOfIdentifierOrLiteral(expr); + } + return undefined; + } + function getTextOfIdentifierOrLiteral(node) { + if (node.kind === 64 || + node.kind === 8 || + node.kind === 7) { + return node.text; + } + return undefined; + } + function tryAddSingleDeclarationName(declaration, containers) { + if (declaration && declaration.name) { + var text = getTextOfIdentifierOrLiteral(declaration.name); + if (text !== undefined) { + containers.unshift(text); + } + else if (declaration.name.kind === 126) { + return tryAddComputedPropertyName(declaration.name.expression, containers, true); + } + else { + return false; + } + } + return true; + } + function tryAddComputedPropertyName(expression, containers, includeLastPortion) { + var text = getTextOfIdentifierOrLiteral(expression); + if (text !== undefined) { + if (includeLastPortion) { + containers.unshift(text); + } + return true; + } + if (expression.kind === 153) { + var propertyAccess = expression; + if (includeLastPortion) { + containers.unshift(propertyAccess.name.text); + } + return tryAddComputedPropertyName(propertyAccess.expression, containers, true); + } + return false; + } + function getContainers(declaration) { + var containers = []; + if (declaration.name.kind === 126) { + if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { + return undefined; + } + } + declaration = ts.getContainerNode(declaration); + while (declaration) { + if (!tryAddSingleDeclarationName(declaration, containers)) { + return undefined; + } + declaration = ts.getContainerNode(declaration); + } + return containers; + } + function bestMatchKind(matches) { + ts.Debug.assert(matches.length > 0); + var bestMatchKind = 3; + for (var i = 0, n = matches.length; i < n; i++) { + var kind = matches[i].kind; + if (kind < bestMatchKind) { + bestMatchKind = kind; + } + } + return bestMatchKind; + } var baseSensitivity = { sensitivity: "base" }; function compareNavigateToItems(i1, i2) { return i1.matchKind - i2.matchKind || @@ -21606,44 +22334,14 @@ var ts; name: rawItem.name, kind: ts.getNodeKind(declaration), kindModifiers: ts.getNodeModifiers(declaration), - matchKind: MatchKind[rawItem.matchKind], + matchKind: ts.PatternMatchKind[rawItem.matchKind], + isCaseSensitive: rawItem.isCaseSensitive, fileName: rawItem.fileName, textSpan: ts.createTextSpanFromBounds(declaration.getStart(), declaration.getEnd()), containerName: container && container.name ? container.name.text : "", containerKind: container && container.name ? ts.getNodeKind(container) : "" }; } - function hasAnyUpperCaseCharacter(s) { - for (var i = 0, n = s.length; i < n; i++) { - var c = s.charCodeAt(i); - if ((65 <= c && c <= 90) || - (c >= 127 && s.charAt(i).toLocaleLowerCase() !== s.charAt(i))) { - return true; - } - } - return false; - } - function getMatchKind(searchTerms, name) { - var matchKind = 0; - if (name) { - for (var j = 0, n = searchTerms.length; j < n; j++) { - var searchTerm = searchTerms[j]; - var nameToSearch = searchTerm.caseSensitive ? name : name.toLocaleLowerCase(); - var index = nameToSearch.indexOf(searchTerm.term); - if (index < 0) { - return 0; - } - var termKind = 2; - if (index === 0) { - termKind = name.length === searchTerm.term.length ? 1 : 3; - } - if (matchKind === 0 || termKind < matchKind) { - matchKind = termKind; - } - } - } - return matchKind; - } } NavigateTo.getNavigateToItems = getNavigateToItems; })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {})); @@ -21660,14 +22358,14 @@ var ts; var current = node.parent; while (current) { switch (current.kind) { - case 198: + case 200: do { current = current.parent; - } while (current.kind === 198); - case 194: + } while (current.kind === 200); + case 196: + case 199: case 197: case 195: - case 193: indent++; } current = current.parent; @@ -21678,24 +22376,24 @@ var ts; var childNodes = []; function visit(node) { switch (node.kind) { - case 173: + case 175: ts.forEach(node.declarationList.declarations, visit); break; - case 146: - case 147: + case 148: + case 149: ts.forEach(node.elements, visit); break; - case 148: - case 191: + case 150: + case 193: if (ts.isBindingPattern(node.name)) { visit(node.name); break; } - case 194: + case 196: + case 199: case 197: + case 200: case 195: - case 198: - case 193: childNodes.push(node); } } @@ -21729,17 +22427,17 @@ var ts; for (var i = 0, n = nodes.length; i < n; i++) { var node = nodes[i]; switch (node.kind) { - case 194: + case 196: + case 199: case 197: - case 195: topLevelNodes.push(node); break; - case 198: + case 200: var moduleDeclaration = node; topLevelNodes.push(node); addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); break; - case 193: + case 195: var functionDeclaration = node; if (isTopLevelFunctionDeclaration(functionDeclaration)) { topLevelNodes.push(node); @@ -21750,9 +22448,9 @@ var ts; } } function isTopLevelFunctionDeclaration(functionDeclaration) { - if (functionDeclaration.kind === 193) { - if (functionDeclaration.body && functionDeclaration.body.kind === 172) { - if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 193 && !isEmpty(s.name.text); })) { + if (functionDeclaration.kind === 195) { + if (functionDeclaration.body && functionDeclaration.body.kind === 174) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 195 && !isEmpty(s.name.text); })) { return true; } if (!ts.isFunctionBlock(functionDeclaration.parent)) { @@ -21805,7 +22503,7 @@ var ts; } function createChildItem(node) { switch (node.kind) { - case 126: + case 128: if (ts.isBindingPattern(node.name)) { break; } @@ -21813,34 +22511,34 @@ var ts; return undefined; } return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 132: + case 131: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); + case 134: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); + case 135: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); + case 138: + return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); + case 219: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 136: + return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); + case 137: + return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); case 130: case 129: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); - case 132: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); - case 133: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); - case 136: - return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); - case 209: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 134: - return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); - case 135: - return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); - case 128: - case 127: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 193: + case 195: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); - case 191: - case 148: + case 193: + case 150: var variableDeclarationNode; var name; - if (node.kind === 148) { + if (node.kind === 150) { name = node.name; variableDeclarationNode = node; - while (variableDeclarationNode && variableDeclarationNode.kind !== 191) { + while (variableDeclarationNode && variableDeclarationNode.kind !== 193) { variableDeclarationNode = variableDeclarationNode.parent; } ts.Debug.assert(variableDeclarationNode !== undefined); @@ -21859,7 +22557,7 @@ var ts; else { return createItem(node, getTextOfNode(name), ts.ScriptElementKind.variableElement); } - case 131: + case 133: return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); } return undefined; @@ -21889,17 +22587,17 @@ var ts; } function createTopLevelItem(node) { switch (node.kind) { - case 210: + case 220: return createSourceFileItem(node); - case 194: + case 196: return createClassItem(node); - case 197: + case 199: return createEnumItem(node); - case 195: + case 197: return createIterfaceItem(node); - case 198: + case 200: return createModuleItem(node); - case 193: + case 195: return createFunctionItem(node); } return undefined; @@ -21909,7 +22607,7 @@ var ts; } var result = []; result.push(moduleDeclaration.name.text); - while (moduleDeclaration.body && moduleDeclaration.body.kind === 198) { + while (moduleDeclaration.body && moduleDeclaration.body.kind === 200) { moduleDeclaration = moduleDeclaration.body; result.push(moduleDeclaration.name.text); } @@ -21921,7 +22619,7 @@ var ts; return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } function createFunctionItem(node) { - if (node.name && node.body && node.body.kind === 172) { + if (node.name && node.body && node.body.kind === 174) { var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); return getNavigationBarItem(node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } @@ -21940,11 +22638,11 @@ var ts; var childItems; if (node.members) { var constructor = ts.forEach(node.members, function (member) { - return member.kind === 131 && member; + return member.kind === 133 && member; }); var nodes = removeDynamicallyNamedProperties(node); if (constructor) { - nodes.push.apply(nodes, constructor.parameters); + nodes.push.apply(nodes, ts.filter(constructor.parameters, function (p) { return !ts.isBindingPattern(p.name); })); } var childItems = getItemsWorker(sortNodes(nodes), createChildItem); } @@ -21960,19 +22658,19 @@ var ts; } } function removeComputedProperties(node) { - return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 124; }); + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 126; }); } function removeDynamicallyNamedProperties(node) { return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); } function getInnermostModule(node) { - while (node.body.kind === 198) { + while (node.body.kind === 200) { node = node.body; } return node; } function getNodeSpan(node) { - return node.kind === 210 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); + return node.kind === 220 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); } function getTextOfNode(node) { return ts.getTextOfNodeFromSourceText(sourceFile.text, node); @@ -21984,10 +22682,10 @@ var ts; var ts; (function (ts) { (function (PatternMatchKind) { - PatternMatchKind[PatternMatchKind["Exact"] = 0] = "Exact"; - PatternMatchKind[PatternMatchKind["Prefix"] = 1] = "Prefix"; - PatternMatchKind[PatternMatchKind["Substring"] = 2] = "Substring"; - PatternMatchKind[PatternMatchKind["CamelCase"] = 3] = "CamelCase"; + PatternMatchKind[PatternMatchKind["exact"] = 0] = "exact"; + PatternMatchKind[PatternMatchKind["prefix"] = 1] = "prefix"; + PatternMatchKind[PatternMatchKind["substring"] = 2] = "substring"; + PatternMatchKind[PatternMatchKind["camelCase"] = 3] = "camelCase"; })(ts.PatternMatchKind || (ts.PatternMatchKind = {})); var PatternMatchKind = ts.PatternMatchKind; function createPatternMatch(kind, punctuationStripped, isCaseSensitive, camelCaseWeight) { @@ -22018,7 +22716,7 @@ var ts; } return matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments)); } - function getMatches(candidate, dottedContainer) { + function getMatches(candidateContainers, candidate) { if (skipMatch(candidate)) { return undefined; } @@ -22026,15 +22724,14 @@ var ts; if (!candidateMatch) { return undefined; } - dottedContainer = dottedContainer || ""; - var containerParts = dottedContainer.split("."); - if (dotSeparatedSegments.length - 1 > containerParts.length) { - return null; + candidateContainers = candidateContainers || []; + if (dotSeparatedSegments.length - 1 > candidateContainers.length) { + return undefined; } var totalMatch = candidateMatch; - for (var i = dotSeparatedSegments.length - 2, j = containerParts.length - 1; i >= 0; i--, j--) { + for (var i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i--, j--) { var segment = dotSeparatedSegments[i]; - var containerName = containerParts[j]; + var containerName = candidateContainers[j]; var containerMatch = matchSegment(containerName, segment); if (!containerMatch) { return undefined; @@ -22461,7 +23158,7 @@ var ts; } return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo); function getImmediatelyContainingArgumentInfo(node) { - if (node.parent.kind === 153 || node.parent.kind === 154) { + if (node.parent.kind === 155 || node.parent.kind === 156) { var callExpression = node.parent; if (node.kind === 24 || node.kind === 16) { @@ -22490,23 +23187,23 @@ var ts; }; } } - else if (node.kind === 10 && node.parent.kind === 155) { + else if (node.kind === 10 && node.parent.kind === 157) { if (ts.isInsideTemplateLiteral(node, position)) { return getArgumentListInfoForTemplate(node.parent, 0); } } - else if (node.kind === 11 && node.parent.parent.kind === 155) { + else if (node.kind === 11 && node.parent.parent.kind === 157) { var templateExpression = node.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 167); + ts.Debug.assert(templateExpression.kind === 169); var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; return getArgumentListInfoForTemplate(tagExpression, argumentIndex); } - else if (node.parent.kind === 171 && node.parent.parent.parent.kind === 155) { + else if (node.parent.kind === 173 && node.parent.parent.parent.kind === 157) { var templateSpan = node.parent; var templateExpression = templateSpan.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 167); + ts.Debug.assert(templateExpression.kind === 169); if (node.kind === 13 && !ts.isInsideTemplateLiteral(node, position)) { return undefined; } @@ -22548,7 +23245,7 @@ var ts; var template = taggedTemplate.template; var applicableSpanStart = template.getStart(); var applicableSpanEnd = template.getEnd(); - if (template.kind === 167) { + if (template.kind === 169) { var lastSpan = ts.lastOrUndefined(template.templateSpans); if (lastSpan.literal.getFullWidth() === 0) { applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); @@ -22557,7 +23254,7 @@ var ts; return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); } function getContainingArgumentInfo(node) { - for (var n = node; n.kind !== 210; n = n.parent) { + for (var n = node; n.kind !== 220; n = n.parent) { if (ts.isFunctionBlock(n)) { return undefined; } @@ -22747,7 +23444,7 @@ var ts; ts.findChildOfKind = findChildOfKind; function findContainingList(node) { var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { - if (c.kind === 211 && c.pos <= node.pos && c.end >= node.end) { + if (c.kind === 221 && c.pos <= node.pos && c.end >= node.end) { return c; } }); @@ -22852,7 +23549,7 @@ var ts; } } } - ts.Debug.assert(startNode !== undefined || n.kind === 210); + ts.Debug.assert(startNode !== undefined || n.kind === 220); if (children.length) { var candidate = findRightmostChildNodeWithTokens(children, children.length); return candidate && findRightmostToken(candidate); @@ -22889,17 +23586,17 @@ var ts; } ts.getNodeModifiers = getNodeModifiers; function getTypeArgumentOrTypeParameterList(node) { - if (node.kind === 137 || node.kind === 153) { + if (node.kind === 139 || node.kind === 155) { return node.typeArguments; } - if (ts.isAnyFunction(node) || node.kind === 194 || node.kind === 195) { + if (ts.isAnyFunction(node) || node.kind === 196 || node.kind === 197) { return node.typeParameters; } return undefined; } ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; function isToken(n) { - return n.kind >= 0 && n.kind <= 122; + return n.kind >= 0 && n.kind <= 124; } ts.isToken = isToken; function isWord(kind) { @@ -22940,7 +23637,7 @@ var ts; var ts; (function (ts) { function isFirstDeclarationOfSymbolParameter(symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 126; + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 128; } ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; var displayPartWriter = getDisplayPartWriter(); @@ -23510,9 +24207,10 @@ var ts; this.IgnoreAfterLineComment = new formatting.Rule(formatting.RuleDescriptor.create3(2, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create1(1)); this.NoSpaceBeforeSemicolon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.NoSpaceBeforeColon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 51), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); - this.NoSpaceBeforeQMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceBeforeQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); this.SpaceAfterColon = new formatting.Rule(formatting.RuleDescriptor.create3(51, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2)); - this.SpaceAfterQMark = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2)); + this.SpaceAfterQuestionMarkInConditionalOperator = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsConditionalOperatorContext), 2)); + this.NoSpaceAfterQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceAfterSemicolon = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); this.SpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsAfterCodeBlockContext), 2)); this.SpaceBetweenCloseBraceAndElse = new formatting.Rule(formatting.RuleDescriptor.create1(15, 75), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); @@ -23525,7 +24223,7 @@ var ts; this.NoSpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 19), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.NoSpaceAfterCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.FunctionOpenBraceLeftTokenRange = formatting.Shared.TokenRange.AnyIncludingMultilineComments; - this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); this.TypeScriptOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([64, 3]); this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); this.ControlOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([17, 3, 74, 95, 80, 75]); @@ -23548,6 +24246,7 @@ var ts; this.SpaceAfterSubtractWhenFollowedByPredecrement = new formatting.Rule(formatting.RuleDescriptor.create1(34, 39), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); this.NoSpaceBeforeComma = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 23), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceAfterCertainKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([97, 93, 87, 73, 89, 96]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterLetConstInVariableDeclaration = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([105, 69]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), 2)); this.NoSpaceBeforeOpenParenInFuncCall = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), 8)); this.SpaceAfterFunctionInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create3(82, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); this.NoSpaceBeforeOpenParenInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionDeclContext), 8)); @@ -23555,13 +24254,13 @@ var ts; this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(89, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([17, 74, 75, 66]), 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([95, 80]), 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); - this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([114, 118]), 64), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116, 120]), 64), 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(112, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([115, 116]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([68, 113, 76, 77, 78, 114, 101, 84, 102, 115, 105, 107, 118, 108]), 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([78, 101])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 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, 118]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([68, 115, 76, 77, 78, 116, 103, 84, 104, 117, 107, 109, 120, 110]), 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([78, 103])), 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)); this.NoSpaceAfterEllipsis = new formatting.Rule(formatting.RuleDescriptor.create1(21, 64), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); @@ -23575,7 +24274,8 @@ var ts; this.HighPriorityCommonRules = [ this.IgnoreBeforeComment, this.IgnoreAfterLineComment, - this.NoSpaceBeforeColon, this.SpaceAfterColon, this.NoSpaceBeforeQMark, this.SpaceAfterQMark, + this.NoSpaceBeforeColon, this.SpaceAfterColon, this.NoSpaceBeforeQuestionMark, this.SpaceAfterQuestionMarkInConditionalOperator, + this.NoSpaceAfterQuestionMark, this.NoSpaceBeforeDot, this.NoSpaceAfterDot, this.NoSpaceAfterUnaryPrefixOperator, this.NoSpaceAfterUnaryPreincrementOperator, this.NoSpaceAfterUnaryPredecrementOperator, @@ -23590,6 +24290,7 @@ var ts; this.SpaceAfterFunctionInFuncDecl, this.NewLineAfterOpenBraceInBlockContext, this.SpaceAfterGetSetInMember, this.NoSpaceBetweenReturnAndSemicolon, this.SpaceAfterCertainKeywords, + this.SpaceAfterLetConstInVariableDeclaration, this.NoSpaceBeforeOpenParenInFuncCall, this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator, this.SpaceAfterVoidOperator, @@ -23648,33 +24349,38 @@ var ts; throw new Error("Unknown rule"); }; Rules.IsForContext = function (context) { - return context.contextNode.kind === 179; + return context.contextNode.kind === 181; }; Rules.IsNotForContext = function (context) { return !Rules.IsForContext(context); }; Rules.IsBinaryOpContext = function (context) { switch (context.contextNode.kind) { - case 165: - case 166: + case 167: + case 168: return true; - case 200: - case 191: - case 126: - case 209: + case 202: + case 193: case 128: - case 127: + case 219: + case 130: + case 129: return context.currentTokenSpan.kind === 52 || context.nextTokenSpan.kind === 52; - case 180: + case 182: return context.currentTokenSpan.kind === 85 || context.nextTokenSpan.kind === 85; - case 181: - return context.currentTokenSpan.kind === 122 || context.nextTokenSpan.kind === 122; + case 183: + return context.currentTokenSpan.kind === 124 || context.nextTokenSpan.kind === 124; + case 150: + return context.currentTokenSpan.kind === 52 || context.nextTokenSpan.kind === 52; } return false; }; Rules.IsNotBinaryOpContext = function (context) { return !Rules.IsBinaryOpContext(context); }; + Rules.IsConditionalOperatorContext = function (context) { + return context.contextNode.kind === 168; + }; Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context); }; @@ -23698,26 +24404,26 @@ var ts; return true; } switch (node.kind) { - case 172: - case 186: - case 150: - case 199: + case 174: + case 188: + case 152: + case 201: return true; } return false; }; Rules.IsFunctionDeclContext = function (context) { switch (context.contextNode.kind) { - case 193: - case 130: - case 129: - case 132: - case 133: - case 134: - case 158: - case 131: - case 159: case 195: + case 132: + case 131: + case 134: + case 135: + case 136: + case 160: + case 133: + case 161: + case 197: return true; } return false; @@ -23727,53 +24433,53 @@ var ts; }; Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { switch (node.kind) { - case 194: - case 195: + case 196: case 197: - case 141: - case 198: + case 199: + case 143: + case 200: return true; } return false; }; Rules.IsAfterCodeBlockContext = function (context) { switch (context.currentTokenParent.kind) { - case 194: - case 198: - case 197: - case 172: - case 206: + case 196: + case 200: case 199: - case 186: + case 174: + case 216: + case 201: + case 188: return true; } return false; }; Rules.IsControlDeclContext = function (context) { switch (context.contextNode.kind) { - case 176: - case 186: - case 179: - case 180: - case 181: case 178: - case 189: - case 177: - case 185: - case 206: + case 188: + case 181: + case 182: + case 183: + case 180: + case 191: + case 179: + case 187: + case 216: return true; default: return false; } }; Rules.IsObjectContext = function (context) { - return context.contextNode.kind === 150; + return context.contextNode.kind === 152; }; Rules.IsFunctionCallContext = function (context) { - return context.contextNode.kind === 153; + return context.contextNode.kind === 155; }; Rules.IsNewContext = function (context) { - return context.contextNode.kind === 154; + return context.contextNode.kind === 156; }; Rules.IsFunctionCallOrNewContext = function (context) { return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); @@ -23784,32 +24490,36 @@ var ts; Rules.IsSameLineTokenContext = function (context) { return context.TokensAreOnSameLine(); }; + Rules.IsStartOfVariableDeclarationList = function (context) { + return context.currentTokenParent.kind === 194 && + context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; + }; Rules.IsNotFormatOnEnter = function (context) { return context.formattingRequestKind != 2; }; Rules.IsModuleDeclContext = function (context) { - return context.contextNode.kind === 198; + return context.contextNode.kind === 200; }; Rules.IsObjectTypeContext = function (context) { - return context.contextNode.kind === 141; + return context.contextNode.kind === 143; }; Rules.IsTypeArgumentOrParameter = function (token, parent) { if (token.kind !== 24 && token.kind !== 25) { return false; } switch (parent.kind) { - case 137: - case 194: + case 139: + case 196: + case 197: case 195: - case 193: - case 158: - case 159: - case 130: - case 129: - case 134: - case 135: - case 153: - case 154: + case 160: + case 161: + case 132: + case 131: + case 136: + case 137: + case 155: + case 156: return true; default: return false; @@ -23820,7 +24530,7 @@ var ts; Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); }; Rules.IsVoidOpContext = function (context) { - return context.currentTokenSpan.kind === 98 && context.currentTokenParent.kind === 162; + return context.currentTokenSpan.kind === 98 && context.currentTokenParent.kind === 164; }; return Rules; })(); @@ -23842,7 +24552,7 @@ var ts; return result; }; RulesMap.prototype.Initialize = function (rules) { - this.mapRowLength = 122 + 1; + this.mapRowLength = 124 + 1; this.map = new Array(this.mapRowLength * this.mapRowLength); var rulesBucketConstructionStateList = new Array(this.map.length); this.FillRules(rules, rulesBucketConstructionStateList); @@ -24011,7 +24721,7 @@ var ts; } TokenAllAccess.prototype.GetTokens = function () { var result = []; - for (var token = 0; token <= 122; token++) { + for (var token = 0; token <= 124; token++) { result.push(token); } return result; @@ -24053,9 +24763,9 @@ var ts; }; TokenRange.Any = TokenRange.AllTokens(); TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3])); - TokenRange.Keywords = TokenRange.FromRange(65, 122); + TokenRange.Keywords = TokenRange.FromRange(65, 124); TokenRange.BinaryOperators = TokenRange.FromRange(24, 63); - TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([85, 86, 122]); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([85, 86, 124]); TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38, 39, 47, 46]); TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7, 64, 16, 18, 14, 92, 87]); TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([64, 16, 92, 87]); @@ -24063,7 +24773,7 @@ var ts; TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([64, 16, 92, 87]); TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([64, 17, 19, 87]); TokenRange.Comments = TokenRange.FromTokens([2, 3]); - TokenRange.TypeNames = TokenRange.FromTokens([64, 117, 119, 111, 120, 98, 110]); + TokenRange.TypeNames = TokenRange.FromTokens([64, 119, 121, 113, 122, 98, 112]); return TokenRange; })(); Shared.TokenRange = TokenRange; @@ -24228,17 +24938,17 @@ var ts; } function isListElement(parent, node) { switch (parent.kind) { - case 194: - case 195: + case 196: + case 197: return ts.rangeContainsRange(parent.members, node); - case 198: + case 200: var body = parent.body; - return body && body.kind === 172 && ts.rangeContainsRange(body.statements, node); - case 210: - case 172: - case 199: + return body && body.kind === 174 && ts.rangeContainsRange(body.statements, node); + case 220: + case 174: + case 201: return ts.rangeContainsRange(parent.statements, node); - case 206: + case 216: return ts.rangeContainsRange(parent.block.statements, node); } return false; @@ -24355,9 +25065,9 @@ var ts; if (indentation === -1) { if (isSomeBlock(node.kind)) { if (isSomeBlock(parent.kind) || - parent.kind === 210 || - parent.kind === 203 || - parent.kind === 204) { + parent.kind === 220 || + parent.kind === 213 || + parent.kind === 214) { indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); } else { @@ -24674,8 +25384,8 @@ var ts; parts.push({ pos: startPos, end: commentRange.end }); } var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); - var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceColumn(startLinePos, parts[0].pos, sourceFile, options); - if (indentation === nonWhitespaceColumnInFirstPart) { + var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].pos, sourceFile, options); + if (indentation === nonWhitespaceColumnInFirstPart.column) { return; } var startIndex = 0; @@ -24683,17 +25393,17 @@ var ts; startIndex = 1; startLine++; } - var delta = indentation - nonWhitespaceColumnInFirstPart; + var delta = indentation - nonWhitespaceColumnInFirstPart.column; for (var i = startIndex, len = parts.length; i < len; ++i, ++startLine) { var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); - var nonWhitespaceColumn = i === 0 ? nonWhitespaceColumnInFirstPart : formatting.SmartIndenter.findFirstNonWhitespaceColumn(parts[i].pos, parts[i].end, sourceFile, options); - var newIndentation = nonWhitespaceColumn + delta; + var nonWhitespaceCharacterAndColumn = i === 0 ? nonWhitespaceColumnInFirstPart : formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(parts[i].pos, parts[i].end, sourceFile, options); + var newIndentation = nonWhitespaceCharacterAndColumn.column + delta; if (newIndentation > 0) { var indentationString = getIndentationString(newIndentation, options); - recordReplace(startLinePos, nonWhitespaceColumn, indentationString); + recordReplace(startLinePos, nonWhitespaceCharacterAndColumn.character, indentationString); } else { - recordDelete(startLinePos, nonWhitespaceColumn); + recordDelete(startLinePos, nonWhitespaceCharacterAndColumn.character); } } } @@ -24760,20 +25470,20 @@ var ts; } function isSomeBlock(kind) { switch (kind) { - case 172: - case 199: + case 174: + case 201: return true; } return false; } function getOpenTokenForList(node, list) { switch (node.kind) { + case 133: + case 195: + case 160: + case 132: case 131: - case 193: - case 158: - case 130: - case 129: - case 159: + case 161: if (node.typeParameters === list) { return 24; } @@ -24781,8 +25491,8 @@ var ts; return 16; } break; - case 153: - case 154: + case 155: + case 156: if (node.typeArguments === list) { return 24; } @@ -24790,7 +25500,7 @@ var ts; return 16; } break; - case 137: + case 139: if (node.typeArguments === list) { return 24; } @@ -24875,7 +25585,7 @@ var ts; return 0; } var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; - if (precedingToken.kind === 23 && precedingToken.parent.kind !== 165) { + if (precedingToken.kind === 23 && precedingToken.parent.kind !== 167) { var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); if (actualIndentation !== -1) { return actualIndentation; @@ -24961,7 +25671,7 @@ var ts; } function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) { var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && - (parent.kind === 210 || !parentAndChildShareLine); + (parent.kind === 220 || !parentAndChildShareLine); if (!useActualIndentation) { return -1; } @@ -24988,7 +25698,7 @@ var ts; return candidate.end > position || !isCompletedNode(candidate, sourceFile); } function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { - if (parent.kind === 176 && parent.elseStatement === child) { + if (parent.kind === 178 && parent.elseStatement === child) { var elseKeyword = ts.findChildOfKind(parent, 75, sourceFile); ts.Debug.assert(elseKeyword !== undefined); var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; @@ -25000,23 +25710,23 @@ var ts; function getContainingList(node, sourceFile) { if (node.parent) { switch (node.parent.kind) { - case 137: + case 139: if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { return node.parent.typeArguments; } break; - case 150: + case 152: return node.parent.properties; - case 149: + case 151: return node.parent.elements; - case 193: - case 158: - case 159: - case 130: - case 129: - case 134: - case 135: + case 195: + case 160: + case 161: + case 132: + case 131: + case 136: + case 137: var start = node.getStart(sourceFile); if (node.parent.typeParameters && ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { @@ -25026,8 +25736,8 @@ var ts; return node.parent.parameters; } break; - case 154: - case 153: + case 156: + case 155: var start = node.getStart(sourceFile); if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { @@ -25070,12 +25780,13 @@ var ts; var lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0); return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options); } - function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) { + function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) { + var character = 0; var column = 0; for (var pos = startPos; pos < endPos; ++pos) { var ch = sourceFile.text.charCodeAt(pos); if (!ts.isWhiteSpace(ch)) { - return column; + break; } if (ch === 9) { column += options.TabSize + (column % options.TabSize); @@ -25083,31 +25794,36 @@ var ts; else { column++; } + character++; } - return column; + return { column: column, character: character }; + } + SmartIndenter.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn; + function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) { + return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column; } SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; function nodeContentIsAlwaysIndented(kind) { switch (kind) { - case 194: - case 195: + case 196: case 197: - case 149: - case 172: case 199: - case 150: - case 141: - case 186: - case 204: - case 203: - case 157: - case 153: - case 154: - case 173: - case 191: + case 151: + case 174: case 201: - case 184: - case 166: + case 152: + case 143: + case 188: + case 214: + case 213: + case 159: + case 155: + case 156: + case 175: + case 193: + case 208: + case 186: + case 168: return true; } return false; @@ -25117,21 +25833,21 @@ var ts; return true; } switch (parent) { - case 177: - case 178: - case 180: - case 181: case 179: - case 176: - case 193: - case 158: - case 130: - case 129: - case 159: - case 131: + case 180: + case 182: + case 183: + case 181: + case 178: + case 195: + case 160: case 132: + case 131: + case 161: case 133: - return child !== 172; + case 134: + case 135: + return child !== 174; default: return false; } @@ -25155,44 +25871,44 @@ var ts; return false; } switch (n.kind) { - case 194: - case 195: + case 196: case 197: - case 150: - case 172: case 199: - case 186: + case 152: + case 174: + case 201: + case 188: return nodeEndsWith(n, 15, sourceFile); - case 206: + case 216: return isCompletedNode(n.block, sourceFile); - case 157: - case 134: - case 153: - case 135: - return nodeEndsWith(n, 17, sourceFile); - case 193: - case 158: - case 130: - case 129: case 159: + case 136: + case 155: + case 137: + return nodeEndsWith(n, 17, sourceFile); + case 195: + case 160: + case 132: + case 131: + case 161: return !n.body || isCompletedNode(n.body, sourceFile); - case 198: + case 200: return n.body && isCompletedNode(n.body, sourceFile); - case 176: + case 178: if (n.elseStatement) { return isCompletedNode(n.elseStatement, sourceFile); } return isCompletedNode(n.thenStatement, sourceFile); - case 175: - return isCompletedNode(n.expression, sourceFile); - case 149: - return nodeEndsWith(n, 19, sourceFile); - case 203: - case 204: - return false; - case 178: - return isCompletedNode(n.statement, sourceFile); case 177: + return isCompletedNode(n.expression, sourceFile); + case 151: + return nodeEndsWith(n, 19, sourceFile); + case 213: + case 214: + return false; + case 180: + return isCompletedNode(n.statement, sourceFile); + case 179: var hasWhileKeyword = ts.findChildOfKind(n, 99, sourceFile); if (hasWhileKeyword) { return nodeEndsWith(n, 17, sourceFile); @@ -25288,7 +26004,7 @@ var ts; return pos; }; NodeObject.prototype.createSyntaxList = function (nodes) { - var list = createNode(211, nodes.pos, nodes.end, 512, this); + var list = createNode(221, nodes.pos, nodes.end, 512, this); list._children = []; var pos = nodes.pos; for (var i = 0, len = nodes.length; i < len; i++) { @@ -25306,7 +26022,7 @@ var ts; }; NodeObject.prototype.createChildren = function (sourceFile) { var _this = this; - if (this.kind >= 123) { + if (this.kind >= 125) { scanner.setText((sourceFile || this.getSourceFile()).text); var children = []; var pos = this.pos; @@ -25351,7 +26067,7 @@ var ts; var children = this.getChildren(); for (var i = 0; i < children.length; i++) { var child = children[i]; - if (child.kind < 123) { + if (child.kind < 125) { return child; } return child.getFirstToken(sourceFile); @@ -25361,7 +26077,7 @@ var ts; var children = this.getChildren(sourceFile); for (var i = children.length - 1; i >= 0; i--) { var child = children[i]; - if (child.kind < 123) { + if (child.kind < 125) { return child; } return child.getLastToken(sourceFile); @@ -25407,7 +26123,7 @@ var ts; ts.forEach(declarations, function (declaration, indexOfDeclaration) { if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); - if (canUseParsedParamTagComments && declaration.kind === 126) { + if (canUseParsedParamTagComments && declaration.kind === 128) { ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedParamJsDocComment) { @@ -25415,13 +26131,13 @@ var ts; } }); } - if (declaration.kind === 198 && declaration.body.kind === 198) { + if (declaration.kind === 200 && declaration.body.kind === 200) { return; } - while (declaration.kind === 198 && declaration.parent.kind === 198) { + while (declaration.kind === 200 && declaration.parent.kind === 200) { declaration = declaration.parent; } - ts.forEach(getJsDocCommentTextRange(declaration.kind === 191 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + ts.forEach(getJsDocCommentTextRange(declaration.kind === 193 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedJsDocComment) { jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); @@ -25705,9 +26421,9 @@ var ts; var namedDeclarations = []; ts.forEachChild(sourceFile, function visit(node) { switch (node.kind) { - case 193: - case 130: - case 129: + case 195: + case 132: + case 131: var functionDeclaration = node; if (functionDeclaration.name && functionDeclaration.name.getFullWidth() > 0) { var lastDeclaration = namedDeclarations.length > 0 ? namedDeclarations[namedDeclarations.length - 1] : undefined; @@ -25722,44 +26438,44 @@ var ts; ts.forEachChild(node, visit); } break; - case 194: - case 195: case 196: case 197: case 198: + case 199: case 200: - case 132: - case 133: - case 141: + case 202: + case 134: + case 135: + case 143: if (node.name) { namedDeclarations.push(node); } - case 131: - case 173: - case 192: - case 146: - case 147: - case 199: + case 133: + case 175: + case 194: + case 148: + case 149: + case 201: ts.forEachChild(node, visit); break; - case 172: + case 174: if (ts.isFunctionBlock(node)) { ts.forEachChild(node, visit); } break; - case 126: + case 128: if (!(node.flags & 112)) { break; } - case 191: - case 148: + case 193: + case 150: if (ts.isBindingPattern(node.name)) { ts.forEachChild(node.name, visit); break; } - case 209: - case 128: - case 127: + case 219: + case 130: + case 129: namedDeclarations.push(node); break; } @@ -25908,14 +26624,14 @@ var ts; return false; } return ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 158) { + if (declaration.kind === 160) { return true; } - if (declaration.kind !== 191 && declaration.kind !== 193) { + if (declaration.kind !== 193 && declaration.kind !== 195) { return false; } for (var parent = declaration.parent; !ts.isFunctionBlock(parent); parent = parent.parent) { - if (parent.kind === 210 || parent.kind === 199) { + if (parent.kind === 220 || parent.kind === 201) { return false; } } @@ -26005,60 +26721,34 @@ var ts; var file = this.getEntry(fileName); return file && file.scriptSnapshot; }; - HostCache.prototype.getChangeRange = function (fileName, lastKnownVersion, oldScriptSnapshot) { - var currentVersion = this.getVersion(fileName); - if (lastKnownVersion === currentVersion) { - return ts.unchangedTextChangeRange; - } - var scriptSnapshot = this.getScriptSnapshot(fileName); - return scriptSnapshot.getChangeRange(oldScriptSnapshot); - }; return HostCache; })(); var SyntaxTreeCache = (function () { function SyntaxTreeCache(host) { this.host = host; - this.currentFileName = ""; - this.currentFileVersion = null; - this.currentSourceFile = null; } - SyntaxTreeCache.prototype.log = function (message) { - if (this.host.log) { - this.host.log(message); + SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { + var scriptSnapshot = this.host.getScriptSnapshot(fileName); + if (!scriptSnapshot) { + throw new Error("Could not find file: '" + fileName + "'."); } - }; - SyntaxTreeCache.prototype.initialize = function (fileName) { - var start = new Date().getTime(); - this.hostCache = new HostCache(this.host); - this.log("SyntaxTreeCache.Initialize: new HostCache: " + (new Date().getTime() - start)); - var version = this.hostCache.getVersion(fileName); + var version = this.host.getScriptVersion(fileName); var sourceFile; if (this.currentFileName !== fileName) { - var scriptSnapshot = this.hostCache.getScriptSnapshot(fileName); - var start = new Date().getTime(); sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 2, version, true); - this.log("SyntaxTreeCache.Initialize: createSourceFile: " + (new Date().getTime() - start)); } else if (this.currentFileVersion !== version) { - var scriptSnapshot = this.hostCache.getScriptSnapshot(fileName); - var editRange = this.hostCache.getChangeRange(fileName, this.currentFileVersion, this.currentSourceFile.scriptSnapshot); - var start = new Date().getTime(); + var editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot); sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange); - this.log("SyntaxTreeCache.Initialize: updateSourceFile: " + (new Date().getTime() - start)); } if (sourceFile) { this.currentFileVersion = version; this.currentFileName = fileName; + this.currentFileScriptSnapshot = scriptSnapshot; this.currentSourceFile = sourceFile; } - }; - SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { - this.initialize(fileName); return this.currentSourceFile; }; - SyntaxTreeCache.prototype.getCurrentScriptSnapshot = function (fileName) { - return this.getCurrentSourceFile(fileName).scriptSnapshot; - }; return SyntaxTreeCache; })(); function setSourceFileFields(sourceFile, scriptSnapshot, version) { @@ -26189,7 +26879,7 @@ var ts; token = scanner.scan(); if (token === 52) { token = scanner.scan(); - if (token === 116) { + if (token === 118) { token = scanner.scan(); if (token === 16) { token = scanner.scan(); @@ -26220,7 +26910,7 @@ var ts; ts.preProcessFile = preProcessFile; function getTargetLabel(referenceNode, labelName) { while (referenceNode) { - if (referenceNode.kind === 187 && referenceNode.label.text === labelName) { + if (referenceNode.kind === 189 && referenceNode.label.text === labelName) { return referenceNode.label; } referenceNode = referenceNode.parent; @@ -26229,16 +26919,16 @@ var ts; } function isJumpStatementTarget(node) { return node.kind === 64 && - (node.parent.kind === 183 || node.parent.kind === 182) && + (node.parent.kind === 185 || node.parent.kind === 184) && node.parent.label === node; } function isLabelOfLabeledStatement(node) { return node.kind === 64 && - node.parent.kind === 187 && + node.parent.kind === 189 && node.parent.label === node; } function isLabeledBy(node, labelName) { - for (var owner = node.parent; owner.kind === 187; owner = owner.parent) { + for (var owner = node.parent; owner.kind === 189; owner = owner.parent) { if (owner.label.text === labelName) { return true; } @@ -26249,25 +26939,25 @@ var ts; return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); } function isRightSideOfQualifiedName(node) { - return node.parent.kind === 123 && node.parent.right === node; + return node.parent.kind === 125 && node.parent.right === node; } function isRightSideOfPropertyAccess(node) { - return node && node.parent && node.parent.kind === 151 && node.parent.name === node; + return node && node.parent && node.parent.kind === 153 && node.parent.name === node; } function isCallExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 153 && node.parent.expression === node; + return node && node.parent && node.parent.kind === 155 && node.parent.expression === node; } function isNewExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 154 && node.parent.expression === node; + return node && node.parent && node.parent.kind === 156 && node.parent.expression === node; } function isNameOfModuleDeclaration(node) { - return node.parent.kind === 198 && node.parent.name === node; + return node.parent.kind === 200 && node.parent.name === node; } function isNameOfFunctionDeclaration(node) { return node.kind === 64 && @@ -26275,22 +26965,22 @@ var ts; } function isNameOfPropertyAssignment(node) { return (node.kind === 64 || node.kind === 8 || node.kind === 7) && - (node.parent.kind === 207 || node.parent.kind === 208) && node.parent.name === node; + (node.parent.kind === 217 || node.parent.kind === 218) && node.parent.name === node; } function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { if (node.kind === 8 || node.kind === 7) { switch (node.parent.kind) { - case 128: - case 127: - case 207: - case 209: case 130: case 129: + case 217: + case 219: case 132: - case 133: - case 198: + case 131: + case 134: + case 135: + case 200: return node.parent.name === node; - case 152: + case 154: return node.parent.argumentExpression === node; } } @@ -26299,7 +26989,7 @@ var ts; function isNameOfExternalModuleImportOrDeclaration(node) { if (node.kind === 8) { return isNameOfModuleDeclaration(node) || - (ts.isExternalModuleImportDeclaration(node.parent.parent) && ts.getExternalModuleImportDeclarationExpression(node.parent.parent) === node); + (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node); } return false; } @@ -26343,7 +27033,7 @@ var ts; BreakContinueSearchType[BreakContinueSearchType["All"] = 3] = "All"; })(BreakContinueSearchType || (BreakContinueSearchType = {})); var keywordCompletions = []; - for (var i = 65; i <= 122; i++) { + for (var i = 65; i <= 124; i++) { keywordCompletions.push({ name: ts.tokenToString(i), kind: ScriptElementKind.keyword, @@ -26357,17 +27047,17 @@ var ts; return undefined; } switch (node.kind) { - case 210: - case 130: - case 129: - case 193: - case 158: + case 220: case 132: - case 133: - case 194: + case 131: case 195: + case 160: + case 134: + case 135: + case 196: case 197: - case 198: + case 199: + case 200: return node; } } @@ -26375,29 +27065,29 @@ var ts; ts.getContainerNode = getContainerNode; function getNodeKind(node) { switch (node.kind) { - case 198: return ScriptElementKind.moduleElement; - case 194: return ScriptElementKind.classElement; - case 195: return ScriptElementKind.interfaceElement; - case 196: return ScriptElementKind.typeElement; - case 197: return ScriptElementKind.enumElement; - case 191: + case 200: return ScriptElementKind.moduleElement; + case 196: return ScriptElementKind.classElement; + case 197: return ScriptElementKind.interfaceElement; + case 198: return ScriptElementKind.typeElement; + case 199: return ScriptElementKind.enumElement; + case 193: return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; - case 193: return ScriptElementKind.functionElement; - case 132: return ScriptElementKind.memberGetAccessorElement; - case 133: return ScriptElementKind.memberSetAccessorElement; + case 195: return ScriptElementKind.functionElement; + case 134: return ScriptElementKind.memberGetAccessorElement; + case 135: return ScriptElementKind.memberSetAccessorElement; + case 132: + case 131: + return ScriptElementKind.memberFunctionElement; case 130: case 129: - return ScriptElementKind.memberFunctionElement; - case 128: - case 127: return ScriptElementKind.memberVariableElement; - case 136: return ScriptElementKind.indexSignatureElement; - case 135: return ScriptElementKind.constructSignatureElement; - case 134: return ScriptElementKind.callSignatureElement; - case 131: return ScriptElementKind.constructorImplementationElement; - case 125: return ScriptElementKind.typeParameterElement; - case 209: return ScriptElementKind.variableElement; - case 126: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; + case 138: return ScriptElementKind.indexSignatureElement; + case 137: return ScriptElementKind.constructSignatureElement; + case 136: return ScriptElementKind.callSignatureElement; + case 133: return ScriptElementKind.constructorImplementationElement; + case 127: return ScriptElementKind.typeParameterElement; + case 219: return ScriptElementKind.variableElement; + case 128: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; } return ScriptElementKind.unknown; } @@ -26423,6 +27113,7 @@ var ts; return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); } function getValidSourceFile(fileName) { + fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); if (!sourceFile) { throw new Error("Could not find file: '" + fileName + "'."); @@ -26477,7 +27168,7 @@ var ts; if (sourceFileUpToDate(oldSourceFile)) { return oldSourceFile; } - var textChangeRange = hostCache.getChangeRange(fileName, oldSourceFile.version, oldSourceFile.scriptSnapshot); + var textChangeRange = hostFileInformation.scriptSnapshot.getChangeRange(oldSourceFile.scriptSnapshot); return documentRegistry.updateDocument(oldSourceFile, fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version, textChangeRange); } } @@ -26518,12 +27209,10 @@ var ts; } function getSyntacticDiagnostics(fileName) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); return program.getSyntacticDiagnostics(getValidSourceFile(fileName)); } function getSemanticDiagnostics(fileName) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var targetSourceFile = getValidSourceFile(fileName); var semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile); if (!program.getCompilerOptions().declaration) { @@ -26570,7 +27259,6 @@ var ts; } function getCompletionsAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var syntacticStart = new Date().getTime(); var sourceFile = getValidSourceFile(fileName); var start = new Date().getTime(); @@ -26597,11 +27285,11 @@ var ts; } var node; var isRightOfDot; - if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 151) { + if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 153) { node = previousToken.parent.expression; isRightOfDot = true; } - else if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 123) { + else if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 125) { node = previousToken.parent.left; isRightOfDot = true; } @@ -26623,7 +27311,7 @@ var ts; var symbols = []; var isMemberCompletion = true; var isNewIdentifierLocation = false; - if (node.kind === 64 || node.kind === 123 || node.kind === 151) { + if (node.kind === 64 || node.kind === 125 || node.kind === 153) { var symbol = typeInfoResolver.getSymbolAtLocation(node); if (symbol && symbol.flags & 8388608) { symbol = typeInfoResolver.getAliasedSymbol(symbol); @@ -26706,27 +27394,27 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23: - return containingNodeKind === 153 || containingNodeKind === 131 || containingNodeKind === 154 || containingNodeKind === 149 || containingNodeKind === 165; + return containingNodeKind === 155 || containingNodeKind === 133 || containingNodeKind === 156 || containingNodeKind === 151 || containingNodeKind === 167; case 16: - return containingNodeKind === 153 || containingNodeKind === 131 || containingNodeKind === 154 || containingNodeKind === 157; + return containingNodeKind === 155 || containingNodeKind === 133 || containingNodeKind === 156 || containingNodeKind === 159; case 18: - return containingNodeKind === 149; - case 115: + return containingNodeKind === 151; + case 117: return true; case 20: - return containingNodeKind === 198; + return containingNodeKind === 200; case 14: - return containingNodeKind === 194; + return containingNodeKind === 196; case 52: - return containingNodeKind === 191 || containingNodeKind === 165; + return containingNodeKind === 193 || containingNodeKind === 167; case 11: - return containingNodeKind === 167; + return containingNodeKind === 169; case 12: - return containingNodeKind === 171; + return containingNodeKind === 173; + case 109: case 107: - case 105: - case 106: - return containingNodeKind === 128; + case 108: + return containingNodeKind === 130; } switch (previousToken.getText()) { case "public": @@ -26756,7 +27444,7 @@ var ts; switch (previousToken.kind) { case 14: case 23: - if (parent && parent.kind === 150) { + if (parent && parent.kind === 152) { return parent; } break; @@ -26766,16 +27454,16 @@ var ts; } function isFunction(kind) { switch (kind) { - case 158: - case 159: - case 193: - case 130: - case 129: + case 160: + case 161: + case 195: case 132: - case 133: + case 131: case 134: case 135: case 136: + case 137: + case 138: return true; } return false; @@ -26785,58 +27473,58 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23: - return containingNodeKind === 191 || - containingNodeKind === 192 || - containingNodeKind === 173 || - containingNodeKind === 197 || - isFunction(containingNodeKind) || + return containingNodeKind === 193 || containingNodeKind === 194 || - containingNodeKind === 193 || + containingNodeKind === 175 || + containingNodeKind === 199 || + isFunction(containingNodeKind) || + containingNodeKind === 196 || containingNodeKind === 195 || - containingNodeKind === 147 || - containingNodeKind === 146; + containingNodeKind === 197 || + containingNodeKind === 149 || + containingNodeKind === 148; case 20: - return containingNodeKind === 147; + return containingNodeKind === 149; case 18: - return containingNodeKind === 147; + return containingNodeKind === 149; case 16: - return containingNodeKind === 206 || + return containingNodeKind === 216 || isFunction(containingNodeKind); case 14: - return containingNodeKind === 197 || - containingNodeKind === 195 || - containingNodeKind === 141 || - containingNodeKind === 146; + return containingNodeKind === 199 || + containingNodeKind === 197 || + containingNodeKind === 143 || + containingNodeKind === 148; case 22: - return containingNodeKind === 127 && - (previousToken.parent.parent.kind === 195 || - previousToken.parent.parent.kind === 141); + return containingNodeKind === 129 && + (previousToken.parent.parent.kind === 197 || + previousToken.parent.parent.kind === 143); case 24: - return containingNodeKind === 194 || - containingNodeKind === 193 || + return containingNodeKind === 196 || containingNodeKind === 195 || + containingNodeKind === 197 || isFunction(containingNodeKind); + case 110: + return containingNodeKind === 130; + case 21: + return containingNodeKind === 128 || + containingNodeKind === 133 || + (previousToken.parent.parent.kind === 149); + case 109: + case 107: case 108: return containingNodeKind === 128; - case 21: - return containingNodeKind === 126 || - containingNodeKind === 131 || - (previousToken.parent.parent.kind === 147); - case 107: - case 105: - case 106: - return containingNodeKind === 126; case 68: case 76: - case 102: + case 104: case 82: case 97: - case 114: - case 118: + case 116: + case 120: case 84: - case 103: + case 105: case 69: - case 109: + case 111: return true; } switch (previousToken.getText()) { @@ -26867,7 +27555,7 @@ var ts; } var existingMemberNames = {}; ts.forEach(existingMembers, function (m) { - if (m.kind !== 207 && m.kind !== 208) { + if (m.kind !== 217 && m.kind !== 218) { return; } if (m.getStart() <= position && position <= m.getEnd()) { @@ -26885,7 +27573,6 @@ var ts; } } function getCompletionEntryDetails(fileName, position, entryName) { - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var session = activeCompletionSession; if (!session || session.fileName !== fileName || session.position !== position) { @@ -27023,14 +27710,14 @@ var ts; } var type = typeResolver.getTypeOfSymbolAtLocation(symbol, location); if (type) { - if (location.parent && location.parent.kind === 151) { + if (location.parent && location.parent.kind === 153) { var right = location.parent.name; if (right === location || (right && right.getFullWidth() === 0)) { location = location.parent; } } var callExpression; - if (location.kind === 153 || location.kind === 154) { + if (location.kind === 155 || location.kind === 156) { callExpression = location; } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { @@ -27042,7 +27729,7 @@ var ts; if (!signature && candidateSignatures.length) { signature = candidateSignatures[0]; } - var useConstructSignatures = callExpression.kind === 154 || callExpression.expression.kind === 90; + var useConstructSignatures = callExpression.kind === 156 || callExpression.expression.kind === 90; var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); if (!ts.contains(allSignatures, signature.target || signature)) { signature = allSignatures.length ? allSignatures[0] : undefined; @@ -27092,22 +27779,22 @@ var ts; } } else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304)) || - (location.kind === 112 && location.parent.kind === 131)) { + (location.kind === 114 && location.parent.kind === 133)) { var signature; var functionDeclaration = location.parent; - var allSignatures = functionDeclaration.kind === 131 ? type.getConstructSignatures() : type.getCallSignatures(); + var allSignatures = functionDeclaration.kind === 133 ? type.getConstructSignatures() : type.getCallSignatures(); if (!typeResolver.isImplementationOfOverload(functionDeclaration)) { signature = typeResolver.getSignatureFromDeclaration(functionDeclaration); } else { signature = allSignatures[0]; } - if (functionDeclaration.kind === 131) { + if (functionDeclaration.kind === 133) { symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } else { - addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 134 && + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 136 && !(type.symbol.flags & 2048 || type.symbol.flags & 4096) ? type.symbol : symbol, symbolKind); } addSignatureDisplayParts(signature, allSignatures); @@ -27123,14 +27810,14 @@ var ts; } if ((symbolFlags & 64) && (semanticMeaning & 2)) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(102)); + displayParts.push(ts.keywordPart(104)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); writeTypeParametersOfSymbol(symbol, sourceFile); } if (symbolFlags & 524288) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(121)); + displayParts.push(ts.keywordPart(123)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); @@ -27150,7 +27837,7 @@ var ts; } if (symbolFlags & 1536) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(115)); + displayParts.push(ts.keywordPart(117)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } @@ -27169,13 +27856,13 @@ var ts; writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration); } else { - var signatureDeclaration = ts.getDeclarationOfKind(symbol, 125).parent; + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 127).parent; var signature = typeResolver.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === 135) { + if (signatureDeclaration.kind === 137) { displayParts.push(ts.keywordPart(87)); displayParts.push(ts.spacePart()); } - else if (signatureDeclaration.kind !== 134 && signatureDeclaration.name) { + else if (signatureDeclaration.kind !== 136 && signatureDeclaration.name) { addFullSymbolName(signatureDeclaration.symbol); } displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeResolver, signature, sourceFile, 32)); @@ -27184,7 +27871,7 @@ var ts; if (symbolFlags & 8) { addPrefixForAnyFunctionOrVar(symbol, "enum member"); var declaration = symbol.declarations[0]; - if (declaration.kind === 209) { + if (declaration.kind === 219) { var constantValue = typeResolver.getConstantValue(declaration); if (constantValue !== undefined) { displayParts.push(ts.spacePart()); @@ -27200,19 +27887,19 @@ var ts; displayParts.push(ts.spacePart()); addFullSymbolName(symbol); ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 200) { - var importDeclaration = declaration; - if (ts.isExternalModuleImportDeclaration(importDeclaration)) { + if (declaration.kind === 202) { + var importEqualsDeclaration = declaration; + if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(52)); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(116)); + displayParts.push(ts.keywordPart(118)); displayParts.push(ts.punctuationPart(16)); - displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportDeclarationExpression(importDeclaration)), 8)); + displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), 8)); displayParts.push(ts.punctuationPart(17)); } else { - var internalAliasSymbol = typeResolver.getSymbolAtLocation(importDeclaration.moduleReference); + var internalAliasSymbol = typeResolver.getSymbolAtLocation(importEqualsDeclaration.moduleReference); if (internalAliasSymbol) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(52)); @@ -27303,7 +27990,6 @@ var ts; } function getQuickInfoAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingPropertyName(sourceFile, position); if (!node) { @@ -27313,8 +27999,8 @@ var ts; if (!symbol) { switch (node.kind) { case 64: - case 151: - case 123: + case 153: + case 125: case 92: case 90: var type = typeInfoResolver.getTypeAtLocation(node); @@ -27341,7 +28027,6 @@ var ts; } function getDefinitionAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingPropertyName(sourceFile, position); if (!node) { @@ -27372,7 +28057,7 @@ var ts; return undefined; } var result = []; - if (node.parent.kind === 208) { + if (node.parent.kind === 218) { var shorthandSymbol = typeInfoResolver.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); var shorthandDeclarations = shorthandSymbol.getDeclarations(); var shorthandSymbolKind = getSymbolKind(shorthandSymbol, typeInfoResolver, node); @@ -27409,8 +28094,8 @@ var ts; var declarations = []; var definition; ts.forEach(signatureDeclarations, function (d) { - if ((selectConstructors && d.kind === 131) || - (!selectConstructors && (d.kind === 193 || d.kind === 130 || d.kind === 129))) { + if ((selectConstructors && d.kind === 133) || + (!selectConstructors && (d.kind === 195 || d.kind === 132 || d.kind === 131))) { declarations.push(d); if (d.body) definition = d; @@ -27427,10 +28112,10 @@ var ts; return false; } function tryAddConstructSignature(symbol, location, symbolKind, symbolName, containerName, result) { - if (isNewExpressionTarget(location) || location.kind === 112) { + if (isNewExpressionTarget(location) || location.kind === 114) { if (symbol.flags & 32) { var classDeclaration = symbol.getDeclarations()[0]; - ts.Debug.assert(classDeclaration && classDeclaration.kind === 194); + ts.Debug.assert(classDeclaration && classDeclaration.kind === 196); return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); } } @@ -27445,7 +28130,6 @@ var ts; } function getOccurrencesAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingWord(sourceFile, position); if (!node) { @@ -27458,81 +28142,81 @@ var ts; switch (node.kind) { case 83: case 75: - if (hasKind(node.parent, 176)) { + if (hasKind(node.parent, 178)) { return getIfElseOccurrences(node.parent); } break; case 89: - if (hasKind(node.parent, 184)) { + if (hasKind(node.parent, 186)) { return getReturnOccurrences(node.parent); } break; case 93: - if (hasKind(node.parent, 188)) { + if (hasKind(node.parent, 190)) { return getThrowOccurrences(node.parent); } break; case 67: - if (hasKind(parent(parent(node)), 189)) { + if (hasKind(parent(parent(node)), 191)) { return getTryCatchFinallyOccurrences(node.parent.parent); } break; case 95: case 80: - if (hasKind(parent(node), 189)) { + if (hasKind(parent(node), 191)) { return getTryCatchFinallyOccurrences(node.parent); } break; case 91: - if (hasKind(node.parent, 186)) { + if (hasKind(node.parent, 188)) { return getSwitchCaseDefaultOccurrences(node.parent); } break; case 66: case 72: - if (hasKind(parent(parent(node)), 186)) { + if (hasKind(parent(parent(node)), 188)) { return getSwitchCaseDefaultOccurrences(node.parent.parent); } break; case 65: case 70: - if (hasKind(node.parent, 183) || hasKind(node.parent, 182)) { + if (hasKind(node.parent, 185) || hasKind(node.parent, 184)) { return getBreakOrContinueStatementOccurences(node.parent); } break; case 81: - if (hasKind(node.parent, 179) || - hasKind(node.parent, 180) || - hasKind(node.parent, 181)) { + if (hasKind(node.parent, 181) || + hasKind(node.parent, 182) || + hasKind(node.parent, 183)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 99: case 74: - if (hasKind(node.parent, 178) || hasKind(node.parent, 177)) { + if (hasKind(node.parent, 180) || hasKind(node.parent, 179)) { return getLoopBreakContinueOccurrences(node.parent); } break; - case 112: - if (hasKind(node.parent, 131)) { + case 114: + if (hasKind(node.parent, 133)) { return getConstructorOccurrences(node.parent); } break; - case 114: - case 118: - if (hasKind(node.parent, 132) || hasKind(node.parent, 133)) { + case 116: + case 120: + if (hasKind(node.parent, 134) || hasKind(node.parent, 135)) { return getGetAndSetOccurrences(node.parent); } default: if (ts.isModifier(node.kind) && node.parent && - (ts.isDeclaration(node.parent) || node.parent.kind === 173)) { + (ts.isDeclaration(node.parent) || node.parent.kind === 175)) { return getModifierOccurrences(node.kind, node.parent); } } return undefined; function getIfElseOccurrences(ifStatement) { var keywords = []; - while (hasKind(ifStatement.parent, 176) && ifStatement.parent.elseStatement === ifStatement) { + while (hasKind(ifStatement.parent, 178) && ifStatement.parent.elseStatement === ifStatement) { ifStatement = ifStatement.parent; } while (ifStatement) { @@ -27543,7 +28227,7 @@ var ts; break; } } - if (!hasKind(ifStatement.elseStatement, 176)) { + if (!hasKind(ifStatement.elseStatement, 178)) { break; } ifStatement = ifStatement.elseStatement; @@ -27576,7 +28260,7 @@ var ts; } function getReturnOccurrences(returnStatement) { var func = ts.getContainingFunction(returnStatement); - if (!(func && hasKind(func.body, 172))) { + if (!(func && hasKind(func.body, 174))) { return undefined; } var keywords = []; @@ -27609,10 +28293,10 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 188) { + if (node.kind === 190) { statementAccumulator.push(node); } - else if (node.kind === 189) { + else if (node.kind === 191) { var tryStatement = node; if (tryStatement.catchClause) { aggregate(tryStatement.catchClause); @@ -27634,10 +28318,10 @@ var ts; var child = throwStatement; while (child.parent) { var parent = child.parent; - if (ts.isFunctionBlock(parent) || parent.kind === 210) { + if (ts.isFunctionBlock(parent) || parent.kind === 220) { return parent; } - if (parent.kind === 189) { + if (parent.kind === 191) { var tryStatement = parent; if (tryStatement.tryBlock === child && tryStatement.catchClause) { return child; @@ -27662,7 +28346,7 @@ var ts; function getLoopBreakContinueOccurrences(loopNode) { var keywords = []; if (pushKeywordIf(keywords, loopNode.getFirstToken(), 81, 99, 74)) { - if (loopNode.kind === 177) { + if (loopNode.kind === 179) { var loopTokens = loopNode.getChildren(); for (var i = loopTokens.length - 1; i >= 0; i--) { if (pushKeywordIf(keywords, loopTokens[i], 99)) { @@ -27697,13 +28381,13 @@ var ts; var owner = getBreakOrContinueOwner(breakOrContinueStatement); if (owner) { switch (owner.kind) { + case 181: + case 182: + case 183: case 179: case 180: - case 181: - case 177: - case 178: return getLoopBreakContinueOccurrences(owner); - case 186: + case 188: return getSwitchCaseDefaultOccurrences(owner); } } @@ -27714,7 +28398,7 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 183 || node.kind === 182) { + if (node.kind === 185 || node.kind === 184) { statementAccumulator.push(node); } else if (!ts.isAnyFunction(node)) { @@ -27730,15 +28414,15 @@ var ts; function getBreakOrContinueOwner(statement) { for (var node = statement.parent; node; node = node.parent) { switch (node.kind) { - case 186: - if (statement.kind === 182) { + case 188: + if (statement.kind === 184) { continue; } - case 179: - case 180: case 181: - case 178: - case 177: + case 182: + case 183: + case 180: + case 179: if (!statement.label || isLabeledBy(node, statement.label.text)) { return node; } @@ -27757,38 +28441,38 @@ var ts; var keywords = []; ts.forEach(declarations, function (declaration) { ts.forEach(declaration.getChildren(), function (token) { - return pushKeywordIf(keywords, token, 112); + return pushKeywordIf(keywords, token, 114); }); }); return ts.map(keywords, getReferenceEntryFromNode); } function getGetAndSetOccurrences(accessorDeclaration) { var keywords = []; - tryPushAccessorKeyword(accessorDeclaration.symbol, 132); - tryPushAccessorKeyword(accessorDeclaration.symbol, 133); + tryPushAccessorKeyword(accessorDeclaration.symbol, 134); + tryPushAccessorKeyword(accessorDeclaration.symbol, 135); return ts.map(keywords, getReferenceEntryFromNode); function tryPushAccessorKeyword(accessorSymbol, accessorKind) { var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); if (accessor) { - ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 114, 118); }); + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116, 120); }); } } } function getModifierOccurrences(modifier, declaration) { var container = declaration.parent; if (declaration.flags & 112) { - if (!(container.kind === 194 || - (declaration.kind === 126 && hasKind(container, 131)))) { + if (!(container.kind === 196 || + (declaration.kind === 128 && hasKind(container, 133)))) { return undefined; } } else if (declaration.flags & 128) { - if (container.kind !== 194) { + if (container.kind !== 196) { return undefined; } } else if (declaration.flags & (1 | 2)) { - if (!(container.kind === 199 || container.kind === 210)) { + if (!(container.kind === 201 || container.kind === 220)) { return undefined; } } @@ -27799,18 +28483,18 @@ var ts; var modifierFlag = getFlagFromModifier(modifier); var nodes; switch (container.kind) { - case 199: - case 210: + case 201: + case 220: nodes = container.statements; break; - case 131: + case 133: nodes = container.parameters.concat(container.parent.members); break; - case 194: + case 196: nodes = container.members; if (modifierFlag & 112) { var constructor = ts.forEach(container.members, function (member) { - return member.kind === 131 && member; + return member.kind === 133 && member; }); if (constructor) { nodes = nodes.concat(constructor.parameters); @@ -27828,17 +28512,17 @@ var ts; return ts.map(keywords, getReferenceEntryFromNode); function getFlagFromModifier(modifier) { switch (modifier) { - case 107: + case 109: return 16; - case 105: + case 107: return 32; - case 106: - return 64; case 108: + return 64; + case 110: return 128; case 77: return 1; - case 113: + case 115: return 2; default: ts.Debug.fail(); @@ -27871,7 +28555,6 @@ var ts; } function findReferences(fileName, position, findInStrings, findInComments) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingPropertyName(sourceFile, position); if (!node) { @@ -27962,7 +28645,7 @@ var ts; return stripQuotes(name); } function getInternedName(symbol, declarations) { - var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 158 ? d : undefined; }); + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 160 ? d : undefined; }); if (functionExpression && functionExpression.name) { var name = functionExpression.name.text; } @@ -27983,7 +28666,7 @@ var ts; if (symbol.getFlags() && (4 | 8192)) { var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32) ? d : undefined; }); if (privateDeclaration) { - return ts.getAncestor(privateDeclaration, 194); + return ts.getAncestor(privateDeclaration, 196); } } if (symbol.parent || (symbol.getFlags() & 268435456)) { @@ -28000,7 +28683,7 @@ var ts; if (scope && scope !== container) { return undefined; } - if (container.kind === 210 && !ts.isExternalModule(container)) { + if (container.kind === 220 && !ts.isExternalModule(container)) { return undefined; } scope = container; @@ -28131,13 +28814,13 @@ var ts; } var staticFlag = 128; switch (searchSpaceNode.kind) { - case 128: - case 127: case 130: case 129: - case 131: case 132: + case 131: case 133: + case 134: + case 135: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; break; @@ -28164,31 +28847,31 @@ var ts; var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, false); var staticFlag = 128; switch (searchSpaceNode.kind) { - case 130: - case 129: + case 132: + case 131: if (ts.isObjectLiteralMethod(searchSpaceNode)) { break; } - case 128: - case 127: - case 131: - case 132: + case 130: + case 129: case 133: + case 134: + case 135: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; break; - case 210: + case 220: if (ts.isExternalModule(searchSpaceNode)) { return undefined; } - case 193: - case 158: + case 195: + case 160: break; default: return undefined; } var result = []; - if (searchSpaceNode.kind === 210) { + if (searchSpaceNode.kind === 220) { ts.forEach(sourceFiles, function (sourceFile) { var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, result); @@ -28209,25 +28892,25 @@ var ts; } var container = ts.getThisContainer(node, false); switch (searchSpaceNode.kind) { - case 158: - case 193: + case 160: + case 195: if (searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 130: - case 129: + case 132: + case 131: if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 194: + case 196: if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128) === staticFlag) { result.push(getReferenceEntryFromNode(node)); } break; - case 210: - if (container.kind === 210 && !ts.isExternalModule(container)) { + case 220: + if (container.kind === 220 && !ts.isExternalModule(container)) { result.push(getReferenceEntryFromNode(node)); } break; @@ -28259,11 +28942,11 @@ var ts; function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { if (symbol && symbol.flags & (32 | 64)) { ts.forEach(symbol.getDeclarations(), function (declaration) { - if (declaration.kind === 194) { + if (declaration.kind === 196) { getPropertySymbolFromTypeReference(ts.getClassBaseTypeNode(declaration)); ts.forEach(ts.getClassImplementedTypeNodes(declaration), getPropertySymbolFromTypeReference); } - else if (declaration.kind === 195) { + else if (declaration.kind === 197) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); } }); @@ -28369,10 +29052,10 @@ var ts; } var parent = node.parent; if (parent) { - if (parent.kind === 164 || parent.kind === 163) { + if (parent.kind === 166 || parent.kind === 165) { return true; } - else if (parent.kind === 165 && parent.left === node) { + else if (parent.kind === 167 && parent.left === node) { var operator = parent.operatorToken.kind; return 52 <= operator && operator <= 63; } @@ -28388,7 +29071,6 @@ var ts; } function getEmitOutput(fileName) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var outputFiles = []; function writeFile(fileName, data, writeByteOrderMark) { @@ -28406,33 +29088,33 @@ var ts; } function getMeaningFromDeclaration(node) { switch (node.kind) { - case 126: - case 191: - case 148: case 128: - case 127: - case 207: - case 208: - case 209: + case 193: + case 150: case 130: case 129: - case 131: + case 217: + case 218: + case 219: case 132: + case 131: case 133: - case 193: - case 158: - case 159: - case 206: - return 1; - case 125: + case 134: + case 135: case 195: - case 196: - case 141: - return 2; - case 194: + case 160: + case 161: + case 216: + return 1; + case 127: case 197: - return 1 | 2; case 198: + case 143: + return 2; + case 196: + case 199: + return 1 | 2; + case 200: if (node.name.kind === 8) { return 4 | 1; } @@ -28442,9 +29124,9 @@ var ts; else { return 4; } - case 200: + case 202: return 1 | 2 | 4; - case 210: + case 220: return 4 | 1; } ts.Debug.fail("Unknown declaration type"); @@ -28453,39 +29135,39 @@ var ts; if (isRightSideOfQualifiedName(node)) { node = node.parent; } - return node.parent.kind === 137; + return node.parent.kind === 139; } function isNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 123) { - while (root.parent && root.parent.kind === 123) + if (root.parent.kind === 125) { + while (root.parent && root.parent.kind === 125) root = root.parent; isLastClause = root.right === node; } - return root.parent.kind === 137 && !isLastClause; + return root.parent.kind === 139 && !isLastClause; } function isInRightSideOfImport(node) { - while (node.parent.kind === 123) { + while (node.parent.kind === 125) { node = node.parent; } - return ts.isInternalModuleImportDeclaration(node.parent) && node.parent.moduleReference === node; + return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; } - function getMeaningFromRightHandSideOfImport(node) { + function getMeaningFromRightHandSideOfImportEquals(node) { ts.Debug.assert(node.kind === 64); - if (node.parent.kind === 123 && + if (node.parent.kind === 125 && node.parent.right === node && - node.parent.parent.kind === 200) { + node.parent.parent.kind === 202) { return 1 | 2 | 4; } return 4; } function getMeaningFromLocation(node) { - if (node.parent.kind === 201) { + if (node.parent.kind === 208) { return 1 | 2 | 4; } else if (isInRightSideOfImport(node)) { - return getMeaningFromRightHandSideOfImport(node); + return getMeaningFromRightHandSideOfImportEquals(node); } else if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(node)) { return getMeaningFromDeclaration(node.parent); @@ -28502,24 +29184,21 @@ var ts; } function getSignatureHelpItems(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); return ts.SignatureHelp.getSignatureHelpItems(sourceFile, position, typeInfoResolver, cancellationToken); } - function getCurrentSourceFile(fileName) { - fileName = ts.normalizeSlashes(fileName); - var currentSourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return currentSourceFile; + function getSourceFile(fileName) { + return syntaxTreeCache.getCurrentSourceFile(fileName); } function getNameOrDottedNameSpan(fileName, startPos, endPos) { - fileName = ts.normalizeSlashes(fileName); - var node = ts.getTouchingPropertyName(getCurrentSourceFile(fileName), startPos); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, startPos); if (!node) { return; } switch (node.kind) { - case 151: - case 123: + case 153: + case 125: case 8: case 79: case 94: @@ -28537,7 +29216,7 @@ var ts; nodeForStartPos = nodeForStartPos.parent; } else if (isNameOfModuleDeclaration(nodeForStartPos)) { - if (nodeForStartPos.parent.parent.kind === 198 && + if (nodeForStartPos.parent.parent.kind === 200 && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { nodeForStartPos = nodeForStartPos.parent.parent.name; } @@ -28552,16 +29231,15 @@ var ts; return ts.createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd()); } function getBreakpointStatementAtPosition(fileName, position) { - fileName = ts.normalizeSlashes(fileName); - return ts.BreakpointResolver.spanInSourceFileAtLocation(getCurrentSourceFile(fileName), position); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position); } function getNavigationBarItems(fileName) { - fileName = ts.normalizeSlashes(fileName); - return ts.NavigationBar.getNavigationBarItems(getCurrentSourceFile(fileName)); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.NavigationBar.getNavigationBarItems(sourceFile); } function getSemanticClassifications(fileName, span) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var result = []; processNode(sourceFile); @@ -28594,7 +29272,7 @@ var ts; return undefined; function hasValueSideModule(symbol) { return ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 198 && ts.getModuleInstanceState(declaration) == 1; + return declaration.kind === 200 && ts.getModuleInstanceState(declaration) == 1; }); } } @@ -28617,8 +29295,7 @@ var ts; } } function getSyntacticClassifications(fileName, span) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); var triviaScanner = ts.createScanner(2, false, sourceFile.text); var mergeConflictScanner = ts.createScanner(2, false, sourceFile.text); var result = []; @@ -28713,16 +29390,16 @@ var ts; if (ts.isPunctuation(tokenKind)) { if (token) { if (tokenKind === 52) { - if (token.parent.kind === 191 || - token.parent.kind === 128 || - token.parent.kind === 126) { + if (token.parent.kind === 193 || + token.parent.kind === 130 || + token.parent.kind === 128) { return ClassificationTypeNames.operator; } } - if (token.parent.kind === 165 || - token.parent.kind === 163 || - token.parent.kind === 164 || - token.parent.kind === 166) { + if (token.parent.kind === 167 || + token.parent.kind === 165 || + token.parent.kind === 166 || + token.parent.kind === 168) { return ClassificationTypeNames.operator; } } @@ -28743,27 +29420,27 @@ var ts; else if (tokenKind === 64) { if (token) { switch (token.parent.kind) { - case 194: + case 196: if (token.parent.name === token) { return ClassificationTypeNames.className; } return; - case 125: + case 127: if (token.parent.name === token) { return ClassificationTypeNames.typeParameterName; } return; - case 195: + case 197: if (token.parent.name === token) { return ClassificationTypeNames.interfaceName; } return; - case 197: + case 199: if (token.parent.name === token) { return ClassificationTypeNames.enumName; } return; - case 198: + case 200: if (token.parent.name === token) { return ClassificationTypeNames.moduleName; } @@ -28789,12 +29466,11 @@ var ts; } } function getOutliningSpans(fileName) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.OutliningElementsCollector.collectElements(sourceFile); } function getBraceMatchingAtPosition(fileName, position) { - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); var result = []; var token = ts.getTouchingToken(sourceFile, position); if (token.getStart(sourceFile) === position) { @@ -28834,9 +29510,8 @@ var ts; } } function getIndentationAtPosition(fileName, position, editorOptions) { - fileName = ts.normalizeSlashes(fileName); var start = new Date().getTime(); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); log("getIndentationAtPosition: getCurrentSourceFile: " + (new Date().getTime() - start)); var start = new Date().getTime(); var result = ts.formatting.SmartIndenter.getIndentation(position, sourceFile, editorOptions); @@ -28844,18 +29519,15 @@ var ts; return result; } function getFormattingEditsForRange(fileName, start, end, options) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(options), options); } function getFormattingEditsForDocument(fileName, options) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options); } function getFormattingEditsAfterKeystroke(fileName, position, key, options) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); if (key === "}") { return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(options), options); } @@ -28869,7 +29541,6 @@ var ts; } function getTodoComments(fileName, descriptors) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); cancellationToken.throwIfCancellationRequested(); var fileContents = sourceFile.text; @@ -28929,7 +29600,6 @@ var ts; } function getRenameInfo(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingWord(sourceFile, position); if (node && node.kind === 64) { @@ -29003,7 +29673,7 @@ var ts; getFormattingEditsForDocument: getFormattingEditsForDocument, getFormattingEditsAfterKeystroke: getFormattingEditsAfterKeystroke, getEmitOutput: getEmitOutput, - getSourceFile: getCurrentSourceFile, + getSourceFile: getSourceFile, getProgram: getProgram }; } @@ -29026,19 +29696,19 @@ var ts; var templateStack = []; function isAccessibilityModifier(kind) { switch (kind) { + case 109: case 107: - case 105: - case 106: + case 108: return true; } return false; } function canFollow(keyword1, keyword2) { if (isAccessibilityModifier(keyword1)) { - if (keyword2 === 114 || - keyword2 === 118 || - keyword2 === 112 || - keyword2 === 108) { + if (keyword2 === 116 || + keyword2 === 120 || + keyword2 === 114 || + keyword2 === 110) { return true; } return false; @@ -29103,11 +29773,11 @@ var ts; else if (token === 25 && angleBracketStack > 0) { angleBracketStack--; } - else if (token === 110 || + else if (token === 112 || + token === 121 || token === 119 || - token === 117 || - token === 111 || - token === 120) { + token === 113 || + token === 122) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { token = 64; } @@ -29251,7 +29921,7 @@ var ts; } } function isKeyword(token) { - return token >= 65 && token <= 122; + return token >= 65 && token <= 124; } function classFromKind(token) { if (isKeyword(token)) { @@ -29300,7 +29970,7 @@ var ts; getNodeConstructor: function (kind) { function Node() { } - var proto = kind === 210 ? new SourceFileObject() : new NodeObject(); + var proto = kind === 220 ? new SourceFileObject() : new NodeObject(); proto.kind = kind; proto.pos = 0; proto.end = 0; @@ -29354,94 +30024,94 @@ var ts; function spanInNode(node) { if (node) { if (ts.isExpression(node)) { - if (node.parent.kind === 177) { + if (node.parent.kind === 179) { return spanInPreviousNode(node); } - if (node.parent.kind === 179) { + if (node.parent.kind === 181) { return textSpan(node); } - if (node.parent.kind === 165 && node.parent.operatorToken.kind === 23) { + if (node.parent.kind === 167 && node.parent.operatorToken.kind === 23) { return textSpan(node); } - if (node.parent.kind == 159 && node.parent.body == node) { + if (node.parent.kind == 161 && node.parent.body == node) { return textSpan(node); } } switch (node.kind) { - case 173: + case 175: return spanInVariableDeclaration(node.declarationList.declarations[0]); - case 191: - case 128: - case 127: - return spanInVariableDeclaration(node); - case 126: - return spanInParameterDeclaration(node); case 193: case 130: case 129: + return spanInVariableDeclaration(node); + case 128: + return spanInParameterDeclaration(node); + case 195: case 132: - case 133: case 131: - case 158: - case 159: + case 134: + case 135: + case 133: + case 160: + case 161: return spanInFunctionDeclaration(node); - case 172: + case 174: if (ts.isFunctionBlock(node)) { return spanInFunctionBlock(node); } - case 199: + case 201: return spanInBlock(node); - case 206: + case 216: return spanInBlock(node.block); - case 175: + case 177: return textSpan(node.expression); - case 184: + case 186: return textSpan(node.getChildAt(0), node.expression); + case 180: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 179: + return spanInNode(node.statement); + case 192: + return textSpan(node.getChildAt(0)); case 178: return textSpan(node, ts.findNextToken(node.expression, node)); - case 177: - return spanInNode(node.statement); - case 190: - return textSpan(node.getChildAt(0)); - case 176: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 187: - return spanInNode(node.statement); - case 183: - case 182: - return textSpan(node.getChildAt(0), node.label); - case 179: - return spanInForStatement(node); - case 180: - case 181: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 186: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 203: - case 204: - return spanInNode(node.statements[0]); case 189: - return spanInBlock(node.tryBlock); + return spanInNode(node.statement); + case 185: + case 184: + return textSpan(node.getChildAt(0), node.label); + case 181: + return spanInForStatement(node); + case 182: + case 183: + return textSpan(node, ts.findNextToken(node.expression, node)); case 188: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 213: + case 214: + return spanInNode(node.statements[0]); + case 191: + return spanInBlock(node.tryBlock); + case 190: return textSpan(node, node.expression); - case 201: + case 208: return textSpan(node, node.exportName); - case 200: + case 202: return textSpan(node, node.moduleReference); - case 198: + case 200: if (ts.getModuleInstanceState(node) !== 1) { return undefined; } - case 194: - case 197: - case 209: - case 153: - case 154: - return textSpan(node); - case 185: - return spanInNode(node.statement); - case 195: case 196: + case 199: + case 219: + case 155: + case 156: + return textSpan(node); + case 187: + return spanInNode(node.statement); + case 197: + case 198: return undefined; case 22: case 1: @@ -29468,10 +30138,10 @@ var ts; case 80: return spanInNextNode(node); default: - if (node.parent.kind === 207 && node.parent.name === node) { + if (node.parent.kind === 217 && node.parent.name === node) { return spanInNode(node.parent.initializer); } - if (node.parent.kind === 156 && node.parent.type === node) { + if (node.parent.kind === 158 && node.parent.type === node) { return spanInNode(node.parent.expression); } if (ts.isAnyFunction(node.parent) && node.parent.type === node) { @@ -29481,12 +30151,12 @@ var ts; } } function spanInVariableDeclaration(variableDeclaration) { - if (variableDeclaration.parent.parent.kind === 180 || - variableDeclaration.parent.parent.kind === 181) { + if (variableDeclaration.parent.parent.kind === 182 || + variableDeclaration.parent.parent.kind === 183) { return spanInNode(variableDeclaration.parent.parent); } - var isParentVariableStatement = variableDeclaration.parent.parent.kind === 173; - var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 179 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 175; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 181 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement ? variableDeclaration.parent.parent.initializer.declarations : undefined; if (variableDeclaration.initializer || (variableDeclaration.flags & 1)) { if (declarations && declarations[0] === variableDeclaration) { @@ -29528,7 +30198,7 @@ var ts; } function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { return !!(functionDeclaration.flags & 1) || - (functionDeclaration.parent.kind === 194 && functionDeclaration.kind !== 131); + (functionDeclaration.parent.kind === 196 && functionDeclaration.kind !== 133); } function spanInFunctionDeclaration(functionDeclaration) { if (!functionDeclaration.body) { @@ -29548,23 +30218,23 @@ var ts; } function spanInBlock(block) { switch (block.parent.kind) { - case 198: + case 200: if (ts.getModuleInstanceState(block.parent) !== 1) { return undefined; } - case 178: - case 176: case 180: - case 181: + case 178: + case 182: + case 183: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); - case 179: + case 181: 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 === 192) { + if (forStatement.initializer.kind === 194) { var variableDeclarationList = forStatement.initializer; if (variableDeclarationList.declarations.length > 0) { return spanInNode(variableDeclarationList.declarations[0]); @@ -29583,34 +30253,34 @@ var ts; } function spanInOpenBraceToken(node) { switch (node.parent.kind) { - case 197: + case 199: var enumDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); - case 194: + case 196: var classDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); - case 186: + case 188: return spanInNodeIfStartsOnSameLine(node.parent, node.parent.clauses[0]); } return spanInNode(node.parent); } function spanInCloseBraceToken(node) { switch (node.parent.kind) { - case 199: + case 201: if (ts.getModuleInstanceState(node.parent.parent) !== 1) { return undefined; } - case 197: - case 194: + case 199: + case 196: return textSpan(node); - case 172: + case 174: if (ts.isFunctionBlock(node.parent)) { return textSpan(node); } - case 206: + case 216: return spanInNode(node.parent.statements[node.parent.statements.length - 1]); ; - case 186: + case 188: var switchStatement = node.parent; var lastClause = switchStatement.clauses[switchStatement.clauses.length - 1]; if (lastClause) { @@ -29622,24 +30292,24 @@ var ts; } } function spanInOpenParenToken(node) { - if (node.parent.kind === 177) { + if (node.parent.kind === 179) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInCloseParenToken(node) { switch (node.parent.kind) { - case 158: - case 193: - case 159: - case 130: - case 129: + case 160: + case 195: + case 161: case 132: - case 133: case 131: - case 178: - case 177: + case 134: + case 135: + case 133: + case 180: case 179: + case 181: return spanInPreviousNode(node); default: return spanInNode(node.parent); @@ -29647,19 +30317,19 @@ var ts; return spanInNode(node.parent); } function spanInColonToken(node) { - if (ts.isAnyFunction(node.parent) || node.parent.kind === 207) { + if (ts.isAnyFunction(node.parent) || node.parent.kind === 217) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInGreaterThanOrLessThanToken(node) { - if (node.parent.kind === 156) { + if (node.parent.kind === 158) { return spanInNode(node.parent.expression); } return spanInNode(node.parent); } function spanInWhileKeyword(node) { - if (node.parent.kind === 177) { + if (node.parent.kind === 179) { return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); } return spanInNode(node.parent); @@ -29752,7 +30422,12 @@ var ts; return this.shimHost.getCurrentDirectory(); }; LanguageServiceShimHostAdapter.prototype.getDefaultLibFileName = function (options) { - return this.shimHost.getDefaultLibFileName(JSON.stringify(options)); + try { + return this.shimHost.getDefaultLibFileName(JSON.stringify(options)); + } + catch (e) { + return ""; + } }; return LanguageServiceShimHostAdapter; })(); diff --git a/bin/typescriptServices.d.ts b/bin/typescriptServices.d.ts index 4421c8d7255..81c5bac2d03 100644 --- a/bin/typescriptServices.d.ts +++ b/bin/typescriptServices.d.ts @@ -123,132 +123,142 @@ declare module ts { VoidKeyword = 98, WhileKeyword = 99, WithKeyword = 100, - ImplementsKeyword = 101, - InterfaceKeyword = 102, - LetKeyword = 103, - PackageKeyword = 104, - PrivateKeyword = 105, - ProtectedKeyword = 106, - PublicKeyword = 107, - StaticKeyword = 108, - YieldKeyword = 109, - AnyKeyword = 110, - BooleanKeyword = 111, - ConstructorKeyword = 112, - DeclareKeyword = 113, - GetKeyword = 114, - ModuleKeyword = 115, - RequireKeyword = 116, - NumberKeyword = 117, - SetKeyword = 118, - StringKeyword = 119, - SymbolKeyword = 120, - TypeKeyword = 121, - OfKeyword = 122, - QualifiedName = 123, - ComputedPropertyName = 124, - TypeParameter = 125, - Parameter = 126, - PropertySignature = 127, - PropertyDeclaration = 128, - MethodSignature = 129, - MethodDeclaration = 130, - Constructor = 131, - GetAccessor = 132, - SetAccessor = 133, - CallSignature = 134, - ConstructSignature = 135, - IndexSignature = 136, - TypeReference = 137, - FunctionType = 138, - ConstructorType = 139, - TypeQuery = 140, - TypeLiteral = 141, - ArrayType = 142, - TupleType = 143, - UnionType = 144, - ParenthesizedType = 145, - ObjectBindingPattern = 146, - ArrayBindingPattern = 147, - BindingElement = 148, - ArrayLiteralExpression = 149, - ObjectLiteralExpression = 150, - PropertyAccessExpression = 151, - ElementAccessExpression = 152, - CallExpression = 153, - NewExpression = 154, - TaggedTemplateExpression = 155, - TypeAssertionExpression = 156, - ParenthesizedExpression = 157, - FunctionExpression = 158, - ArrowFunction = 159, - DeleteExpression = 160, - TypeOfExpression = 161, - VoidExpression = 162, - PrefixUnaryExpression = 163, - PostfixUnaryExpression = 164, - BinaryExpression = 165, - ConditionalExpression = 166, - TemplateExpression = 167, - YieldExpression = 168, - SpreadElementExpression = 169, - OmittedExpression = 170, - TemplateSpan = 171, - Block = 172, - VariableStatement = 173, - EmptyStatement = 174, - ExpressionStatement = 175, - IfStatement = 176, - DoStatement = 177, - WhileStatement = 178, - ForStatement = 179, - ForInStatement = 180, - ForOfStatement = 181, - ContinueStatement = 182, - BreakStatement = 183, - ReturnStatement = 184, - WithStatement = 185, - SwitchStatement = 186, - LabeledStatement = 187, - ThrowStatement = 188, - TryStatement = 189, - DebuggerStatement = 190, - VariableDeclaration = 191, - VariableDeclarationList = 192, - FunctionDeclaration = 193, - ClassDeclaration = 194, - InterfaceDeclaration = 195, - TypeAliasDeclaration = 196, - EnumDeclaration = 197, - ModuleDeclaration = 198, - ModuleBlock = 199, - ImportDeclaration = 200, - ExportAssignment = 201, - ExternalModuleReference = 202, - CaseClause = 203, - DefaultClause = 204, - HeritageClause = 205, - CatchClause = 206, - PropertyAssignment = 207, - ShorthandPropertyAssignment = 208, - EnumMember = 209, - SourceFile = 210, - SyntaxList = 211, - Count = 212, + AsKeyword = 101, + FromKeyword = 102, + ImplementsKeyword = 103, + InterfaceKeyword = 104, + LetKeyword = 105, + PackageKeyword = 106, + PrivateKeyword = 107, + ProtectedKeyword = 108, + PublicKeyword = 109, + StaticKeyword = 110, + YieldKeyword = 111, + AnyKeyword = 112, + BooleanKeyword = 113, + ConstructorKeyword = 114, + DeclareKeyword = 115, + GetKeyword = 116, + ModuleKeyword = 117, + RequireKeyword = 118, + NumberKeyword = 119, + SetKeyword = 120, + StringKeyword = 121, + SymbolKeyword = 122, + TypeKeyword = 123, + OfKeyword = 124, + QualifiedName = 125, + ComputedPropertyName = 126, + TypeParameter = 127, + Parameter = 128, + PropertySignature = 129, + PropertyDeclaration = 130, + MethodSignature = 131, + MethodDeclaration = 132, + Constructor = 133, + GetAccessor = 134, + SetAccessor = 135, + CallSignature = 136, + ConstructSignature = 137, + IndexSignature = 138, + TypeReference = 139, + FunctionType = 140, + ConstructorType = 141, + TypeQuery = 142, + TypeLiteral = 143, + ArrayType = 144, + TupleType = 145, + UnionType = 146, + ParenthesizedType = 147, + ObjectBindingPattern = 148, + ArrayBindingPattern = 149, + BindingElement = 150, + ArrayLiteralExpression = 151, + ObjectLiteralExpression = 152, + PropertyAccessExpression = 153, + ElementAccessExpression = 154, + CallExpression = 155, + NewExpression = 156, + TaggedTemplateExpression = 157, + TypeAssertionExpression = 158, + ParenthesizedExpression = 159, + FunctionExpression = 160, + ArrowFunction = 161, + DeleteExpression = 162, + TypeOfExpression = 163, + VoidExpression = 164, + PrefixUnaryExpression = 165, + PostfixUnaryExpression = 166, + BinaryExpression = 167, + ConditionalExpression = 168, + TemplateExpression = 169, + YieldExpression = 170, + SpreadElementExpression = 171, + OmittedExpression = 172, + TemplateSpan = 173, + Block = 174, + VariableStatement = 175, + EmptyStatement = 176, + ExpressionStatement = 177, + IfStatement = 178, + DoStatement = 179, + WhileStatement = 180, + ForStatement = 181, + ForInStatement = 182, + ForOfStatement = 183, + ContinueStatement = 184, + BreakStatement = 185, + ReturnStatement = 186, + WithStatement = 187, + SwitchStatement = 188, + LabeledStatement = 189, + ThrowStatement = 190, + TryStatement = 191, + DebuggerStatement = 192, + VariableDeclaration = 193, + VariableDeclarationList = 194, + FunctionDeclaration = 195, + ClassDeclaration = 196, + InterfaceDeclaration = 197, + TypeAliasDeclaration = 198, + EnumDeclaration = 199, + ModuleDeclaration = 200, + ModuleBlock = 201, + ImportEqualsDeclaration = 202, + ImportDeclaration = 203, + ImportClause = 204, + NamespaceImport = 205, + NamedImports = 206, + ImportSpecifier = 207, + ExportAssignment = 208, + ExportDeclaration = 209, + NamedExports = 210, + ExportSpecifier = 211, + ExternalModuleReference = 212, + CaseClause = 213, + DefaultClause = 214, + HeritageClause = 215, + CatchClause = 216, + PropertyAssignment = 217, + ShorthandPropertyAssignment = 218, + EnumMember = 219, + SourceFile = 220, + SyntaxList = 221, + Count = 222, FirstAssignment = 52, LastAssignment = 63, FirstReservedWord = 65, LastReservedWord = 100, FirstKeyword = 65, - LastKeyword = 122, - FirstFutureReservedWord = 101, - LastFutureReservedWord = 109, - FirstTypeNode = 137, - LastTypeNode = 145, + LastKeyword = 124, + FirstFutureReservedWord = 103, + LastFutureReservedWord = 111, + FirstTypeNode = 139, + LastTypeNode = 147, FirstPunctuation = 14, LastPunctuation = 63, FirstToken = 0, - LastToken = 122, + LastToken = 124, FirstTriviaToken = 2, LastTriviaToken = 6, FirstLiteralToken = 7, @@ -257,7 +267,7 @@ declare module ts { LastTemplateToken = 13, FirstBinaryOperator = 24, LastBinaryOperator = 63, - FirstNode = 123, + FirstNode = 125, } const enum NodeFlags { Export = 1, @@ -295,13 +305,13 @@ declare module ts { kind: SyntaxKind; flags: NodeFlags; parserContextFlags?: ParserContextFlags; + modifiers?: ModifiersArray; id?: number; parent?: Node; symbol?: Symbol; locals?: SymbolTable; nextContainer?: Node; localSymbol?: Symbol; - modifiers?: ModifiersArray; } interface NodeArray extends Array, TextRange { hasTrailingComma?: boolean; @@ -665,20 +675,49 @@ declare module ts { name: Identifier; members: NodeArray; } - interface ModuleDeclaration extends Declaration, ModuleElement { + interface ExportContainer { + exportStars?: ExportDeclaration[]; + } + interface ModuleDeclaration extends Declaration, ModuleElement, ExportContainer { name: Identifier | LiteralExpression; body: ModuleBlock | ModuleDeclaration; } interface ModuleBlock extends Node, ModuleElement { statements: NodeArray; } - interface ImportDeclaration extends Declaration, ModuleElement { + interface ImportEqualsDeclaration extends Declaration, ModuleElement { name: Identifier; moduleReference: EntityName | ExternalModuleReference; } interface ExternalModuleReference extends Node { expression?: Expression; } + interface ImportDeclaration extends Statement, ModuleElement { + importClause?: ImportClause; + moduleSpecifier: Expression; + } + interface ImportClause extends Declaration { + name?: Identifier; + namedBindings?: NamespaceImport | NamedImports; + } + interface NamespaceImport extends Declaration { + name: Identifier; + } + interface ExportDeclaration extends Statement, ModuleElement { + exportClause?: NamedExports; + moduleSpecifier?: Expression; + } + interface NamedImportsOrExports extends Node { + elements: NodeArray; + } + type NamedImports = NamedImportsOrExports; + type NamedExports = NamedImportsOrExports; + interface ImportOrExportSpecifier extends Declaration { + propertyName?: Identifier; + name: Identifier; + } + type ImportSpecifier = ImportOrExportSpecifier; + type ExportSpecifier = ImportOrExportSpecifier; interface ExportAssignment extends Statement, ModuleElement { exportName: Identifier; } @@ -688,7 +727,7 @@ declare module ts { interface CommentRange extends TextRange { hasTrailingNewLine?: boolean; } - interface SourceFile extends Declaration { + interface SourceFile extends Declaration, ExportContainer { statements: NodeArray; endOfFileToken: Node; fileName: string; @@ -842,7 +881,7 @@ declare module ts { } interface SymbolVisibilityResult { accessibility: SymbolAccessibility; - aliasesToMakeVisible?: ImportDeclaration[]; + aliasesToMakeVisible?: ImportEqualsDeclaration[]; errorSymbolName?: string; errorNode?: Node; } @@ -850,11 +889,11 @@ declare module ts { errorModuleName?: string; } interface EmitResolver { - getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string; - getExpressionNamePrefix(node: Identifier): string; + getGeneratedNameForNode(node: ModuleDeclaration | EnumDeclaration | ImportDeclaration | ExportDeclaration): string; + getExpressionNameSubstitution(node: Identifier): string; getExportAssignmentName(node: SourceFile): string; - isReferencedImportDeclaration(node: ImportDeclaration): boolean; - isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean; + isReferencedImportDeclaration(node: Node): boolean; + isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean; getNodeCheckFlags(node: Node): NodeCheckFlags; isDeclarationVisible(node: Declaration): boolean; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; @@ -949,8 +988,10 @@ declare module ts { declaredType?: Type; mapper?: TypeMapper; referenced?: boolean; - exportAssignSymbol?: Symbol; + exportAssignmentChecked?: boolean; + exportAssignmentSymbol?: Symbol; unionType?: UnionType; + resolvedExports?: SymbolTable; } interface TransientSymbol extends Symbol, SymbolLinks { } @@ -975,7 +1016,8 @@ declare module ts { enumMemberValue?: number; isIllegalTypeReferenceInConstraint?: boolean; isVisible?: boolean; - localModuleName?: string; + generatedName?: string; + generatedNames?: Map; assignmentChecks?: Map; hasReportedStatementInAmbientContext?: boolean; importOnRightSide?: Symbol; @@ -1560,6 +1602,7 @@ declare module ts { kind: string; kindModifiers: string; matchKind: string; + isCaseSensitive: boolean; fileName: string; textSpan: TextSpan; containerName: string; diff --git a/bin/typescriptServices.js b/bin/typescriptServices.js index 1d2c9f37ac8..4ee694a8f19 100644 --- a/bin/typescriptServices.js +++ b/bin/typescriptServices.js @@ -117,132 +117,142 @@ var ts; SyntaxKind[SyntaxKind["VoidKeyword"] = 98] = "VoidKeyword"; SyntaxKind[SyntaxKind["WhileKeyword"] = 99] = "WhileKeyword"; SyntaxKind[SyntaxKind["WithKeyword"] = 100] = "WithKeyword"; - SyntaxKind[SyntaxKind["ImplementsKeyword"] = 101] = "ImplementsKeyword"; - SyntaxKind[SyntaxKind["InterfaceKeyword"] = 102] = "InterfaceKeyword"; - SyntaxKind[SyntaxKind["LetKeyword"] = 103] = "LetKeyword"; - SyntaxKind[SyntaxKind["PackageKeyword"] = 104] = "PackageKeyword"; - SyntaxKind[SyntaxKind["PrivateKeyword"] = 105] = "PrivateKeyword"; - SyntaxKind[SyntaxKind["ProtectedKeyword"] = 106] = "ProtectedKeyword"; - SyntaxKind[SyntaxKind["PublicKeyword"] = 107] = "PublicKeyword"; - SyntaxKind[SyntaxKind["StaticKeyword"] = 108] = "StaticKeyword"; - SyntaxKind[SyntaxKind["YieldKeyword"] = 109] = "YieldKeyword"; - SyntaxKind[SyntaxKind["AnyKeyword"] = 110] = "AnyKeyword"; - SyntaxKind[SyntaxKind["BooleanKeyword"] = 111] = "BooleanKeyword"; - SyntaxKind[SyntaxKind["ConstructorKeyword"] = 112] = "ConstructorKeyword"; - SyntaxKind[SyntaxKind["DeclareKeyword"] = 113] = "DeclareKeyword"; - SyntaxKind[SyntaxKind["GetKeyword"] = 114] = "GetKeyword"; - SyntaxKind[SyntaxKind["ModuleKeyword"] = 115] = "ModuleKeyword"; - SyntaxKind[SyntaxKind["RequireKeyword"] = 116] = "RequireKeyword"; - SyntaxKind[SyntaxKind["NumberKeyword"] = 117] = "NumberKeyword"; - SyntaxKind[SyntaxKind["SetKeyword"] = 118] = "SetKeyword"; - SyntaxKind[SyntaxKind["StringKeyword"] = 119] = "StringKeyword"; - SyntaxKind[SyntaxKind["SymbolKeyword"] = 120] = "SymbolKeyword"; - SyntaxKind[SyntaxKind["TypeKeyword"] = 121] = "TypeKeyword"; - SyntaxKind[SyntaxKind["OfKeyword"] = 122] = "OfKeyword"; - SyntaxKind[SyntaxKind["QualifiedName"] = 123] = "QualifiedName"; - SyntaxKind[SyntaxKind["ComputedPropertyName"] = 124] = "ComputedPropertyName"; - SyntaxKind[SyntaxKind["TypeParameter"] = 125] = "TypeParameter"; - SyntaxKind[SyntaxKind["Parameter"] = 126] = "Parameter"; - SyntaxKind[SyntaxKind["PropertySignature"] = 127] = "PropertySignature"; - SyntaxKind[SyntaxKind["PropertyDeclaration"] = 128] = "PropertyDeclaration"; - SyntaxKind[SyntaxKind["MethodSignature"] = 129] = "MethodSignature"; - SyntaxKind[SyntaxKind["MethodDeclaration"] = 130] = "MethodDeclaration"; - SyntaxKind[SyntaxKind["Constructor"] = 131] = "Constructor"; - SyntaxKind[SyntaxKind["GetAccessor"] = 132] = "GetAccessor"; - SyntaxKind[SyntaxKind["SetAccessor"] = 133] = "SetAccessor"; - SyntaxKind[SyntaxKind["CallSignature"] = 134] = "CallSignature"; - SyntaxKind[SyntaxKind["ConstructSignature"] = 135] = "ConstructSignature"; - SyntaxKind[SyntaxKind["IndexSignature"] = 136] = "IndexSignature"; - SyntaxKind[SyntaxKind["TypeReference"] = 137] = "TypeReference"; - SyntaxKind[SyntaxKind["FunctionType"] = 138] = "FunctionType"; - SyntaxKind[SyntaxKind["ConstructorType"] = 139] = "ConstructorType"; - SyntaxKind[SyntaxKind["TypeQuery"] = 140] = "TypeQuery"; - SyntaxKind[SyntaxKind["TypeLiteral"] = 141] = "TypeLiteral"; - SyntaxKind[SyntaxKind["ArrayType"] = 142] = "ArrayType"; - SyntaxKind[SyntaxKind["TupleType"] = 143] = "TupleType"; - SyntaxKind[SyntaxKind["UnionType"] = 144] = "UnionType"; - SyntaxKind[SyntaxKind["ParenthesizedType"] = 145] = "ParenthesizedType"; - SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 146] = "ObjectBindingPattern"; - SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 147] = "ArrayBindingPattern"; - SyntaxKind[SyntaxKind["BindingElement"] = 148] = "BindingElement"; - SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 149] = "ArrayLiteralExpression"; - SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 150] = "ObjectLiteralExpression"; - SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 151] = "PropertyAccessExpression"; - SyntaxKind[SyntaxKind["ElementAccessExpression"] = 152] = "ElementAccessExpression"; - SyntaxKind[SyntaxKind["CallExpression"] = 153] = "CallExpression"; - SyntaxKind[SyntaxKind["NewExpression"] = 154] = "NewExpression"; - SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 155] = "TaggedTemplateExpression"; - SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 156] = "TypeAssertionExpression"; - SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 157] = "ParenthesizedExpression"; - SyntaxKind[SyntaxKind["FunctionExpression"] = 158] = "FunctionExpression"; - SyntaxKind[SyntaxKind["ArrowFunction"] = 159] = "ArrowFunction"; - SyntaxKind[SyntaxKind["DeleteExpression"] = 160] = "DeleteExpression"; - SyntaxKind[SyntaxKind["TypeOfExpression"] = 161] = "TypeOfExpression"; - SyntaxKind[SyntaxKind["VoidExpression"] = 162] = "VoidExpression"; - SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 163] = "PrefixUnaryExpression"; - SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 164] = "PostfixUnaryExpression"; - SyntaxKind[SyntaxKind["BinaryExpression"] = 165] = "BinaryExpression"; - SyntaxKind[SyntaxKind["ConditionalExpression"] = 166] = "ConditionalExpression"; - SyntaxKind[SyntaxKind["TemplateExpression"] = 167] = "TemplateExpression"; - SyntaxKind[SyntaxKind["YieldExpression"] = 168] = "YieldExpression"; - SyntaxKind[SyntaxKind["SpreadElementExpression"] = 169] = "SpreadElementExpression"; - SyntaxKind[SyntaxKind["OmittedExpression"] = 170] = "OmittedExpression"; - SyntaxKind[SyntaxKind["TemplateSpan"] = 171] = "TemplateSpan"; - SyntaxKind[SyntaxKind["Block"] = 172] = "Block"; - SyntaxKind[SyntaxKind["VariableStatement"] = 173] = "VariableStatement"; - SyntaxKind[SyntaxKind["EmptyStatement"] = 174] = "EmptyStatement"; - SyntaxKind[SyntaxKind["ExpressionStatement"] = 175] = "ExpressionStatement"; - SyntaxKind[SyntaxKind["IfStatement"] = 176] = "IfStatement"; - SyntaxKind[SyntaxKind["DoStatement"] = 177] = "DoStatement"; - SyntaxKind[SyntaxKind["WhileStatement"] = 178] = "WhileStatement"; - SyntaxKind[SyntaxKind["ForStatement"] = 179] = "ForStatement"; - SyntaxKind[SyntaxKind["ForInStatement"] = 180] = "ForInStatement"; - SyntaxKind[SyntaxKind["ForOfStatement"] = 181] = "ForOfStatement"; - SyntaxKind[SyntaxKind["ContinueStatement"] = 182] = "ContinueStatement"; - SyntaxKind[SyntaxKind["BreakStatement"] = 183] = "BreakStatement"; - SyntaxKind[SyntaxKind["ReturnStatement"] = 184] = "ReturnStatement"; - SyntaxKind[SyntaxKind["WithStatement"] = 185] = "WithStatement"; - SyntaxKind[SyntaxKind["SwitchStatement"] = 186] = "SwitchStatement"; - SyntaxKind[SyntaxKind["LabeledStatement"] = 187] = "LabeledStatement"; - SyntaxKind[SyntaxKind["ThrowStatement"] = 188] = "ThrowStatement"; - SyntaxKind[SyntaxKind["TryStatement"] = 189] = "TryStatement"; - SyntaxKind[SyntaxKind["DebuggerStatement"] = 190] = "DebuggerStatement"; - SyntaxKind[SyntaxKind["VariableDeclaration"] = 191] = "VariableDeclaration"; - SyntaxKind[SyntaxKind["VariableDeclarationList"] = 192] = "VariableDeclarationList"; - SyntaxKind[SyntaxKind["FunctionDeclaration"] = 193] = "FunctionDeclaration"; - SyntaxKind[SyntaxKind["ClassDeclaration"] = 194] = "ClassDeclaration"; - SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 195] = "InterfaceDeclaration"; - SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 196] = "TypeAliasDeclaration"; - SyntaxKind[SyntaxKind["EnumDeclaration"] = 197] = "EnumDeclaration"; - SyntaxKind[SyntaxKind["ModuleDeclaration"] = 198] = "ModuleDeclaration"; - SyntaxKind[SyntaxKind["ModuleBlock"] = 199] = "ModuleBlock"; - SyntaxKind[SyntaxKind["ImportDeclaration"] = 200] = "ImportDeclaration"; - SyntaxKind[SyntaxKind["ExportAssignment"] = 201] = "ExportAssignment"; - SyntaxKind[SyntaxKind["ExternalModuleReference"] = 202] = "ExternalModuleReference"; - SyntaxKind[SyntaxKind["CaseClause"] = 203] = "CaseClause"; - SyntaxKind[SyntaxKind["DefaultClause"] = 204] = "DefaultClause"; - SyntaxKind[SyntaxKind["HeritageClause"] = 205] = "HeritageClause"; - SyntaxKind[SyntaxKind["CatchClause"] = 206] = "CatchClause"; - SyntaxKind[SyntaxKind["PropertyAssignment"] = 207] = "PropertyAssignment"; - SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 208] = "ShorthandPropertyAssignment"; - SyntaxKind[SyntaxKind["EnumMember"] = 209] = "EnumMember"; - SyntaxKind[SyntaxKind["SourceFile"] = 210] = "SourceFile"; - SyntaxKind[SyntaxKind["SyntaxList"] = 211] = "SyntaxList"; - SyntaxKind[SyntaxKind["Count"] = 212] = "Count"; + SyntaxKind[SyntaxKind["AsKeyword"] = 101] = "AsKeyword"; + SyntaxKind[SyntaxKind["FromKeyword"] = 102] = "FromKeyword"; + SyntaxKind[SyntaxKind["ImplementsKeyword"] = 103] = "ImplementsKeyword"; + SyntaxKind[SyntaxKind["InterfaceKeyword"] = 104] = "InterfaceKeyword"; + SyntaxKind[SyntaxKind["LetKeyword"] = 105] = "LetKeyword"; + SyntaxKind[SyntaxKind["PackageKeyword"] = 106] = "PackageKeyword"; + SyntaxKind[SyntaxKind["PrivateKeyword"] = 107] = "PrivateKeyword"; + SyntaxKind[SyntaxKind["ProtectedKeyword"] = 108] = "ProtectedKeyword"; + SyntaxKind[SyntaxKind["PublicKeyword"] = 109] = "PublicKeyword"; + SyntaxKind[SyntaxKind["StaticKeyword"] = 110] = "StaticKeyword"; + SyntaxKind[SyntaxKind["YieldKeyword"] = 111] = "YieldKeyword"; + SyntaxKind[SyntaxKind["AnyKeyword"] = 112] = "AnyKeyword"; + SyntaxKind[SyntaxKind["BooleanKeyword"] = 113] = "BooleanKeyword"; + SyntaxKind[SyntaxKind["ConstructorKeyword"] = 114] = "ConstructorKeyword"; + SyntaxKind[SyntaxKind["DeclareKeyword"] = 115] = "DeclareKeyword"; + SyntaxKind[SyntaxKind["GetKeyword"] = 116] = "GetKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 117] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 118] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 119] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 120] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 121] = "StringKeyword"; + SyntaxKind[SyntaxKind["SymbolKeyword"] = 122] = "SymbolKeyword"; + SyntaxKind[SyntaxKind["TypeKeyword"] = 123] = "TypeKeyword"; + SyntaxKind[SyntaxKind["OfKeyword"] = 124] = "OfKeyword"; + SyntaxKind[SyntaxKind["QualifiedName"] = 125] = "QualifiedName"; + SyntaxKind[SyntaxKind["ComputedPropertyName"] = 126] = "ComputedPropertyName"; + SyntaxKind[SyntaxKind["TypeParameter"] = 127] = "TypeParameter"; + SyntaxKind[SyntaxKind["Parameter"] = 128] = "Parameter"; + SyntaxKind[SyntaxKind["PropertySignature"] = 129] = "PropertySignature"; + SyntaxKind[SyntaxKind["PropertyDeclaration"] = 130] = "PropertyDeclaration"; + SyntaxKind[SyntaxKind["MethodSignature"] = 131] = "MethodSignature"; + SyntaxKind[SyntaxKind["MethodDeclaration"] = 132] = "MethodDeclaration"; + SyntaxKind[SyntaxKind["Constructor"] = 133] = "Constructor"; + SyntaxKind[SyntaxKind["GetAccessor"] = 134] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 135] = "SetAccessor"; + SyntaxKind[SyntaxKind["CallSignature"] = 136] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 137] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 138] = "IndexSignature"; + SyntaxKind[SyntaxKind["TypeReference"] = 139] = "TypeReference"; + SyntaxKind[SyntaxKind["FunctionType"] = 140] = "FunctionType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 141] = "ConstructorType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 142] = "TypeQuery"; + SyntaxKind[SyntaxKind["TypeLiteral"] = 143] = "TypeLiteral"; + SyntaxKind[SyntaxKind["ArrayType"] = 144] = "ArrayType"; + SyntaxKind[SyntaxKind["TupleType"] = 145] = "TupleType"; + SyntaxKind[SyntaxKind["UnionType"] = 146] = "UnionType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 147] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 148] = "ObjectBindingPattern"; + SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 149] = "ArrayBindingPattern"; + SyntaxKind[SyntaxKind["BindingElement"] = 150] = "BindingElement"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 151] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 152] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 153] = "PropertyAccessExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 154] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["CallExpression"] = 155] = "CallExpression"; + SyntaxKind[SyntaxKind["NewExpression"] = 156] = "NewExpression"; + SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 157] = "TaggedTemplateExpression"; + SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 158] = "TypeAssertionExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 159] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 160] = "FunctionExpression"; + SyntaxKind[SyntaxKind["ArrowFunction"] = 161] = "ArrowFunction"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 162] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 163] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 164] = "VoidExpression"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 165] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 166] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 167] = "BinaryExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 168] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 169] = "TemplateExpression"; + SyntaxKind[SyntaxKind["YieldExpression"] = 170] = "YieldExpression"; + SyntaxKind[SyntaxKind["SpreadElementExpression"] = 171] = "SpreadElementExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 172] = "OmittedExpression"; + SyntaxKind[SyntaxKind["TemplateSpan"] = 173] = "TemplateSpan"; + SyntaxKind[SyntaxKind["Block"] = 174] = "Block"; + SyntaxKind[SyntaxKind["VariableStatement"] = 175] = "VariableStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 176] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 177] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["IfStatement"] = 178] = "IfStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 179] = "DoStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 180] = "WhileStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 181] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 182] = "ForInStatement"; + SyntaxKind[SyntaxKind["ForOfStatement"] = 183] = "ForOfStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 184] = "ContinueStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 185] = "BreakStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 186] = "ReturnStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 187] = "WithStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 188] = "SwitchStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 189] = "LabeledStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 190] = "ThrowStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 191] = "TryStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 192] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 193] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarationList"] = 194] = "VariableDeclarationList"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 195] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 196] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 197] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 198] = "TypeAliasDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 199] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 200] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ModuleBlock"] = 201] = "ModuleBlock"; + SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 202] = "ImportEqualsDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 203] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ImportClause"] = 204] = "ImportClause"; + SyntaxKind[SyntaxKind["NamespaceImport"] = 205] = "NamespaceImport"; + SyntaxKind[SyntaxKind["NamedImports"] = 206] = "NamedImports"; + SyntaxKind[SyntaxKind["ImportSpecifier"] = 207] = "ImportSpecifier"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 208] = "ExportAssignment"; + SyntaxKind[SyntaxKind["ExportDeclaration"] = 209] = "ExportDeclaration"; + SyntaxKind[SyntaxKind["NamedExports"] = 210] = "NamedExports"; + SyntaxKind[SyntaxKind["ExportSpecifier"] = 211] = "ExportSpecifier"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 212] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["CaseClause"] = 213] = "CaseClause"; + SyntaxKind[SyntaxKind["DefaultClause"] = 214] = "DefaultClause"; + SyntaxKind[SyntaxKind["HeritageClause"] = 215] = "HeritageClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 216] = "CatchClause"; + SyntaxKind[SyntaxKind["PropertyAssignment"] = 217] = "PropertyAssignment"; + SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 218] = "ShorthandPropertyAssignment"; + SyntaxKind[SyntaxKind["EnumMember"] = 219] = "EnumMember"; + SyntaxKind[SyntaxKind["SourceFile"] = 220] = "SourceFile"; + SyntaxKind[SyntaxKind["SyntaxList"] = 221] = "SyntaxList"; + SyntaxKind[SyntaxKind["Count"] = 222] = "Count"; SyntaxKind[SyntaxKind["FirstAssignment"] = 52] = "FirstAssignment"; SyntaxKind[SyntaxKind["LastAssignment"] = 63] = "LastAssignment"; SyntaxKind[SyntaxKind["FirstReservedWord"] = 65] = "FirstReservedWord"; SyntaxKind[SyntaxKind["LastReservedWord"] = 100] = "LastReservedWord"; SyntaxKind[SyntaxKind["FirstKeyword"] = 65] = "FirstKeyword"; - SyntaxKind[SyntaxKind["LastKeyword"] = 122] = "LastKeyword"; - SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 101] = "FirstFutureReservedWord"; - SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 109] = "LastFutureReservedWord"; - SyntaxKind[SyntaxKind["FirstTypeNode"] = 137] = "FirstTypeNode"; - SyntaxKind[SyntaxKind["LastTypeNode"] = 145] = "LastTypeNode"; + SyntaxKind[SyntaxKind["LastKeyword"] = 124] = "LastKeyword"; + SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 103] = "FirstFutureReservedWord"; + SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 111] = "LastFutureReservedWord"; + SyntaxKind[SyntaxKind["FirstTypeNode"] = 139] = "FirstTypeNode"; + SyntaxKind[SyntaxKind["LastTypeNode"] = 147] = "LastTypeNode"; SyntaxKind[SyntaxKind["FirstPunctuation"] = 14] = "FirstPunctuation"; SyntaxKind[SyntaxKind["LastPunctuation"] = 63] = "LastPunctuation"; SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken"; - SyntaxKind[SyntaxKind["LastToken"] = 122] = "LastToken"; + SyntaxKind[SyntaxKind["LastToken"] = 124] = "LastToken"; SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken"; SyntaxKind[SyntaxKind["LastTriviaToken"] = 6] = "LastTriviaToken"; SyntaxKind[SyntaxKind["FirstLiteralToken"] = 7] = "FirstLiteralToken"; @@ -251,7 +261,7 @@ var ts; SyntaxKind[SyntaxKind["LastTemplateToken"] = 13] = "LastTemplateToken"; SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 24] = "FirstBinaryOperator"; SyntaxKind[SyntaxKind["LastBinaryOperator"] = 63] = "LastBinaryOperator"; - SyntaxKind[SyntaxKind["FirstNode"] = 123] = "FirstNode"; + SyntaxKind[SyntaxKind["FirstNode"] = 125] = "FirstNode"; })(ts.SyntaxKind || (ts.SyntaxKind = {})); var SyntaxKind = ts.SyntaxKind; (function (NodeFlags) { @@ -1595,6 +1605,10 @@ var ts; Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: 1, key: "Only a single variable declaration is allowed in a 'for...of' statement." }, The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: 1, key: "The variable declaration of a 'for...in' statement cannot have an initializer." }, The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: 1, key: "The variable declaration of a 'for...of' statement cannot have an initializer." }, + An_import_declaration_cannot_have_modifiers: { code: 1191, category: 1, key: "An import declaration cannot have modifiers." }, + External_module_0_has_no_default_export_or_export_assignment: { code: 1192, category: 1, key: "External module '{0}' has no default export or export assignment." }, + An_export_declaration_cannot_have_modifiers: { code: 1193, category: 1, key: "An export declaration cannot have modifiers." }, + Export_declarations_are_not_permitted_in_an_internal_module: { code: 1194, category: 1, key: "Export declarations are not permitted in an internal module." }, Duplicate_identifier_0: { code: 2300, category: 1, key: "Duplicate identifier '{0}'." }, Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: 1, 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: 1, key: "Static members cannot reference class type parameters." }, @@ -1723,7 +1737,7 @@ var ts; Ambient_external_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: 1, key: "Ambient external module declaration cannot specify relative module name." }, Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: 1, key: "Module '{0}' is hidden by a local declaration with the same name" }, Import_name_cannot_be_0: { code: 2438, category: 1, key: "Import name cannot be '{0}'" }, - Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name." }, + Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: { code: 2439, category: 1, key: "Import or export declaration in an ambient external module declaration cannot reference external module through relative external module name." }, Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: 1, key: "Import declaration conflicts with local declaration of '{0}'" }, Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: { code: 2441, category: 1, key: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module." }, Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: 1, key: "Types have separate declarations of a private property '{0}'." }, @@ -1767,6 +1781,7 @@ var ts; Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: 1, key: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." }, for_of_statements_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 2482, category: 1, key: "'for...of' statements are only available when targeting ECMAScript 6 or higher." }, The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: 1, key: "The left-hand side of a 'for...of' statement cannot use a type annotation." }, + Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: 1, key: "Export declaration conflicts with exported declaration of '{0}'" }, Import_declaration_0_is_using_private_name_1: { code: 4000, category: 1, 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: 1, 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: 1, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, @@ -1918,17 +1933,18 @@ var ts; var ts; (function (ts) { var textToToken = { - "any": 110, - "boolean": 111, + "any": 112, + "as": 101, + "boolean": 113, "break": 65, "case": 66, "catch": 67, "class": 68, "continue": 70, "const": 69, - "constructor": 112, + "constructor": 114, "debugger": 71, - "declare": 113, + "declare": 115, "default": 72, "delete": 73, "do": 74, @@ -1939,43 +1955,44 @@ var ts; "false": 79, "finally": 80, "for": 81, + "from": 102, "function": 82, - "get": 114, + "get": 116, "if": 83, - "implements": 101, + "implements": 103, "import": 84, "in": 85, "instanceof": 86, - "interface": 102, - "let": 103, - "module": 115, + "interface": 104, + "let": 105, + "module": 117, "new": 87, "null": 88, - "number": 117, - "package": 104, - "private": 105, - "protected": 106, - "public": 107, - "require": 116, + "number": 119, + "package": 106, + "private": 107, + "protected": 108, + "public": 109, + "require": 118, "return": 89, - "set": 118, - "static": 108, - "string": 119, + "set": 120, + "static": 110, + "string": 121, "super": 90, "switch": 91, - "symbol": 120, + "symbol": 122, "this": 92, "throw": 93, "true": 94, "try": 95, - "type": 121, + "type": 123, "typeof": 96, "var": 97, "void": 98, "while": 99, "with": 100, - "yield": 109, - "of": 122, + "yield": 111, + "of": 124, "{": 14, "}": 15, "(": 16, @@ -3116,7 +3133,7 @@ var ts; } } function getSourceFileOfNode(node) { - while (node && node.kind !== 210) { + while (node && node.kind !== 220) { node = node.parent; } return node; @@ -3182,6 +3199,10 @@ var ts; return identifier.length >= 3 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 && identifier.charCodeAt(2) === 95 ? identifier.substr(1) : identifier; } ts.unescapeIdentifier = unescapeIdentifier; + function makeIdentifierFromModuleName(moduleName) { + return ts.getBaseFileName(moduleName).replace(/\W/g, "_"); + } + ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; function declarationNameToString(name) { return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); } @@ -3212,13 +3233,13 @@ var ts; function getErrorSpanForNode(node) { var errorSpan; switch (node.kind) { - case 191: - case 148: - case 194: - case 195: - case 198: + case 193: + case 150: + case 196: case 197: - case 209: + case 200: + case 199: + case 219: errorSpan = node.name; break; } @@ -3234,11 +3255,11 @@ var ts; } ts.isDeclarationFile = isDeclarationFile; function isConstEnumDeclaration(node) { - return node.kind === 197 && isConst(node); + return node.kind === 199 && isConst(node); } ts.isConstEnumDeclaration = isConstEnumDeclaration; function walkUpBindingElementsAndPatterns(node) { - while (node && (node.kind === 148 || isBindingPattern(node))) { + while (node && (node.kind === 150 || isBindingPattern(node))) { node = node.parent; } return node; @@ -3246,14 +3267,14 @@ var ts; function getCombinedNodeFlags(node) { node = walkUpBindingElementsAndPatterns(node); var flags = node.flags; - if (node.kind === 191) { + if (node.kind === 193) { node = node.parent; } - if (node && node.kind === 192) { + if (node && node.kind === 194) { flags |= node.flags; node = node.parent; } - if (node && node.kind === 173) { + if (node && node.kind === 175) { flags |= node.flags; } return flags; @@ -3268,12 +3289,12 @@ var ts; } ts.isLet = isLet; function isPrologueDirective(node) { - return node.kind === 175 && node.expression.kind === 8; + return node.kind === 177 && node.expression.kind === 8; } ts.isPrologueDirective = isPrologueDirective; function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node); - if (node.kind === 126 || node.kind === 125) { + if (node.kind === 128 || node.kind === 127) { return ts.concatenate(ts.getTrailingCommentRanges(sourceFileOfNode.text, node.pos), ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos)); } else { @@ -3295,22 +3316,22 @@ var ts; return traverse(body); function traverse(node) { switch (node.kind) { - case 184: + case 186: return visitor(node); - case 172: - case 176: - case 177: + case 174: case 178: case 179: case 180: case 181: - case 185: - case 186: - case 203: - case 204: + case 182: + case 183: case 187: + case 188: + case 213: + case 214: case 189: - case 206: + case 191: + case 216: return ts.forEachChild(node, traverse); } } @@ -3319,22 +3340,22 @@ var ts; function isAnyFunction(node) { if (node) { switch (node.kind) { - case 131: - case 158: - case 193: - case 159: - case 130: - case 129: - case 132: case 133: + case 160: + case 195: + case 161: + case 132: + case 131: case 134: case 135: case 136: + case 137: case 138: - case 139: - case 158: - case 159: - case 193: + case 140: + case 141: + case 160: + case 161: + case 195: return true; } } @@ -3342,11 +3363,11 @@ var ts; } ts.isAnyFunction = isAnyFunction; function isFunctionBlock(node) { - return node && node.kind === 172 && isAnyFunction(node.parent); + return node && node.kind === 174 && isAnyFunction(node.parent); } ts.isFunctionBlock = isFunctionBlock; function isObjectLiteralMethod(node) { - return node && node.kind === 130 && node.parent.kind === 150; + return node && node.kind === 132 && node.parent.kind === 152; } ts.isObjectLiteralMethod = isObjectLiteralMethod; function getContainingFunction(node) { @@ -3365,28 +3386,28 @@ var ts; return undefined; } switch (node.kind) { - case 124: - if (node.parent.parent.kind === 194) { + case 126: + if (node.parent.parent.kind === 196) { return node; } node = node.parent; break; - case 159: + case 161: if (!includeArrowFunctions) { continue; } - case 193: - case 158: - case 198: - case 128: - case 127: + case 195: + case 160: + case 200: case 130: case 129: - case 131: case 132: + case 131: case 133: - case 197: - case 210: + case 134: + case 135: + case 199: + case 220: return node; } } @@ -3398,32 +3419,32 @@ var ts; if (!node) return node; switch (node.kind) { - case 124: - if (node.parent.parent.kind === 194) { + case 126: + if (node.parent.parent.kind === 196) { return node; } node = node.parent; break; - case 193: - case 158: - case 159: + case 195: + case 160: + case 161: if (!includeFunctions) { continue; } - case 128: - case 127: case 130: case 129: - case 131: case 132: + case 131: case 133: + case 134: + case 135: return node; } } } ts.getSuperContainer = getSuperContainer; function getInvokedExpression(node) { - if (node.kind === 155) { + if (node.kind === 157) { return node.tag; } return node.expression; @@ -3437,8 +3458,6 @@ var ts; case 94: case 79: case 9: - case 149: - case 150: case 151: case 152: case 153: @@ -3448,65 +3467,67 @@ var ts; case 157: case 158: case 159: - case 162: case 160: case 161: - case 163: case 164: + case 162: + case 163: case 165: case 166: - case 169: case 167: + case 168: + case 171: + case 169: case 10: - case 170: + case 172: return true; - case 123: - while (node.parent.kind === 123) { + case 125: + while (node.parent.kind === 125) { node = node.parent; } - return node.parent.kind === 140; + return node.parent.kind === 142; case 64: - if (node.parent.kind === 140) { + if (node.parent.kind === 142) { return true; } case 7: case 8: var parent = node.parent; switch (parent.kind) { - case 191: - case 126: + case 193: case 128: - case 127: - case 209: - case 207: - case 148: + case 130: + case 129: + case 219: + case 217: + case 150: return parent.initializer === node; - case 175: - case 176: case 177: case 178: - case 184: - case 185: - case 186: - case 203: - case 188: - case 186: - return parent.expression === node; case 179: + case 180: + case 186: + case 187: + case 188: + case 213: + case 190: + case 188: + return parent.expression === node; + case 181: var forStatement = parent; - return (forStatement.initializer === node && forStatement.initializer.kind !== 192) || + return (forStatement.initializer === node && forStatement.initializer.kind !== 194) || forStatement.condition === node || forStatement.iterator === node; - case 180: - case 181: + case 182: + case 183: var forInStatement = parent; - return (forInStatement.initializer === node && forInStatement.initializer.kind !== 192) || + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 194) || forInStatement.expression === node; - case 156: + case 158: return node === parent.expression; - case 171: + case 173: return node === parent.expression; - case 124: + case 126: return node === parent.expression; default: if (isExpression(parent)) { @@ -3523,36 +3544,51 @@ var ts; (preserveConstEnums && moduleState === 2); } ts.isInstantiatedModule = isInstantiatedModule; - function isExternalModuleImportDeclaration(node) { - return node.kind === 200 && node.moduleReference.kind === 202; + function isExternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind === 212; } - ts.isExternalModuleImportDeclaration = isExternalModuleImportDeclaration; - function getExternalModuleImportDeclarationExpression(node) { - ts.Debug.assert(isExternalModuleImportDeclaration(node)); + ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; + function getExternalModuleImportEqualsDeclarationExpression(node) { + ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node)); return node.moduleReference.expression; } - ts.getExternalModuleImportDeclarationExpression = getExternalModuleImportDeclarationExpression; - function isInternalModuleImportDeclaration(node) { - return node.kind === 200 && node.moduleReference.kind !== 202; + ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; + function isInternalModuleImportEqualsDeclaration(node) { + return node.kind === 202 && node.moduleReference.kind !== 212; } - ts.isInternalModuleImportDeclaration = isInternalModuleImportDeclaration; + ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; + function getExternalModuleName(node) { + if (node.kind === 203) { + return node.moduleSpecifier; + } + if (node.kind === 202) { + var reference = node.moduleReference; + if (reference.kind === 212) { + return reference.expression; + } + } + if (node.kind === 209) { + return node.moduleSpecifier; + } + } + ts.getExternalModuleName = getExternalModuleName; function hasDotDotDotToken(node) { - return node && node.kind === 126 && node.dotDotDotToken !== undefined; + return node && node.kind === 128 && node.dotDotDotToken !== undefined; } ts.hasDotDotDotToken = hasDotDotDotToken; function hasQuestionToken(node) { if (node) { switch (node.kind) { - case 126: + case 128: return node.questionToken !== undefined; + case 132: + case 131: + return node.questionToken !== undefined; + case 218: + case 217: case 130: case 129: return node.questionToken !== undefined; - case 208: - case 207: - case 128: - case 127: - return node.questionToken !== undefined; } } return false; @@ -3575,7 +3611,7 @@ var ts; } ts.isTemplateLiteralKind = isTemplateLiteralKind; function isBindingPattern(node) { - return node.kind === 147 || node.kind === 146; + return node.kind === 149 || node.kind === 148; } ts.isBindingPattern = isBindingPattern; function isInAmbientContext(node) { @@ -3590,27 +3626,31 @@ var ts; ts.isInAmbientContext = isInAmbientContext; function isDeclaration(node) { switch (node.kind) { - case 125: - case 126: - case 191: - case 148: - case 128: case 127: - case 207: - case 208: - case 209: + case 128: + case 193: + case 150: case 130: case 129: - case 193: + case 217: + case 218: + case 219: case 132: - case 133: case 131: - case 194: case 195: + case 134: + case 135: + case 133: case 196: case 197: case 198: + case 199: case 200: + case 202: + case 204: + case 207: + case 205: + case 211: return true; } return false; @@ -3618,25 +3658,25 @@ var ts; ts.isDeclaration = isDeclaration; function isStatement(n) { switch (n.kind) { - case 183: - case 182: - case 190: - case 177: - case 175: - case 174: - case 180: - case 181: - case 179: - case 176: - case 187: - case 184: - case 186: - case 93: - case 189: - case 173: - case 178: case 185: - case 201: + case 184: + case 192: + case 179: + case 177: + case 176: + case 182: + case 183: + case 181: + case 178: + case 189: + case 186: + case 188: + case 93: + case 191: + case 175: + case 180: + case 187: + case 208: return true; default: return false; @@ -3648,10 +3688,10 @@ var ts; return false; } var parent = name.parent; - if (isDeclaration(parent) || parent.kind === 158) { + if (isDeclaration(parent) || parent.kind === 160) { return parent.name === name; } - if (parent.kind === 206) { + if (parent.kind === 216) { return parent.name === name; } return false; @@ -3663,7 +3703,7 @@ var ts; } ts.getClassBaseTypeNode = getClassBaseTypeNode; function getClassImplementedTypeNodes(node) { - var heritageClause = getHeritageClause(node.heritageClauses, 101); + var heritageClause = getHeritageClause(node.heritageClauses, 103); return heritageClause ? heritageClause.types : undefined; } ts.getClassImplementedTypeNodes = getClassImplementedTypeNodes; @@ -3692,32 +3732,11 @@ var ts; } ts.tryResolveScriptReference = tryResolveScriptReference; function getAncestor(node, kind) { - switch (kind) { - case 194: - while (node) { - switch (node.kind) { - case 194: - return node; - case 197: - case 195: - case 196: - case 198: - case 200: - return undefined; - default: - node = node.parent; - continue; - } - } - break; - default: - while (node) { - if (node.kind === kind) { - return node; - } - node = node.parent; - } - break; + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; } return undefined; } @@ -3757,7 +3776,7 @@ var ts; } ts.getFileReferenceFromReferencePath = getFileReferenceFromReferencePath; function isKeyword(token) { - return 65 <= token && token <= 122; + return 65 <= token && token <= 124; } ts.isKeyword = isKeyword; function isTrivia(token) { @@ -3766,19 +3785,19 @@ var ts; ts.isTrivia = isTrivia; function hasDynamicName(declaration) { return declaration.name && - declaration.name.kind === 124 && + declaration.name.kind === 126 && !isWellKnownSymbolSyntactically(declaration.name.expression); } ts.hasDynamicName = hasDynamicName; function isWellKnownSymbolSyntactically(node) { - return node.kind === 151 && isESSymbolIdentifier(node.expression); + return node.kind === 153 && isESSymbolIdentifier(node.expression); } ts.isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; function getPropertyNameForPropertyNameNode(name) { if (name.kind === 64 || name.kind === 8 || name.kind === 7) { return name.text; } - if (name.kind === 124) { + if (name.kind === 126) { var nameExpression = name.expression; if (isWellKnownSymbolSyntactically(nameExpression)) { var rightHandSideName = nameExpression.name.text; @@ -3798,12 +3817,12 @@ var ts; ts.isESSymbolIdentifier = isESSymbolIdentifier; function isModifier(token) { switch (token) { + case 109: case 107: - case 105: - case 106: case 108: + case 110: case 77: - case 113: + case 115: case 69: return true; } @@ -3987,7 +4006,7 @@ var ts; })(ts || (ts = {})); var ts; (function (ts) { - var nodeConstructors = new Array(212); + var nodeConstructors = new Array(222); ts.parseTime = 0; function getNodeConstructor(kind) { return nodeConstructors[kind] || (nodeConstructors[kind] = ts.objectAllocator.getNodeConstructor(kind)); @@ -4024,20 +4043,20 @@ var ts; var visitNodes = cbNodeArray ? visitNodeArray : visitEachNode; var cbNodes = cbNodeArray || cbNode; switch (node.kind) { - case 123: + case 125: return visitNode(cbNode, node.left) || visitNode(cbNode, node.right); - case 125: + case 127: return visitNode(cbNode, node.name) || visitNode(cbNode, node.constraint) || visitNode(cbNode, node.expression); - case 126: case 128: - case 127: - case 207: - case 208: - case 191: - case 148: + case 130: + case 129: + case 217: + case 218: + case 193: + case 150: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.propertyName) || visitNode(cbNode, node.dotDotDotToken) || @@ -4045,23 +4064,23 @@ var ts; visitNode(cbNode, node.questionToken) || visitNode(cbNode, node.type) || visitNode(cbNode, node.initializer); - case 138: - case 139: - case 134: - case 135: + case 140: + case 141: case 136: + case 137: + case 138: return visitNodes(cbNodes, node.modifiers) || visitNodes(cbNodes, node.typeParameters) || visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type); - case 130: - case 129: - case 131: case 132: + case 131: case 133: - case 158: - case 193: - case 159: + case 134: + case 135: + case 160: + case 195: + case 161: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.name) || @@ -4070,178 +4089,198 @@ var ts; visitNodes(cbNodes, node.parameters) || visitNode(cbNode, node.type) || visitNode(cbNode, node.body); - case 137: + case 139: return visitNode(cbNode, node.typeName) || visitNodes(cbNodes, node.typeArguments); - case 140: - return visitNode(cbNode, node.exprName); - case 141: - return visitNodes(cbNodes, node.members); case 142: - return visitNode(cbNode, node.elementType); + return visitNode(cbNode, node.exprName); case 143: - return visitNodes(cbNodes, node.elementTypes); + return visitNodes(cbNodes, node.members); case 144: - return visitNodes(cbNodes, node.types); + return visitNode(cbNode, node.elementType); case 145: - return visitNode(cbNode, node.type); + return visitNodes(cbNodes, node.elementTypes); case 146: + return visitNodes(cbNodes, node.types); case 147: - return visitNodes(cbNodes, node.elements); + return visitNode(cbNode, node.type); + case 148: case 149: return visitNodes(cbNodes, node.elements); - case 150: - return visitNodes(cbNodes, node.properties); case 151: + return visitNodes(cbNodes, node.elements); + case 152: + return visitNodes(cbNodes, node.properties); + case 153: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.name); - case 152: + case 154: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.argumentExpression); - case 153: - case 154: + case 155: + case 156: return visitNode(cbNode, node.expression) || visitNodes(cbNodes, node.typeArguments) || visitNodes(cbNodes, node.arguments); - case 155: + case 157: return visitNode(cbNode, node.tag) || visitNode(cbNode, node.template); - case 156: + case 158: return visitNode(cbNode, node.type) || visitNode(cbNode, node.expression); - case 157: - return visitNode(cbNode, node.expression); - case 160: - return visitNode(cbNode, node.expression); - case 161: + case 159: return visitNode(cbNode, node.expression); case 162: return visitNode(cbNode, node.expression); case 163: + return visitNode(cbNode, node.expression); + case 164: + return visitNode(cbNode, node.expression); + case 165: return visitNode(cbNode, node.operand); - case 168: + case 170: return visitNode(cbNode, node.asteriskToken) || visitNode(cbNode, node.expression); - case 164: + case 166: return visitNode(cbNode, node.operand); - case 165: + case 167: return visitNode(cbNode, node.left) || visitNode(cbNode, node.operatorToken) || visitNode(cbNode, node.right); - case 166: + case 168: return visitNode(cbNode, node.condition) || visitNode(cbNode, node.whenTrue) || visitNode(cbNode, node.whenFalse); - case 169: + case 171: return visitNode(cbNode, node.expression); - case 172: - case 199: + case 174: + case 201: return visitNodes(cbNodes, node.statements); - case 210: + case 220: return visitNodes(cbNodes, node.statements) || visitNode(cbNode, node.endOfFileToken); - case 173: + case 175: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.declarationList); - case 192: + case 194: return visitNodes(cbNodes, node.declarations); - case 175: + case 177: return visitNode(cbNode, node.expression); - case 176: + case 178: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.thenStatement) || visitNode(cbNode, node.elseStatement); - case 177: + case 179: return visitNode(cbNode, node.statement) || visitNode(cbNode, node.expression); - case 178: + case 180: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); - case 179: + case 181: return visitNode(cbNode, node.initializer) || visitNode(cbNode, node.condition) || visitNode(cbNode, node.iterator) || visitNode(cbNode, node.statement); - case 180: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); - case 181: - return visitNode(cbNode, node.initializer) || - visitNode(cbNode, node.expression) || - visitNode(cbNode, node.statement); case 182: - case 183: - return visitNode(cbNode, node.label); - case 184: - return visitNode(cbNode, node.expression); - case 185: - return visitNode(cbNode, node.expression) || + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); + case 183: + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + case 184: + case 185: + return visitNode(cbNode, node.label); case 186: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.clauses); - case 203: - return visitNode(cbNode, node.expression) || - visitNodes(cbNodes, node.statements); - case 204: - return visitNodes(cbNodes, node.statements); + return visitNode(cbNode, node.expression); case 187: - return visitNode(cbNode, node.label) || + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.statement); case 188: - return visitNode(cbNode, node.expression); + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.clauses); + case 213: + return visitNode(cbNode, node.expression) || + visitNodes(cbNodes, node.statements); + case 214: + return visitNodes(cbNodes, node.statements); case 189: + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + case 190: + return visitNode(cbNode, node.expression); + case 191: return visitNode(cbNode, node.tryBlock) || visitNode(cbNode, node.catchClause) || visitNode(cbNode, node.finallyBlock); - case 206: + case 216: return visitNode(cbNode, node.name) || visitNode(cbNode, node.type) || visitNode(cbNode, node.block); - case 194: - return visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); - case 195: - return visitNodes(cbNodes, node.modifiers) || - visitNode(cbNode, node.name) || - visitNodes(cbNodes, node.typeParameters) || - visitNodes(cbNodes, node.heritageClauses) || - visitNodes(cbNodes, node.members); case 196: return 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 197: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.typeParameters) || + visitNodes(cbNodes, node.heritageClauses) || visitNodes(cbNodes, node.members); - case 209: - return visitNode(cbNode, node.name) || - visitNode(cbNode, node.initializer); case 198: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || - visitNode(cbNode, node.body); + visitNode(cbNode, node.type); + case 199: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNodes, node.members); + case 219: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); case 200: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + case 202: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.name) || visitNode(cbNode, node.moduleReference); - case 201: + case 203: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier); + case 204: + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + case 205: + return visitNode(cbNode, node.name); + case 206: + case 210: + return visitNodes(cbNodes, node.elements); + case 209: + return visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier); + case 207: + case 211: + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + case 208: return visitNodes(cbNodes, node.modifiers) || visitNode(cbNode, node.exportName); - case 167: + case 169: return visitNode(cbNode, node.head) || visitNodes(cbNodes, node.templateSpans); - case 171: + case 173: return visitNode(cbNode, node.expression) || visitNode(cbNode, node.literal); - case 124: + case 126: return visitNode(cbNode, node.expression); - case 205: + case 215: return visitNodes(cbNodes, node.types); - case 202: + case 212: return visitNode(cbNode, node.expression); } } @@ -4268,7 +4307,8 @@ var ts; ParsingContext[ParsingContext["TypeArguments"] = 17] = "TypeArguments"; ParsingContext[ParsingContext["TupleElementTypes"] = 18] = "TupleElementTypes"; ParsingContext[ParsingContext["HeritageClauses"] = 19] = "HeritageClauses"; - ParsingContext[ParsingContext["Count"] = 20] = "Count"; + ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 20] = "ImportOrExportSpecifiers"; + ParsingContext[ParsingContext["Count"] = 21] = "Count"; })(ParsingContext || (ParsingContext = {})); var Tristate; (function (Tristate) { @@ -4298,17 +4338,18 @@ var ts; 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; } } ; function modifierToFlag(token) { switch (token) { - case 108: return 128; - case 107: return 16; - case 106: return 64; - case 105: return 32; + case 110: return 128; + case 109: return 16; + case 108: return 64; + case 107: return 32; case 77: return 1; - case 113: return 2; + case 115: return 2; case 69: return 4096; } return 0; @@ -4627,7 +4668,7 @@ var ts; var identifierCount = 0; var nodeCount = 0; var token; - var sourceFile = createNode(210, 0); + var sourceFile = createNode(220, 0); sourceFile.pos = 0; sourceFile.end = sourceText.length; sourceFile.text = sourceText; @@ -4782,10 +4823,10 @@ var ts; if (token === 64) { return true; } - if (token === 109 && inYieldContext()) { + if (token === 111 && inYieldContext()) { return false; } - return inStrictModeContext() ? token > 109 : token > 100; + return inStrictModeContext() ? token > 111 : token > 100; } function parseExpected(kind, diagnosticMessage) { if (token === kind) { @@ -4904,7 +4945,7 @@ var ts; return parseIdentifierName(); } function parseComputedPropertyName() { - var node = createNode(124); + var node = createNode(126); parseExpected(18); var yieldContext = inYieldContext(); if (inGeneratorParameterContext()) { @@ -4931,6 +4972,10 @@ var ts; if (token === 69) { return nextToken() === 76; } + if (token === 77) { + nextToken(); + return token !== 35 && token !== 14 && canFollowModifier(); + } nextToken(); return canFollowModifier(); } @@ -4979,6 +5024,8 @@ var ts; return token === 23 || isStartOfType(); case 19: return isHeritageClause(); + case 20: + return isIdentifierOrKeyword(); } ts.Debug.fail("Non-exhaustive case in 'isListElement'."); } @@ -4987,7 +5034,7 @@ var ts; return isIdentifier(); } function isNotHeritageClauseTypeName() { - if (token === 101 || + if (token === 103 || token === 78) { return lookAhead(nextTokenIsIdentifier); } @@ -5006,15 +5053,16 @@ var ts; case 7: case 13: case 10: + case 20: return token === 15; case 4: return token === 15 || token === 66 || token === 72; case 8: - return token === 14 || token === 78 || token === 101; + return token === 14 || token === 78 || token === 103; case 9: return isVariableDeclaratorListTerminator(); case 16: - return token === 25 || token === 16 || token === 14 || token === 78 || token === 101; + return token === 25 || token === 16 || token === 14 || token === 78 || token === 103; case 12: return token === 17 || token === 22; case 14: @@ -5042,7 +5090,7 @@ var ts; return false; } function isInSomeParsingContext() { - for (var kind = 0; kind < 20; kind++) { + for (var kind = 0; kind < 21; kind++) { if (parsingContext & (1 << kind)) { if (isListElement(kind, true) || isListTerminator(kind)) { return true; @@ -5153,12 +5201,14 @@ var ts; function isReusableModuleElement(node) { if (node) { switch (node.kind) { - case 200: - case 201: - case 194: - case 195: - case 198: + case 203: + case 202: + case 209: + case 208: + case 196: case 197: + case 200: + case 199: return true; } return isReusableStatement(node); @@ -5168,12 +5218,12 @@ var ts; function isReusableClassMember(node) { if (node) { switch (node.kind) { - case 131: - case 136: - case 130: - case 132: case 133: - case 128: + case 138: + case 132: + case 134: + case 135: + case 130: return true; } } @@ -5182,8 +5232,8 @@ var ts; function isReusableSwitchClause(node) { if (node) { switch (node.kind) { - case 203: - case 204: + case 213: + case 214: return true; } } @@ -5192,56 +5242,56 @@ var ts; function isReusableStatement(node) { if (node) { switch (node.kind) { - case 193: - case 173: - case 172: - case 176: + case 195: case 175: - case 188: - case 184: - case 186: - case 183: - case 182: - case 180: - case 181: - case 179: - case 178: - case 185: case 174: - case 189: - case 187: + case 178: case 177: case 190: + case 186: + case 188: + case 185: + case 184: + case 182: + case 183: + case 181: + case 180: + case 187: + case 176: + case 191: + case 189: + case 179: + case 192: return true; } } return false; } function isReusableEnumMember(node) { - return node.kind === 209; + return node.kind === 219; } function isReusableTypeMember(node) { if (node) { switch (node.kind) { - case 135: + case 137: + case 131: + case 138: case 129: case 136: - case 127: - case 134: return true; } } return false; } function isReusableVariableDeclaration(node) { - if (node.kind !== 191) { + if (node.kind !== 193) { return false; } var variableDeclarator = node; return variableDeclarator.initializer === undefined; } function isReusableParameter(node) { - if (node.kind !== 126) { + if (node.kind !== 128) { return false; } var parameter = node; @@ -5310,7 +5360,7 @@ var ts; function parseEntityName(allowReservedWords, diagnosticMessage) { var entity = parseIdentifier(diagnosticMessage); while (parseOptional(20)) { - var node = createNode(123, entity.pos); + var node = createNode(125, entity.pos); node.left = entity; node.right = parseRightSideOfDot(allowReservedWords); entity = finishNode(node); @@ -5327,7 +5377,7 @@ var ts; return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); } function parseTemplateExpression() { - var template = createNode(167); + var template = createNode(169); template.head = parseLiteralNode(); ts.Debug.assert(template.head.kind === 11, "Template head has wrong token kind"); var templateSpans = []; @@ -5340,7 +5390,7 @@ var ts; return finishNode(template); } function parseTemplateSpan() { - var span = createNode(171); + var span = createNode(173); span.expression = allowInAnd(parseExpression); var literal; if (token === 15) { @@ -5369,7 +5419,7 @@ var ts; return node; } function parseTypeReference() { - var node = createNode(137); + var node = createNode(139); node.typeName = parseEntityName(false, ts.Diagnostics.Type_expected); if (!scanner.hasPrecedingLineBreak() && token === 24) { node.typeArguments = parseBracketedList(17, parseType, 24, 25); @@ -5377,13 +5427,13 @@ var ts; return finishNode(node); } function parseTypeQuery() { - var node = createNode(140); + var node = createNode(142); parseExpected(96); node.exprName = parseEntityName(true); return finishNode(node); } function parseTypeParameter() { - var node = createNode(125); + var node = createNode(127); node.name = parseIdentifier(); if (parseOptional(78)) { if (isStartOfType() || !isStartOfExpression()) { @@ -5416,7 +5466,7 @@ var ts; } } function parseParameter() { - var node = createNode(126); + var node = createNode(128); setModifiers(node, parseModifiers()); node.dotDotDotToken = parseOptionalToken(21); node.name = inGeneratorParameterContext() ? doInYieldContext(parseIdentifierOrPattern) : parseIdentifierOrPattern(); @@ -5460,14 +5510,14 @@ var ts; return requireCompleteParameterList ? undefined : createMissingList(); } function parseTypeMemberSemicolon() { - if (parseSemicolon()) { + if (parseOptional(23)) { return; } - parseOptional(23); + parseSemicolon(); } function parseSignatureMember(kind) { var node = createNode(kind); - if (kind === 135) { + if (kind === 137) { parseExpected(87); } fillSignature(51, false, false, node); @@ -5508,7 +5558,7 @@ var ts; } function parseIndexSignatureDeclaration(modifiers) { var fullStart = modifiers ? modifiers.pos : scanner.getStartPos(); - var node = createNode(136, fullStart); + var node = createNode(138, fullStart); setModifiers(node, modifiers); node.parameters = parseBracketedList(15, parseParameter, 18, 19); node.type = parseTypeAnnotation(); @@ -5520,7 +5570,7 @@ var ts; var name = parsePropertyName(); var questionToken = parseOptionalToken(50); if (token === 16 || token === 24) { - var method = createNode(129, fullStart); + var method = createNode(131, fullStart); method.name = name; method.questionToken = questionToken; fillSignature(51, false, false, method); @@ -5528,7 +5578,7 @@ var ts; return finishNode(method); } else { - var property = createNode(127, fullStart); + var property = createNode(129, fullStart); property.name = name; property.questionToken = questionToken; property.type = parseTypeAnnotation(); @@ -5570,12 +5620,12 @@ var ts; switch (token) { case 16: case 24: - return parseSignatureMember(134); + return parseSignatureMember(136); case 18: return isIndexSignature() ? parseIndexSignatureDeclaration(undefined) : parsePropertyOrMethodSignature(); case 87: if (lookAhead(isStartOfConstructSignature)) { - return parseSignatureMember(135); + return parseSignatureMember(137); } case 8: case 7: @@ -5601,7 +5651,7 @@ var ts; return token === 16 || token === 24; } function parseTypeLiteral() { - var node = createNode(141); + var node = createNode(143); node.members = parseObjectTypeMembers(); return finishNode(node); } @@ -5617,12 +5667,12 @@ var ts; return members; } function parseTupleType() { - var node = createNode(143); + var node = createNode(145); node.elementTypes = parseBracketedList(18, parseType, 18, 19); return finishNode(node); } function parseParenthesizedType() { - var node = createNode(145); + var node = createNode(147); parseExpected(16); node.type = parseType(); parseExpected(17); @@ -5630,7 +5680,7 @@ var ts; } function parseFunctionOrConstructorType(kind) { var node = createNode(kind); - if (kind === 139) { + if (kind === 141) { parseExpected(87); } fillSignature(32, false, false, node); @@ -5642,11 +5692,11 @@ var ts; } function parseNonArrayType() { switch (token) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: var node = tryParse(parseKeywordAndNoDot); return node || parseTypeReference(); case 98: @@ -5665,11 +5715,11 @@ var ts; } function isStartOfType() { switch (token) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: case 98: case 96: case 14: @@ -5691,7 +5741,7 @@ var ts; var type = parseNonArrayType(); while (!scanner.hasPrecedingLineBreak() && parseOptional(18)) { parseExpected(19); - var node = createNode(142, type.pos); + var node = createNode(144, type.pos); node.elementType = type; type = finishNode(node); } @@ -5706,7 +5756,7 @@ var ts; types.push(parseArrayTypeOrHigher()); } types.end = getNodeEnd(); - var node = createNode(144, type.pos); + var node = createNode(146, type.pos); node.types = types; type = finishNode(node); } @@ -5751,10 +5801,10 @@ var ts; } function parseTypeWorker() { if (isStartOfFunctionType()) { - return parseFunctionOrConstructorType(138); + return parseFunctionOrConstructorType(140); } if (token === 87) { - return parseFunctionOrConstructorType(139); + return parseFunctionOrConstructorType(141); } return parseUnionTypeOrHigher(); } @@ -5790,7 +5840,7 @@ var ts; case 39: case 24: case 64: - case 109: + case 111: return true; default: if (isBinaryOperator()) { @@ -5837,7 +5887,7 @@ var ts; return parseConditionalExpressionRest(expr); } function isYieldExpression() { - if (token === 109) { + if (token === 111) { if (inYieldContext()) { return true; } @@ -5853,7 +5903,7 @@ var ts; return !scanner.hasPrecedingLineBreak() && isIdentifier(); } function parseYieldExpression() { - var node = createNode(168); + var node = createNode(170); nextToken(); if (!scanner.hasPrecedingLineBreak() && (token === 35 || isStartOfExpression())) { @@ -5867,8 +5917,8 @@ var ts; } function parseSimpleArrowFunctionExpression(identifier) { ts.Debug.assert(token === 32, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); - var node = createNode(159, identifier.pos); - var parameter = createNode(126, identifier.pos); + var node = createNode(161, identifier.pos); + var parameter = createNode(128, identifier.pos); parameter.name = identifier; finishNode(parameter); node.parameters = [parameter]; @@ -5942,7 +5992,7 @@ var ts; return parseParenthesizedArrowFunctionExpressionHead(false); } function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) { - var node = createNode(159); + var node = createNode(161); fillSignature(51, false, !allowAmbiguity, node); if (!node.parameters) { return undefined; @@ -5965,7 +6015,7 @@ var ts; if (!parseOptional(50)) { return leftOperand; } - var node = createNode(166, leftOperand.pos); + var node = createNode(168, leftOperand.pos); node.condition = leftOperand; node.whenTrue = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(51); @@ -5977,7 +6027,7 @@ var ts; return parseBinaryExpressionRest(precedence, leftOperand); } function isInOrOfKeyword(t) { - return t === 85 || t === 122; + return t === 85 || t === 124; } function parseBinaryExpressionRest(precedence, leftOperand) { while (true) { @@ -6038,33 +6088,33 @@ var ts; return -1; } function makeBinaryExpression(left, operatorToken, right) { - var node = createNode(165, left.pos); + var node = createNode(167, left.pos); node.left = left; node.operatorToken = operatorToken; node.right = right; return finishNode(node); } function parsePrefixUnaryExpression() { - var node = createNode(163); + var node = createNode(165); node.operator = token; nextToken(); node.operand = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseDeleteExpression() { - var node = createNode(160); + var node = createNode(162); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseTypeOfExpression() { - var node = createNode(161); + var node = createNode(163); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); } function parseVoidExpression() { - var node = createNode(162); + var node = createNode(164); nextToken(); node.expression = parseUnaryExpressionOrHigher(); return finishNode(node); @@ -6094,7 +6144,7 @@ var ts; var expression = parseLeftHandSideExpressionOrHigher(); ts.Debug.assert(isLeftHandSideExpression(expression)); if ((token === 38 || token === 39) && !scanner.hasPrecedingLineBreak()) { - var node = createNode(164, expression.pos); + var node = createNode(166, expression.pos); node.operand = expression; node.operator = token; nextToken(); @@ -6115,14 +6165,14 @@ var ts; if (token === 16 || token === 20) { return expression; } - var node = createNode(151, expression.pos); + var node = createNode(153, expression.pos); node.expression = expression; parseExpected(20, 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(156); + var node = createNode(158); parseExpected(24); node.type = parseType(); parseExpected(25); @@ -6133,14 +6183,14 @@ var ts; while (true) { var dotOrBracketStart = scanner.getTokenPos(); if (parseOptional(20)) { - var propertyAccess = createNode(151, expression.pos); + var propertyAccess = createNode(153, expression.pos); propertyAccess.expression = expression; propertyAccess.name = parseRightSideOfDot(true); expression = finishNode(propertyAccess); continue; } if (parseOptional(18)) { - var indexedAccess = createNode(152, expression.pos); + var indexedAccess = createNode(154, expression.pos); indexedAccess.expression = expression; if (token !== 19) { indexedAccess.argumentExpression = allowInAnd(parseExpression); @@ -6154,7 +6204,7 @@ var ts; continue; } if (token === 10 || token === 11) { - var tagExpression = createNode(155, expression.pos); + var tagExpression = createNode(157, expression.pos); tagExpression.tag = expression; tagExpression.template = token === 10 ? parseLiteralNode() : parseTemplateExpression(); expression = finishNode(tagExpression); @@ -6171,7 +6221,7 @@ var ts; if (!typeArguments) { return expression; } - var callExpr = createNode(153, expression.pos); + var callExpr = createNode(155, expression.pos); callExpr.expression = expression; callExpr.typeArguments = typeArguments; callExpr.arguments = parseArgumentList(); @@ -6179,7 +6229,7 @@ var ts; continue; } else if (token === 16) { - var callExpr = createNode(153, expression.pos); + var callExpr = createNode(155, expression.pos); callExpr.expression = expression; callExpr.arguments = parseArgumentList(); expression = finishNode(callExpr); @@ -6264,26 +6314,26 @@ var ts; return parseIdentifier(ts.Diagnostics.Expression_expected); } function parseParenthesizedExpression() { - var node = createNode(157); + var node = createNode(159); parseExpected(16); node.expression = allowInAnd(parseExpression); parseExpected(17); return finishNode(node); } function parseSpreadElement() { - var node = createNode(169); + var node = createNode(171); parseExpected(21); node.expression = parseAssignmentExpressionOrHigher(); return finishNode(node); } function parseArgumentOrArrayLiteralElement() { - return token === 21 ? parseSpreadElement() : token === 23 ? createNode(170) : parseAssignmentExpressionOrHigher(); + return token === 21 ? parseSpreadElement() : token === 23 ? createNode(172) : parseAssignmentExpressionOrHigher(); } function parseArgumentExpression() { return allowInAnd(parseArgumentOrArrayLiteralElement); } function parseArrayLiteralExpression() { - var node = createNode(149); + var node = createNode(151); parseExpected(18); if (scanner.hasPrecedingLineBreak()) node.flags |= 256; @@ -6292,11 +6342,11 @@ var ts; return finishNode(node); } function tryParseAccessorDeclaration(fullStart, modifiers) { - if (parseContextualModifier(114)) { - return parseAccessorDeclaration(132, fullStart, modifiers); + if (parseContextualModifier(116)) { + return parseAccessorDeclaration(134, fullStart, modifiers); } - else if (parseContextualModifier(118)) { - return parseAccessorDeclaration(133, fullStart, modifiers); + else if (parseContextualModifier(120)) { + return parseAccessorDeclaration(135, fullStart, modifiers); } return undefined; } @@ -6316,13 +6366,13 @@ var ts; return parseMethodDeclaration(fullStart, modifiers, asteriskToken, propertyName, questionToken); } if ((token === 23 || token === 15) && tokenIsIdentifier) { - var shorthandDeclaration = createNode(208, fullStart); + var shorthandDeclaration = createNode(218, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; return finishNode(shorthandDeclaration); } else { - var propertyAssignment = createNode(207, fullStart); + var propertyAssignment = createNode(217, fullStart); propertyAssignment.name = propertyName; propertyAssignment.questionToken = questionToken; parseExpected(51); @@ -6331,7 +6381,7 @@ var ts; } } function parseObjectLiteralExpression() { - var node = createNode(150); + var node = createNode(152); parseExpected(14); if (scanner.hasPrecedingLineBreak()) { node.flags |= 256; @@ -6341,7 +6391,7 @@ var ts; return finishNode(node); } function parseFunctionExpression() { - var node = createNode(158); + var node = createNode(160); parseExpected(82); node.asteriskToken = parseOptionalToken(35); node.name = node.asteriskToken ? doInYieldContext(parseOptionalIdentifier) : parseOptionalIdentifier(); @@ -6353,7 +6403,7 @@ var ts; return isIdentifier() ? parseIdentifier() : undefined; } function parseNewExpression() { - var node = createNode(154); + var node = createNode(156); parseExpected(87); node.expression = parseMemberExpressionOrHigher(); node.typeArguments = tryParse(parseTypeArgumentsInExpression); @@ -6363,7 +6413,7 @@ var ts; return finishNode(node); } function parseBlock(ignoreMissingOpenBrace, checkForStrictMode, diagnosticMessage) { - var node = createNode(172); + var node = createNode(174); if (parseExpected(14, diagnosticMessage) || ignoreMissingOpenBrace) { node.statements = parseList(2, checkForStrictMode, parseStatement); parseExpected(15); @@ -6381,12 +6431,12 @@ var ts; return block; } function parseEmptyStatement() { - var node = createNode(174); + var node = createNode(176); parseExpected(22); return finishNode(node); } function parseIfStatement() { - var node = createNode(176); + var node = createNode(178); parseExpected(83); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6396,7 +6446,7 @@ var ts; return finishNode(node); } function parseDoStatement() { - var node = createNode(177); + var node = createNode(179); parseExpected(74); node.statement = parseStatement(); parseExpected(99); @@ -6407,7 +6457,7 @@ var ts; return finishNode(node); } function parseWhileStatement() { - var node = createNode(178); + var node = createNode(180); parseExpected(99); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6421,7 +6471,7 @@ var ts; parseExpected(16); var initializer = undefined; if (token !== 22) { - if (token === 97 || token === 103 || token === 69) { + if (token === 97 || token === 105 || token === 69) { initializer = parseVariableDeclarationList(true); } else { @@ -6430,21 +6480,21 @@ var ts; } var forOrForInOrForOfStatement; if (parseOptional(85)) { - var forInStatement = createNode(180, pos); + var forInStatement = createNode(182, pos); forInStatement.initializer = initializer; forInStatement.expression = allowInAnd(parseExpression); parseExpected(17); forOrForInOrForOfStatement = forInStatement; } - else if (parseOptional(122)) { - var forOfStatement = createNode(181, pos); + else if (parseOptional(124)) { + var forOfStatement = createNode(183, pos); forOfStatement.initializer = initializer; forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(17); forOrForInOrForOfStatement = forOfStatement; } else { - var forStatement = createNode(179, pos); + var forStatement = createNode(181, pos); forStatement.initializer = initializer; parseExpected(22); if (token !== 22 && token !== 17) { @@ -6462,7 +6512,7 @@ var ts; } function parseBreakOrContinueStatement(kind) { var node = createNode(kind); - parseExpected(kind === 183 ? 65 : 70); + parseExpected(kind === 185 ? 65 : 70); if (!canParseSemicolon()) { node.label = parseIdentifier(); } @@ -6470,7 +6520,7 @@ var ts; return finishNode(node); } function parseReturnStatement() { - var node = createNode(184); + var node = createNode(186); parseExpected(89); if (!canParseSemicolon()) { node.expression = allowInAnd(parseExpression); @@ -6479,7 +6529,7 @@ var ts; return finishNode(node); } function parseWithStatement() { - var node = createNode(185); + var node = createNode(187); parseExpected(100); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6488,7 +6538,7 @@ var ts; return finishNode(node); } function parseCaseClause() { - var node = createNode(203); + var node = createNode(213); parseExpected(66); node.expression = allowInAnd(parseExpression); parseExpected(51); @@ -6496,7 +6546,7 @@ var ts; return finishNode(node); } function parseDefaultClause() { - var node = createNode(204); + var node = createNode(214); parseExpected(72); parseExpected(51); node.statements = parseList(4, false, parseStatement); @@ -6506,7 +6556,7 @@ var ts; return token === 66 ? parseCaseClause() : parseDefaultClause(); } function parseSwitchStatement() { - var node = createNode(186); + var node = createNode(188); parseExpected(91); parseExpected(16); node.expression = allowInAnd(parseExpression); @@ -6517,14 +6567,14 @@ var ts; return finishNode(node); } function parseThrowStatement() { - var node = createNode(188); + var node = createNode(190); parseExpected(93); node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); parseSemicolon(); return finishNode(node); } function parseTryStatement() { - var node = createNode(189); + var node = createNode(191); parseExpected(95); node.tryBlock = parseBlock(false, false); node.catchClause = token === 67 ? parseCatchClause() : undefined; @@ -6535,7 +6585,7 @@ var ts; return finishNode(node); } function parseCatchClause() { - var result = createNode(206); + var result = createNode(216); parseExpected(67); parseExpected(16); result.name = parseIdentifier(); @@ -6545,7 +6595,7 @@ var ts; return finishNode(result); } function parseDebuggerStatement() { - var node = createNode(190); + var node = createNode(192); parseExpected(71); parseSemicolon(); return finishNode(node); @@ -6554,13 +6604,13 @@ var ts; var fullStart = scanner.getStartPos(); var expression = allowInAnd(parseExpression); if (expression.kind === 64 && parseOptional(51)) { - var labeledStatement = createNode(187, fullStart); + var labeledStatement = createNode(189, fullStart); labeledStatement.label = expression; labeledStatement.statement = parseStatement(); return finishNode(labeledStatement); } else { - var expressionStatement = createNode(175, fullStart); + var expressionStatement = createNode(177, fullStart); expressionStatement.expression = expression; parseSemicolon(); return finishNode(expressionStatement); @@ -6578,7 +6628,7 @@ var ts; return !inErrorRecovery; case 14: case 97: - case 103: + case 105: case 82: case 83: case 74: @@ -6598,18 +6648,18 @@ var ts; case 69: var isConstEnum = lookAhead(nextTokenIsEnumKeyword); return !isConstEnum; - case 102: + case 104: case 68: - case 115: + case 117: case 76: - case 121: + case 123: if (isDeclarationStart()) { return false; } + case 109: case 107: - case 105: - case 106: case 108: + case 110: if (lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine)) { return false; } @@ -6645,9 +6695,9 @@ var ts; case 81: return parseForOrForInOrForOfStatement(); case 70: - return parseBreakOrContinueStatement(182); + return parseBreakOrContinueStatement(184); case 65: - return parseBreakOrContinueStatement(183); + return parseBreakOrContinueStatement(185); case 89: return parseReturnStatement(); case 100: @@ -6662,7 +6712,7 @@ var ts; return parseTryStatement(); case 71: return parseDebuggerStatement(); - case 103: + case 105: if (isLetDeclaration()) { return parseVariableStatement(scanner.getStartPos(), undefined); } @@ -6686,7 +6736,7 @@ var ts; return undefined; } return parseVariableStatement(start, modifiers); - case 103: + case 105: if (!isLetDeclaration()) { return undefined; } @@ -6707,16 +6757,16 @@ var ts; } function parseArrayBindingElement() { if (token === 23) { - return createNode(170); + return createNode(172); } - var node = createNode(148); + var node = createNode(150); node.dotDotDotToken = parseOptionalToken(21); node.name = parseIdentifierOrPattern(); node.initializer = parseInitializer(false); return finishNode(node); } function parseObjectBindingElement() { - var node = createNode(148); + var node = createNode(150); var id = parsePropertyName(); if (id.kind === 64 && token !== 51) { node.name = id; @@ -6730,14 +6780,14 @@ var ts; return finishNode(node); } function parseObjectBindingPattern() { - var node = createNode(146); + var node = createNode(148); parseExpected(14); node.elements = parseDelimitedList(10, parseObjectBindingElement); parseExpected(15); return finishNode(node); } function parseArrayBindingPattern() { - var node = createNode(147); + var node = createNode(149); parseExpected(18); node.elements = parseDelimitedList(11, parseArrayBindingElement); parseExpected(19); @@ -6756,7 +6806,7 @@ var ts; return parseIdentifier(); } function parseVariableDeclaration() { - var node = createNode(191); + var node = createNode(193); node.name = parseIdentifierOrPattern(); node.type = parseTypeAnnotation(); if (!isInOrOfKeyword(token)) { @@ -6765,11 +6815,11 @@ var ts; return finishNode(node); } function parseVariableDeclarationList(inForStatementInitializer) { - var node = createNode(192); + var node = createNode(194); switch (token) { case 97: break; - case 103: + case 105: node.flags |= 2048; break; case 69: @@ -6779,7 +6829,7 @@ var ts; ts.Debug.fail(); } nextToken(); - if (token === 122 && lookAhead(canFollowContextualOfKeyword)) { + if (token === 124 && lookAhead(canFollowContextualOfKeyword)) { node.declarations = createMissingList(); } else { @@ -6794,14 +6844,14 @@ var ts; return nextTokenIsIdentifier() && nextToken() === 17; } function parseVariableStatement(fullStart, modifiers) { - var node = createNode(173, fullStart); + var node = createNode(175, fullStart); setModifiers(node, modifiers); node.declarationList = parseVariableDeclarationList(false); parseSemicolon(); return finishNode(node); } function parseFunctionDeclaration(fullStart, modifiers) { - var node = createNode(193, fullStart); + var node = createNode(195, fullStart); setModifiers(node, modifiers); parseExpected(82); node.asteriskToken = parseOptionalToken(35); @@ -6811,15 +6861,15 @@ var ts; return finishNode(node); } function parseConstructorDeclaration(pos, modifiers) { - var node = createNode(131, pos); + var node = createNode(133, pos); setModifiers(node, modifiers); - parseExpected(112); + parseExpected(114); fillSignature(51, false, false, node); node.body = parseFunctionBlockOrSemicolon(false, ts.Diagnostics.or_expected); return finishNode(node); } function parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, diagnosticMessage) { - var method = createNode(130, fullStart); + var method = createNode(132, fullStart); setModifiers(method, modifiers); method.asteriskToken = asteriskToken; method.name = name; @@ -6836,7 +6886,7 @@ var ts; return parseMethodDeclaration(fullStart, modifiers, asteriskToken, name, questionToken, ts.Diagnostics.or_expected); } else { - var property = createNode(128, fullStart); + var property = createNode(130, fullStart); setModifiers(property, modifiers); property.name = name; property.questionToken = questionToken; @@ -6874,7 +6924,7 @@ var ts; return true; } if (idToken !== undefined) { - if (!ts.isKeyword(idToken) || idToken === 118 || idToken === 114) { + if (!ts.isKeyword(idToken) || idToken === 120 || idToken === 116) { return true; } switch (token) { @@ -6919,7 +6969,7 @@ var ts; if (accessor) { return accessor; } - if (token === 112) { + if (token === 114) { return parseConstructorDeclaration(fullStart, modifiers); } if (isIndexSignature()) { @@ -6935,7 +6985,7 @@ var ts; ts.Debug.fail("Should not have attempted to parse class member declaration."); } function parseClassDeclaration(fullStart, modifiers) { - var node = createNode(194, fullStart); + var node = createNode(196, fullStart); setModifiers(node, modifiers); parseExpected(68); node.name = parseIdentifier(); @@ -6960,8 +7010,8 @@ var ts; return parseList(19, false, parseHeritageClause); } function parseHeritageClause() { - if (token === 78 || token === 101) { - var node = createNode(205); + if (token === 78 || token === 103) { + var node = createNode(215); node.token = token; nextToken(); node.types = parseDelimitedList(8, parseTypeReference); @@ -6970,15 +7020,15 @@ var ts; return undefined; } function isHeritageClause() { - return token === 78 || token === 101; + return token === 78 || token === 103; } function parseClassMembers() { return parseList(6, false, parseClassElement); } function parseInterfaceDeclaration(fullStart, modifiers) { - var node = createNode(195, fullStart); + var node = createNode(197, fullStart); setModifiers(node, modifiers); - parseExpected(102); + parseExpected(104); node.name = parseIdentifier(); node.typeParameters = parseTypeParameters(); node.heritageClauses = parseHeritageClauses(false); @@ -6986,9 +7036,9 @@ var ts; return finishNode(node); } function parseTypeAliasDeclaration(fullStart, modifiers) { - var node = createNode(196, fullStart); + var node = createNode(198, fullStart); setModifiers(node, modifiers); - parseExpected(121); + parseExpected(123); node.name = parseIdentifier(); parseExpected(52); node.type = parseType(); @@ -6996,13 +7046,13 @@ var ts; return finishNode(node); } function parseEnumMember() { - var node = createNode(209, scanner.getStartPos()); + var node = createNode(219, scanner.getStartPos()); node.name = parsePropertyName(); node.initializer = allowInAnd(parseNonParameterInitializer); return finishNode(node); } function parseEnumDeclaration(fullStart, modifiers) { - var node = createNode(197, fullStart); + var node = createNode(199, fullStart); setModifiers(node, modifiers); parseExpected(76); node.name = parseIdentifier(); @@ -7016,7 +7066,7 @@ var ts; return finishNode(node); } function parseModuleBlock() { - var node = createNode(199, scanner.getStartPos()); + var node = createNode(201, scanner.getStartPos()); if (parseExpected(14)) { node.statements = parseList(1, false, parseModuleElement); parseExpected(15); @@ -7027,7 +7077,7 @@ var ts; return finishNode(node); } function parseInternalModuleTail(fullStart, modifiers, flags) { - var node = createNode(198, fullStart); + var node = createNode(200, fullStart); setModifiers(node, modifiers); node.flags |= flags; node.name = parseIdentifier(); @@ -7035,49 +7085,144 @@ var ts; return finishNode(node); } function parseAmbientExternalModuleDeclaration(fullStart, modifiers) { - var node = createNode(198, fullStart); + var node = createNode(200, fullStart); setModifiers(node, modifiers); node.name = parseLiteralNode(true); node.body = parseModuleBlock(); return finishNode(node); } function parseModuleDeclaration(fullStart, modifiers) { - parseExpected(115); + parseExpected(117); return token === 8 ? parseAmbientExternalModuleDeclaration(fullStart, modifiers) : parseInternalModuleTail(fullStart, modifiers, modifiers ? modifiers.flags : 0); } function isExternalModuleReference() { - return token === 116 && + return token === 118 && lookAhead(nextTokenIsOpenParen); } function nextTokenIsOpenParen() { return nextToken() === 16; } - function parseImportDeclaration(fullStart, modifiers) { - var node = createNode(200, fullStart); - setModifiers(node, modifiers); + function nextTokenIsCommaOrFromKeyword() { + nextToken(); + return token === 23 || + token === 102; + } + function parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers) { parseExpected(84); - node.name = parseIdentifier(); - parseExpected(52); - node.moduleReference = parseModuleReference(); + var afterImportPos = scanner.getStartPos(); + var identifier; + if (isIdentifier()) { + identifier = parseIdentifier(); + if (token !== 23 && token !== 102) { + var importEqualsDeclaration = createNode(202, fullStart); + setModifiers(importEqualsDeclaration, modifiers); + importEqualsDeclaration.name = identifier; + parseExpected(52); + importEqualsDeclaration.moduleReference = parseModuleReference(); + parseSemicolon(); + return finishNode(importEqualsDeclaration); + } + } + var importDeclaration = createNode(203, fullStart); + setModifiers(importDeclaration, modifiers); + if (identifier || + token === 35 || + token === 14) { + importDeclaration.importClause = parseImportClause(identifier, afterImportPos); + parseExpected(102); + } + importDeclaration.moduleSpecifier = parseModuleSpecifier(); parseSemicolon(); - return finishNode(node); + return finishNode(importDeclaration); + } + function parseImportClause(identifier, fullStart) { + var importClause = createNode(204, fullStart); + if (identifier) { + importClause.name = identifier; + } + if (!importClause.name || + parseOptional(23)) { + importClause.namedBindings = token === 35 ? parseNamespaceImport() : parseNamedImportsOrExports(206); + } + return finishNode(importClause); } function parseModuleReference() { return isExternalModuleReference() ? parseExternalModuleReference() : parseEntityName(false); } function parseExternalModuleReference() { - var node = createNode(202); - parseExpected(116); + var node = createNode(212); + parseExpected(118); parseExpected(16); - node.expression = parseExpression(); - if (node.expression.kind === 8) { - internIdentifier(node.expression.text); - } + node.expression = parseModuleSpecifier(); parseExpected(17); return finishNode(node); } + function parseModuleSpecifier() { + var result = parseExpression(); + if (result.kind === 8) { + internIdentifier(result.text); + } + return result; + } + function parseNamespaceImport() { + var namespaceImport = createNode(205); + parseExpected(35); + parseExpected(101); + namespaceImport.name = parseIdentifier(); + return finishNode(namespaceImport); + } + function parseNamedImportsOrExports(kind) { + var node = createNode(kind); + node.elements = parseBracketedList(20, kind === 206 ? parseImportSpecifier : parseExportSpecifier, 14, 15); + return finishNode(node); + } + function parseExportSpecifier() { + return parseImportOrExportSpecifier(211); + } + function parseImportSpecifier() { + return parseImportOrExportSpecifier(207); + } + function parseImportOrExportSpecifier(kind) { + var node = createNode(kind); + var isFirstIdentifierNameNotAnIdentifier = ts.isKeyword(token) && !isIdentifier(); + var start = scanner.getTokenPos(); + var identifierName = parseIdentifierName(); + if (token === 101) { + node.propertyName = identifierName; + parseExpected(101); + if (isIdentifier()) { + node.name = parseIdentifierName(); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected); + } + } + else { + node.name = identifierName; + if (isFirstIdentifierNameNotAnIdentifier) { + parseErrorAtPosition(start, identifierName.end - start, ts.Diagnostics.Identifier_expected); + } + } + return finishNode(node); + } + function parseExportDeclaration(fullStart, modifiers) { + var node = createNode(209, fullStart); + setModifiers(node, modifiers); + if (parseOptional(35)) { + parseExpected(102); + node.moduleSpecifier = parseModuleSpecifier(); + } + else { + node.exportClause = parseNamedImportsOrExports(210); + if (parseOptional(102)) { + node.moduleSpecifier = parseModuleSpecifier(); + } + } + parseSemicolon(); + return finishNode(node); + } function parseExportAssignmentTail(fullStart, modifiers) { - var node = createNode(201, fullStart); + var node = createNode(208, fullStart); setModifiers(node, modifiers); node.exportName = parseIdentifier(); parseSemicolon(); @@ -7092,23 +7237,24 @@ var ts; case 69: case 82: return true; - case 103: + case 105: return isLetDeclaration(); case 68: - case 102: + case 104: case 76: - case 84: - case 121: + case 123: return lookAhead(nextTokenIsIdentifierOrKeyword); - case 115: + case 84: + return lookAhead(nextTokenCanFollowImportKeyword); + case 117: return lookAhead(nextTokenIsIdentifierOrKeywordOrStringLiteral); case 77: - return lookAhead(nextTokenIsEqualsTokenOrDeclarationStart); - case 113: + return lookAhead(nextTokenCanFollowExportKeyword); + case 115: + case 109: case 107: - case 105: - case 106: case 108: + case 110: return lookAhead(nextTokenIsDeclarationStart); } } @@ -7123,14 +7269,23 @@ var ts; nextToken(); return isIdentifierOrKeyword() || token === 8; } - function nextTokenIsEqualsTokenOrDeclarationStart() { + function nextTokenCanFollowImportKeyword() { nextToken(); - return token === 52 || isDeclarationStart(); + return isIdentifierOrKeyword() || token === 8 || + token === 35 || token === 14; + } + function nextTokenCanFollowExportKeyword() { + nextToken(); + return token === 52 || token === 35 || + token === 14 || isDeclarationStart(); } function nextTokenIsDeclarationStart() { nextToken(); return isDeclarationStart(); } + function nextTokenIsAsKeyword() { + return nextToken() === 101; + } function parseDeclaration() { var fullStart = getNodePos(); var modifiers = parseModifiers(); @@ -7139,26 +7294,29 @@ var ts; if (parseOptional(52)) { return parseExportAssignmentTail(fullStart, modifiers); } + if (token === 35 || token === 14) { + return parseExportDeclaration(fullStart, modifiers); + } } switch (token) { case 97: - case 103: + case 105: case 69: return parseVariableStatement(fullStart, modifiers); case 82: return parseFunctionDeclaration(fullStart, modifiers); case 68: return parseClassDeclaration(fullStart, modifiers); - case 102: + case 104: return parseInterfaceDeclaration(fullStart, modifiers); - case 121: + case 123: return parseTypeAliasDeclaration(fullStart, modifiers); case 76: return parseEnumDeclaration(fullStart, modifiers); - case 115: + case 117: return parseModuleDeclaration(fullStart, modifiers); case 84: - return parseImportDeclaration(fullStart, modifiers); + return parseImportDeclarationOrImportEqualsDeclaration(fullStart, modifiers); default: ts.Debug.fail("Mismatch between isDeclarationStart and parseDeclaration"); } @@ -7231,28 +7389,28 @@ var ts; } function setExternalModuleIndicator(sourceFile) { sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) { - return node.flags & 1 || node.kind === 200 && node.moduleReference.kind === 202 || node.kind === 201 ? node : undefined; + return node.flags & 1 || node.kind === 202 && node.moduleReference.kind === 212 || node.kind === 203 || node.kind === 208 || node.kind === 209 ? node : undefined; }); } } function isLeftHandSideExpression(expr) { if (expr) { switch (expr.kind) { - case 151: - case 152: - case 154: case 153: + case 154: + case 156: case 155: - case 149: case 157: - case 150: - case 158: + case 151: + case 159: + case 152: + case 160: case 64: case 9: case 7: case 8: case 10: - case 167: + case 169: case 79: case 88: case 92: @@ -7279,16 +7437,16 @@ var ts; })(ts.ModuleInstanceState || (ts.ModuleInstanceState = {})); var ModuleInstanceState = ts.ModuleInstanceState; function getModuleInstanceState(node) { - if (node.kind === 195 || node.kind === 196) { + if (node.kind === 197 || node.kind === 198) { return 0; } else if (ts.isConstEnumDeclaration(node)) { return 2; } - else if (node.kind === 200 && !(node.flags & 1)) { + else if ((node.kind === 203 || node.kind === 202) && !(node.flags & 1)) { return 0; } - else if (node.kind === 199) { + else if (node.kind === 201) { var state = 0; ts.forEachChild(node, function (n) { switch (getModuleInstanceState(n)) { @@ -7304,7 +7462,7 @@ var ts; }); return state; } - else if (node.kind === 198) { + else if (node.kind === 200) { return getModuleInstanceState(node.body); } else { @@ -7350,10 +7508,10 @@ var ts; } function getDeclarationName(node) { if (node.name) { - if (node.kind === 198 && node.name.kind === 8) { + if (node.kind === 200 && node.name.kind === 8) { return '"' + node.name.text + '"'; } - if (node.name.kind === 124) { + if (node.name.kind === 126) { var nameExpression = node.name.expression; ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression)); return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text); @@ -7361,15 +7519,15 @@ var ts; return node.name.text; } switch (node.kind) { - case 139: - case 131: + case 141: + case 133: return "__constructor"; - case 138: - case 134: - return "__call"; - case 135: - return "__new"; + case 140: case 136: + return "__call"; + case 137: + return "__new"; + case 138: return "__index"; } } @@ -7398,7 +7556,7 @@ var ts; } addDeclarationToSymbol(symbol, node, includes); symbol.parent = parent; - if (node.kind === 194 && symbol.exports) { + if (node.kind === 196 && symbol.exports) { var prototypeSymbol = createSymbol(4 | 134217728, "prototype"); if (ts.hasProperty(symbol.exports, prototypeSymbol.name)) { if (node.name) { @@ -7420,29 +7578,28 @@ var ts; return false; } function declareModuleMember(node, symbolKind, symbolExcludes) { - var exportKind = 0; - if (symbolKind & 107455) { - exportKind |= 1048576; + var hasExportModifier = ts.getCombinedNodeFlags(node) & 1; + if (symbolKind & 8388608) { + if (node.kind === 211 || (node.kind === 202 && hasExportModifier)) { + declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + } + else { + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); + } } - if (symbolKind & 793056) { - exportKind |= 2097152; - } - if (symbolKind & 1536) { - exportKind |= 4194304; - } - if (ts.getCombinedNodeFlags(node) & 1 || (node.kind !== 200 && isAmbientContext(container))) { - if (exportKind) { + else { + if (hasExportModifier || isAmbientContext(container)) { + var exportKind = (symbolKind & 107455 ? 1048576 : 0) | + (symbolKind & 793056 ? 2097152 : 0) | + (symbolKind & 1536 ? 4194304 : 0); var local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes); local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); node.localSymbol = local; } else { - declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); + declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); } } - else { - declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); - } } function bindChildren(node, symbolKind, isBlockScopeContainer) { if (symbolKind & 255504) { @@ -7469,40 +7626,40 @@ var ts; } function bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer) { switch (container.kind) { - case 198: + case 200: declareModuleMember(node, symbolKind, symbolExcludes); break; - case 210: + case 220: if (ts.isExternalModule(container)) { declareModuleMember(node, symbolKind, symbolExcludes); break; } + case 140: + case 141: + case 136: + case 137: case 138: - case 139: + case 132: + case 131: + case 133: case 134: case 135: - case 136: - case 130: - case 129: - case 131: - case 132: - case 133: - case 193: - case 158: - case 159: + case 195: + case 160: + case 161: declareSymbol(container.locals, undefined, node, symbolKind, symbolExcludes); break; - case 194: + case 196: if (node.flags & 128) { declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } - case 141: - case 150: - case 195: + case 143: + case 152: + case 197: declareSymbol(container.symbol.members, container.symbol, node, symbolKind, symbolExcludes); break; - case 197: + case 199: declareSymbol(container.symbol.exports, container.symbol, node, symbolKind, symbolExcludes); break; } @@ -7528,6 +7685,12 @@ var ts; } } } + function bindExportDeclaration(node) { + if (!node.exportClause) { + (container.exportStars || (container.exportStars = [])).push(node); + } + bindChildren(node, 0, false); + } function bindFunctionOrConstructorType(node) { var symbol = createSymbol(131072, getDeclarationName(node)); addDeclarationToSymbol(symbol, node, 131072); @@ -7535,7 +7698,7 @@ var ts; var typeLiteralSymbol = createSymbol(2048, "__type"); addDeclarationToSymbol(typeLiteralSymbol, node, 2048); typeLiteralSymbol.members = {}; - typeLiteralSymbol.members[node.kind === 138 ? "__call" : "__new"] = symbol; + typeLiteralSymbol.members[node.kind === 140 ? "__call" : "__new"] = symbol; } function bindAnonymousDeclaration(node, symbolKind, name, isBlockScopeContainer) { var symbol = createSymbol(symbolKind, name); @@ -7554,10 +7717,10 @@ var ts; } function bindBlockScopedVariableDeclaration(node) { switch (blockScopeContainer.kind) { - case 198: + case 200: declareModuleMember(node, 2, 107455); break; - case 210: + case 220: if (ts.isExternalModule(container)) { declareModuleMember(node, 2, 107455); break; @@ -7576,14 +7739,14 @@ var ts; function bind(node) { node.parent = parent; switch (node.kind) { - case 125: + case 127: bindDeclaration(node, 262144, 530912, false); break; - case 126: + case 128: bindParameter(node); break; - case 191: - case 148: + case 193: + case 150: if (ts.isBindingPattern(node.name)) { bindChildren(node, 0, false); } @@ -7594,65 +7757,65 @@ var ts; bindDeclaration(node, 1, 107454, false); } break; - case 128: - case 127: - bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); - break; - case 207: - case 208: - bindPropertyOrMethodOrAccessor(node, 4, 107455, false); - break; - case 209: - bindPropertyOrMethodOrAccessor(node, 8, 107455, false); - break; - case 134: - case 135: - case 136: - bindDeclaration(node, 131072, 0, false); - break; case 130: case 129: - bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); + bindPropertyOrMethodOrAccessor(node, 4 | (node.questionToken ? 536870912 : 0), 107455, false); break; - case 193: - bindDeclaration(node, 16, 106927, true); + case 217: + case 218: + bindPropertyOrMethodOrAccessor(node, 4, 107455, false); break; - case 131: - bindDeclaration(node, 16384, 0, true); + case 219: + bindPropertyOrMethodOrAccessor(node, 8, 107455, false); + break; + case 136: + case 137: + case 138: + bindDeclaration(node, 131072, 0, false); break; case 132: - bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); - break; - case 133: - bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); - break; - case 138: - case 139: - bindFunctionOrConstructorType(node); - break; - case 141: - bindAnonymousDeclaration(node, 2048, "__type", false); - break; - case 150: - bindAnonymousDeclaration(node, 4096, "__object", false); - break; - case 158: - case 159: - bindAnonymousDeclaration(node, 16, "__function", true); - break; - case 206: - bindCatchVariableDeclaration(node); - break; - case 194: - bindDeclaration(node, 32, 899583, false); + case 131: + bindPropertyOrMethodOrAccessor(node, 8192 | (node.questionToken ? 536870912 : 0), ts.isObjectLiteralMethod(node) ? 107455 : 99263, true); break; case 195: - bindDeclaration(node, 64, 792992, false); + bindDeclaration(node, 16, 106927, true); + break; + case 133: + bindDeclaration(node, 16384, 0, true); + break; + case 134: + bindPropertyOrMethodOrAccessor(node, 32768, 41919, true); + break; + case 135: + bindPropertyOrMethodOrAccessor(node, 65536, 74687, true); + break; + case 140: + case 141: + bindFunctionOrConstructorType(node); + break; + case 143: + bindAnonymousDeclaration(node, 2048, "__type", false); + break; + case 152: + bindAnonymousDeclaration(node, 4096, "__object", false); + break; + case 160: + case 161: + bindAnonymousDeclaration(node, 16, "__function", true); + break; + case 216: + bindCatchVariableDeclaration(node); break; case 196: - bindDeclaration(node, 524288, 793056, false); + bindDeclaration(node, 32, 899583, false); break; case 197: + bindDeclaration(node, 64, 792992, false); + break; + case 198: + bindDeclaration(node, 524288, 793056, false); + break; + case 199: if (ts.isConst(node)) { bindDeclaration(node, 128, 899967, false); } @@ -7660,25 +7823,39 @@ var ts; bindDeclaration(node, 256, 899327, false); } break; - case 198: + case 200: bindModuleDeclaration(node); break; - case 200: + case 202: + case 205: + case 207: + case 211: bindDeclaration(node, 8388608, 8388608, false); break; - case 210: + case 209: + bindExportDeclaration(node); + break; + case 204: + if (node.name) { + bindDeclaration(node, 8388608, 8388608, false); + } + else { + bindChildren(node, 0, false); + } + break; + case 220: if (ts.isExternalModule(node)) { bindAnonymousDeclaration(node, 512, '"' + ts.removeFileExtension(node.fileName) + '"', true); break; } - case 172: + case 174: bindChildren(node, 0, !ts.isAnyFunction(node.parent)); break; - case 206: - case 179: - case 180: + case 216: case 181: - case 186: + case 182: + case 183: + case 188: bindChildren(node, 0, true); break; default: @@ -7696,8 +7873,8 @@ var ts; bindDeclaration(node, 1, 107455, false); } if (node.flags & 112 && - node.parent.kind === 131 && - node.parent.parent.kind === 194) { + node.parent.kind === 133 && + node.parent.parent.kind === 196) { var classDeclaration = node.parent.parent; declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4, 107455); } @@ -7890,7 +8067,7 @@ var ts; recordMergedSymbol(result, symbol); return result; } - function extendSymbol(target, source) { + function mergeSymbol(target, source) { if (!(target.flags & getExcludedSymbolFlags(source.flags))) { if (source.flags & 512 && target.flags & 512 && target.constEnumOnlyModule && !source.constEnumOnlyModule) { target.constEnumOnlyModule = false; @@ -7904,12 +8081,12 @@ var ts; if (source.members) { if (!target.members) target.members = {}; - extendSymbolTable(target.members, source.members); + mergeSymbolTable(target.members, source.members); } if (source.exports) { if (!target.exports) target.exports = {}; - extendSymbolTable(target.exports, source.exports); + mergeSymbolTable(target.exports, source.exports); } recordMergedSymbol(target, source); } @@ -7932,7 +8109,7 @@ var ts; } return result; } - function extendSymbolTable(target, source) { + function mergeSymbolTable(target, source) { for (var id in source) { if (ts.hasProperty(source, id)) { if (!ts.hasProperty(target, id)) { @@ -7943,11 +8120,18 @@ var ts; if (!(symbol.flags & 33554432)) { target[id] = symbol = cloneSymbol(symbol); } - extendSymbol(symbol, source[id]); + mergeSymbol(symbol, source[id]); } } } } + function extendSymbolTable(target, source) { + for (var id in source) { + if (!ts.hasProperty(target, id)) { + target[id] = source[id]; + } + } + } function getSymbolLinks(symbol) { if (symbol.flags & 67108864) return symbol; @@ -7961,10 +8145,10 @@ var ts; return nodeLinks[node.id] || (nodeLinks[node.id] = {}); } function getSourceFile(node) { - return ts.getAncestor(node, 210); + return ts.getAncestor(node, 220); } function isGlobalSourceFile(node) { - return node.kind === 210 && !ts.isExternalModule(node); + return node.kind === 220 && !ts.isExternalModule(node); } function getSymbol(symbols, name, meaning) { if (meaning && ts.hasProperty(symbols, name)) { @@ -8005,22 +8189,25 @@ var ts; } } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) break; - case 198: + case 200: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8914931)) { - break loop; + if (!(result.flags & 8388608 && getDeclarationOfImportSymbol(result).kind === 211)) { + break loop; + } + result = undefined; } break; - case 197: + case 199: if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8)) { break loop; } break; - case 128: - case 127: - if (location.parent.kind === 194 && !(location.flags & 128)) { + case 130: + case 129: + if (location.parent.kind === 196 && !(location.flags & 128)) { var ctor = findConstructorDeclaration(location.parent); if (ctor && ctor.locals) { if (getSymbol(ctor.locals, name, meaning & 107455)) { @@ -8029,8 +8216,8 @@ var ts; } } break; - case 194: - case 195: + case 196: + case 197: 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); @@ -8039,28 +8226,28 @@ var ts; break loop; } break; - case 124: + case 126: var grandparent = location.parent.parent; - if (grandparent.kind === 194 || grandparent.kind === 195) { + if (grandparent.kind === 196 || grandparent.kind === 197) { 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 130: - case 129: - case 131: case 132: + case 131: case 133: - case 193: - case 159: + case 134: + case 135: + case 195: + case 161: if (name === "arguments") { result = argumentsSymbol; break loop; } break; - case 158: + case 160: if (name === "arguments") { result = argumentsSymbol; break loop; @@ -8071,7 +8258,7 @@ var ts; break loop; } break; - case 206: + case 216: var id = location.name; if (name === id.text) { result = location.symbol; @@ -8107,18 +8294,78 @@ var ts; } return result; } + function isImportSymbolDeclaration(node) { + return node.kind === 202 || + node.kind === 204 && !!node.name || + node.kind === 205 || + node.kind === 207 || + node.kind === 211; + } + function getDeclarationOfImportSymbol(symbol) { + return ts.forEach(symbol.declarations, function (d) { return isImportSymbolDeclaration(d) ? d : undefined; }); + } + function getTargetOfImportEqualsDeclaration(node) { + if (node.moduleReference.kind === 212) { + var moduleSymbol = resolveExternalModuleName(node, ts.getExternalModuleImportEqualsDeclarationExpression(node)); + var exportAssignmentSymbol = moduleSymbol && getResolvedExportAssignmentSymbol(moduleSymbol); + return exportAssignmentSymbol || moduleSymbol; + } + return getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, node); + } + function getTargetOfImportClause(node) { + var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); + if (moduleSymbol) { + var exportAssignmentSymbol = getResolvedExportAssignmentSymbol(moduleSymbol); + if (!exportAssignmentSymbol) { + error(node.name, ts.Diagnostics.External_module_0_has_no_default_export_or_export_assignment, symbolToString(moduleSymbol)); + } + return exportAssignmentSymbol; + } + } + function getTargetOfNamespaceImport(node) { + return resolveExternalModuleName(node, node.parent.parent.moduleSpecifier); + } + function getExternalModuleMember(node, specifier) { + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleSymbol) { + var name = specifier.propertyName || specifier.name; + if (name.text) { + var symbol = getSymbol(getExportsOfSymbol(moduleSymbol), name.text, 107455 | 793056 | 1536); + if (!symbol) { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(moduleSymbol), ts.declarationNameToString(name)); + return; + } + return symbol.flags & (107455 | 793056 | 1536) ? symbol : resolveImport(symbol); + } + } + } + function getTargetOfImportSpecifier(node) { + return getExternalModuleMember(node.parent.parent.parent, node); + } + function getTargetOfExportSpecifier(node) { + return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : resolveEntityName(node, node.propertyName || node.name, 107455 | 793056 | 1536); + } + function getTargetOfImportDeclaration(node) { + switch (node.kind) { + case 202: + return getTargetOfImportEqualsDeclaration(node); + case 204: + return getTargetOfImportClause(node); + case 205: + return getTargetOfNamespaceImport(node); + case 207: + return getTargetOfImportSpecifier(node); + case 211: + return getTargetOfExportSpecifier(node); + } + } function resolveImport(symbol) { ts.Debug.assert((symbol.flags & 8388608) !== 0, "Should only get Imports here."); var links = getSymbolLinks(symbol); if (!links.target) { links.target = resolvingSymbol; - var node = ts.getDeclarationOfKind(symbol, 200); - if (node.moduleReference.kind === 202) { - if (node.moduleReference.expression.kind !== 8) { - grammarErrorOnNode(node.moduleReference.expression, ts.Diagnostics.String_literal_expected); - } - } - var target = node.moduleReference.kind === 202 ? resolveExternalModuleName(node, ts.getExternalModuleImportDeclarationExpression(node)) : getSymbolOfPartOfRightHandSideOfImport(node.moduleReference, node); + var node = getDeclarationOfImportSymbol(symbol); + var target = getTargetOfImportDeclaration(node); if (links.target === resolvingSymbol) { links.target = target || unknownSymbol; } @@ -8131,19 +8378,19 @@ var ts; } return links.target; } - function getSymbolOfPartOfRightHandSideOfImport(entityName, importDeclaration) { + function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration) { if (!importDeclaration) { - importDeclaration = ts.getAncestor(entityName, 200); + importDeclaration = ts.getAncestor(entityName, 202); ts.Debug.assert(importDeclaration !== undefined); } if (entityName.kind === 64 && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { entityName = entityName.parent; } - if (entityName.kind === 64 || entityName.parent.kind === 123) { + if (entityName.kind === 64 || entityName.parent.kind === 125) { return resolveEntityName(importDeclaration, entityName, 1536); } else { - ts.Debug.assert(entityName.parent.kind === 200); + ts.Debug.assert(entityName.parent.kind === 202); return resolveEntityName(importDeclaration, entityName, 107455 | 793056 | 1536); } } @@ -8160,11 +8407,11 @@ var ts; return; } } - else if (name.kind === 123) { + else if (name.kind === 125) { var namespace = resolveEntityName(location, name.left, 1536); if (!namespace || namespace === unknownSymbol || ts.getFullWidth(name.right) === 0) return; - var symbol = getSymbol(namespace.exports, name.right.text, meaning); + var symbol = getSymbol(getExportsOfSymbol(namespace), name.right.text, meaning); if (!symbol) { error(location, ts.Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace), ts.declarationNameToString(name.right)); return; @@ -8189,7 +8436,7 @@ var ts; if (!isRelative) { var symbol = getSymbol(globals, '"' + moduleName + '"', 512); if (symbol) { - return getResolvedExportSymbol(symbol); + return symbol; } } while (true) { @@ -8204,14 +8451,14 @@ var ts; } if (sourceFile) { if (sourceFile.symbol) { - return getResolvedExportSymbol(sourceFile.symbol); + return sourceFile.symbol; } error(moduleReferenceLiteral, ts.Diagnostics.File_0_is_not_an_external_module, sourceFile.fileName); return; } error(moduleReferenceLiteral, ts.Diagnostics.Cannot_find_external_module_0, moduleName); } - function getResolvedExportSymbol(moduleSymbol) { + function getResolvedExportAssignmentSymbol(moduleSymbol) { var symbol = getExportAssignmentSymbol(moduleSymbol); if (symbol) { if (symbol.flags & (107455 | 793056 | 1536)) { @@ -8221,16 +8468,14 @@ var ts; return resolveImport(symbol); } } - return moduleSymbol; } function getExportAssignmentSymbol(symbol) { checkTypeOfExportAssignmentSymbol(symbol); - var symbolLinks = getSymbolLinks(symbol); - return symbolLinks.exportAssignSymbol === unknownSymbol ? undefined : symbolLinks.exportAssignSymbol; + return getSymbolLinks(symbol).exportAssignmentSymbol; } function checkTypeOfExportAssignmentSymbol(containerSymbol) { var symbolLinks = getSymbolLinks(containerSymbol); - if (!symbolLinks.exportAssignSymbol) { + if (!symbolLinks.exportAssignmentChecked) { var exportInformation = collectExportInformationForSourceFileOrModule(containerSymbol); if (exportInformation.exportAssignments.length) { if (exportInformation.exportAssignments.length > 1) { @@ -8244,17 +8489,18 @@ var ts; var meaning = 107455 | 793056 | 1536; var exportSymbol = resolveName(node, node.exportName.text, meaning, ts.Diagnostics.Cannot_find_name_0, node.exportName); } + symbolLinks.exportAssignmentSymbol = exportSymbol || unknownSymbol; } - symbolLinks.exportAssignSymbol = exportSymbol || unknownSymbol; + symbolLinks.exportAssignmentChecked = true; } } function collectExportInformationForSourceFileOrModule(symbol) { var seenExportedMember = false; var result = []; ts.forEach(symbol.declarations, function (declaration) { - var block = (declaration.kind === 210 ? declaration : declaration.body); + var block = (declaration.kind === 220 ? declaration : declaration.body); ts.forEach(block.statements, function (node) { - if (node.kind === 201) { + if (node.kind === 208) { result.push(node); } else { @@ -8267,6 +8513,37 @@ var ts; exportAssignments: result }; } + function getExportsOfSymbol(symbol) { + return symbol.flags & 1536 ? getExportsOfModule(symbol) : symbol.exports; + } + function getExportsOfModule(symbol) { + var links = getSymbolLinks(symbol); + return links.resolvedExports || (links.resolvedExports = getExportsForModule(symbol)); + } + function getExportsForModule(symbol) { + var result; + var visitedSymbols = []; + visit(symbol); + return result; + function visit(symbol) { + if (!ts.contains(visitedSymbols, symbol)) { + visitedSymbols.push(symbol); + if (!result) { + result = symbol.exports; + } + else { + extendSymbolTable(result, symbol.exports); + } + ts.forEach(symbol.declarations, function (node) { + if (node.kind === 220 || node.kind === 200) { + ts.forEach(node.exportStars, function (exportStar) { + visit(resolveExternalModuleName(exportStar, exportStar.moduleSpecifier)); + }); + } + }); + } + } + } function getMergedSymbol(symbol) { var merged; return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol; @@ -8296,7 +8573,7 @@ var ts; var members = node.members; for (var i = 0; i < members.length; i++) { var member = members[i]; - if (member.kind === 131 && ts.nodeIsPresent(member.body)) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { return member; } } @@ -8361,17 +8638,17 @@ var ts; } } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) { break; } - case 198: + case 200: if (result = callback(getSymbolOfNode(location).exports)) { return result; } break; - case 194: - case 195: + case 196: + case 197: if (result = callback(getSymbolOfNode(location).members)) { return result; } @@ -8404,7 +8681,7 @@ var ts; return ts.forEachValue(symbols, function (symbolFromSymbolTable) { if (symbolFromSymbolTable.flags & 8388608) { if (!useOnlyExternalAliasing || - ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportDeclaration)) { + ts.forEach(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) { var resolvedImportedSymbol = resolveImport(symbolFromSymbolTable); if (isAccessible(symbolFromSymbolTable, resolveImport(symbolFromSymbolTable))) { return [symbolFromSymbolTable]; @@ -8486,8 +8763,8 @@ var ts; } } function hasExternalModuleSymbol(declaration) { - return (declaration.kind === 198 && declaration.name.kind === 8) || - (declaration.kind === 210 && ts.isExternalModule(declaration)); + return (declaration.kind === 200 && declaration.name.kind === 8) || + (declaration.kind === 220 && ts.isExternalModule(declaration)); } function hasVisibleDeclarations(symbol) { var aliasesToMakeVisible; @@ -8497,7 +8774,7 @@ var ts; return { accessibility: 0, aliasesToMakeVisible: aliasesToMakeVisible }; function getIsDeclarationVisible(declaration) { if (!isDeclarationVisible(declaration)) { - if (declaration.kind === 200 && + if (declaration.kind === 202 && !(declaration.flags & 1) && isDeclarationVisible(declaration.parent)) { getNodeLinks(declaration).isVisible = true; @@ -8518,11 +8795,11 @@ var ts; } function isEntityNameVisible(entityName, enclosingDeclaration) { var meaning; - if (entityName.parent.kind === 140) { + if (entityName.parent.kind === 142) { meaning = 107455 | 1048576; } - else if (entityName.kind === 123 || - entityName.parent.kind === 200) { + else if (entityName.kind === 125 || + entityName.parent.kind === 202) { meaning = 1536; } else { @@ -8566,10 +8843,10 @@ var ts; function getTypeAliasForTypeLiteral(type) { if (type.symbol && type.symbol.flags & 2048) { var node = type.symbol.declarations[0].parent; - while (node.kind === 145) { + while (node.kind === 147) { node = node.parent; } - if (node.kind === 196) { + if (node.kind === 198) { return getSymbolOfNode(node); } } @@ -8722,7 +8999,7 @@ var ts; buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, 793056, 0, flags); } else { - writeKeyword(writer, 110); + writeKeyword(writer, 112); } } else { @@ -8740,7 +9017,7 @@ var ts; var isNonLocalFunctionSymbol = !!(type.symbol.flags & 16) && (type.symbol.parent || ts.forEach(type.symbol.declarations, function (declaration) { - return declaration.parent.kind === 210 || declaration.parent.kind === 199; + return declaration.parent.kind === 220 || declaration.parent.kind === 201; })); if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { return !!(flags & 2) || @@ -8813,7 +9090,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 0, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 119); + writeKeyword(writer, 121); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -8826,7 +9103,7 @@ var ts; writer.writeParameter(getIndexerParameterName(resolved, 1, "x")); writePunctuation(writer, 51); writeSpace(writer); - writeKeyword(writer, 117); + writeKeyword(writer, 119); writePunctuation(writer, 19); writePunctuation(writer, 51); writeSpace(writer); @@ -8969,12 +9246,12 @@ var ts; function isDeclarationVisible(node) { function getContainingExternalModule(node) { for (; node; node = node.parent) { - if (node.kind === 198) { + if (node.kind === 200) { if (node.name.kind === 8) { return node; } } - else if (node.kind === 210) { + else if (node.kind === 220) { return ts.isExternalModule(node) ? node : undefined; } } @@ -9016,47 +9293,47 @@ var ts; } function determineIfDeclarationIsVisible() { switch (node.kind) { - case 191: - case 148: - case 198: - case 194: - case 195: - case 196: case 193: - case 197: + case 150: case 200: + case 196: + case 197: + case 198: + case 195: + case 199: + case 202: var parent = getDeclarationContainer(node); if (!(ts.getCombinedNodeFlags(node) & 1) && - !(node.kind !== 200 && parent.kind !== 210 && ts.isInAmbientContext(parent))) { + !(node.kind !== 202 && parent.kind !== 220 && ts.isInAmbientContext(parent))) { return isGlobalSourceFile(parent) || isUsedInExportAssignment(node); } return isDeclarationVisible(parent); - case 128: - case 127: - case 132: - case 133: case 130: case 129: + case 134: + case 135: + case 132: + case 131: if (node.flags & (32 | 64)) { return false; } - case 131: - case 135: - case 134: - case 136: - case 126: - case 199: - case 138: - case 139: - case 141: + case 133: case 137: - case 142: + case 136: + case 138: + case 128: + case 201: + case 140: + case 141: case 143: + case 139: case 144: case 145: + case 146: + case 147: return isDeclarationVisible(node.parent); - case 125: - case 210: + case 127: + case 220: return true; default: ts.Debug.fail("isDeclarationVisible unknown: SyntaxKind: " + node.kind); @@ -9071,14 +9348,14 @@ var ts; } } function getRootDeclaration(node) { - while (node.kind === 148) { + while (node.kind === 150) { node = node.parent.parent; } return node; } function getDeclarationContainer(node) { node = getRootDeclaration(node); - return node.kind === 191 ? node.parent.parent.parent : node.parent; + return node.kind === 193 ? node.parent.parent.parent : node.parent; } function getTypeOfPrototypeProperty(prototype) { var classType = getDeclaredTypeOfSymbol(prototype.parent); @@ -9100,7 +9377,7 @@ var ts; } return parentType; } - if (pattern.kind === 146) { + if (pattern.kind === 148) { var name = declaration.propertyName || declaration.name; var type = getTypeOfPropertyOfType(parentType, name.text) || isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, 1) || @@ -9130,7 +9407,7 @@ var ts; return type; } function getTypeForVariableLikeDeclaration(declaration) { - if (declaration.parent.parent.kind === 180) { + if (declaration.parent.parent.kind === 182) { return anyType; } if (ts.isBindingPattern(declaration.parent)) { @@ -9139,10 +9416,10 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 126) { + if (declaration.kind === 128) { var func = declaration.parent; - if (func.kind === 133 && !ts.hasDynamicName(func)) { - var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 132); + if (func.kind === 135 && !ts.hasDynamicName(func)) { + var getter = ts.getDeclarationOfKind(declaration.parent.symbol, 134); if (getter) { return getReturnTypeOfSignature(getSignatureFromDeclaration(getter)); } @@ -9155,7 +9432,7 @@ var ts; if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - if (declaration.kind === 208) { + if (declaration.kind === 218) { return checkIdentifier(declaration.name); } return undefined; @@ -9184,7 +9461,7 @@ var ts; var hasSpreadElement = false; var elementTypes = []; ts.forEach(pattern.elements, function (e) { - elementTypes.push(e.kind === 170 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); + elementTypes.push(e.kind === 172 || e.dotDotDotToken ? anyType : getTypeFromBindingElement(e)); if (e.dotDotDotToken) { hasSpreadElement = true; } @@ -9192,7 +9469,7 @@ var ts; return !elementTypes.length ? anyArrayType : hasSpreadElement ? createArrayType(getUnionType(elementTypes)) : createTupleType(elementTypes); } function getTypeFromBindingPattern(pattern) { - return pattern.kind === 146 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); + return pattern.kind === 148 ? getTypeFromObjectBindingPattern(pattern) : getTypeFromArrayBindingPattern(pattern); } function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { var type = getTypeForVariableLikeDeclaration(declaration); @@ -9200,7 +9477,7 @@ var ts; if (reportErrors) { reportErrorsFromWidening(declaration, type); } - return declaration.kind !== 207 ? getWidenedType(type) : type; + return declaration.kind !== 217 ? getWidenedType(type) : type; } if (ts.isBindingPattern(declaration.name)) { return getTypeFromBindingPattern(declaration.name); @@ -9208,7 +9485,7 @@ var ts; type = declaration.dotDotDotToken ? anyArrayType : anyType; if (reportErrors && compilerOptions.noImplicitAny) { var root = getRootDeclaration(declaration); - if (!isPrivateWithinAmbient(root) && !(root.kind === 126 && isPrivateWithinAmbient(root.parent))) { + if (!isPrivateWithinAmbient(root) && !(root.kind === 128 && isPrivateWithinAmbient(root.parent))) { reportImplicitAnyError(declaration, type); } } @@ -9221,7 +9498,7 @@ var ts; return links.type = getTypeOfPrototypeProperty(symbol); } var declaration = symbol.valueDeclaration; - if (declaration.kind === 206) { + if (declaration.kind === 216) { return links.type = anyType; } links.type = resolvingType; @@ -9244,7 +9521,7 @@ var ts; } function getAnnotatedAccessorType(accessor) { if (accessor) { - if (accessor.kind === 132) { + if (accessor.kind === 134) { return accessor.type && getTypeFromTypeNode(accessor.type); } else { @@ -9263,8 +9540,8 @@ var ts; links = links || getSymbolLinks(symbol); if (!links.type) { links.type = resolvingType; - var getter = ts.getDeclarationOfKind(symbol, 132); - var setter = ts.getDeclarationOfKind(symbol, 133); + var getter = ts.getDeclarationOfKind(symbol, 134); + var setter = ts.getDeclarationOfKind(symbol, 135); var type; var getterReturnType = getAnnotatedAccessorType(getter); if (getterReturnType) { @@ -9294,7 +9571,7 @@ var ts; else if (links.type === resolvingType) { links.type = anyType; if (compilerOptions.noImplicitAny) { - var getter = ts.getDeclarationOfKind(symbol, 132); + var getter = ts.getDeclarationOfKind(symbol, 134); error(getter, 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)); } } @@ -9361,7 +9638,7 @@ var ts; function getTypeParametersOfClassOrInterface(symbol) { var result; ts.forEach(symbol.declarations, function (node) { - if (node.kind === 195 || node.kind === 194) { + if (node.kind === 197 || node.kind === 196) { var declaration = node; if (declaration.typeParameters && declaration.typeParameters.length) { ts.forEach(declaration.typeParameters, function (node) { @@ -9392,7 +9669,7 @@ var ts; type.typeArguments = type.typeParameters; } type.baseTypes = []; - var declaration = ts.getDeclarationOfKind(symbol, 194); + var declaration = ts.getDeclarationOfKind(symbol, 196); var baseTypeNode = ts.getClassBaseTypeNode(declaration); if (baseTypeNode) { var baseType = getTypeFromTypeReferenceNode(baseTypeNode); @@ -9433,7 +9710,7 @@ var ts; } type.baseTypes = []; ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 195 && ts.getInterfaceBaseTypeNodes(declaration)) { + if (declaration.kind === 197 && ts.getInterfaceBaseTypeNodes(declaration)) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), function (node) { var baseType = getTypeFromTypeReferenceNode(node); if (baseType !== unknownType) { @@ -9464,7 +9741,7 @@ var ts; var links = getSymbolLinks(symbol); if (!links.declaredType) { links.declaredType = resolvingType; - var declaration = ts.getDeclarationOfKind(symbol, 196); + var declaration = ts.getDeclarationOfKind(symbol, 198); var type = getTypeFromTypeNode(declaration.type); if (links.declaredType === resolvingType) { links.declaredType = type; @@ -9472,7 +9749,7 @@ var ts; } else if (links.declaredType === resolvingType) { links.declaredType = unknownType; - var declaration = ts.getDeclarationOfKind(symbol, 196); + var declaration = ts.getDeclarationOfKind(symbol, 198); error(declaration.name, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); } return links.declaredType; @@ -9491,7 +9768,7 @@ var ts; if (!links.declaredType) { var type = createType(512); type.symbol = symbol; - if (!ts.getDeclarationOfKind(symbol, 125).constraint) { + if (!ts.getDeclarationOfKind(symbol, 127).constraint) { type.constraint = noConstraintType; } links.declaredType = type; @@ -9700,7 +9977,7 @@ var ts; var callSignatures = emptyArray; var constructSignatures = emptyArray; if (symbol.flags & 1952) { - members = symbol.exports; + members = getExportsOfSymbol(symbol); } if (symbol.flags & (16 | 8192)) { callSignatures = getSignaturesOfSymbol(symbol); @@ -9897,7 +10174,7 @@ var ts; function getSignatureFromDeclaration(declaration) { var links = getNodeLinks(declaration); if (!links.resolvedSignature) { - var classType = declaration.kind === 131 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; + var classType = declaration.kind === 133 ? getDeclaredTypeOfClass(declaration.parent.symbol) : undefined; var typeParameters = classType ? classType.typeParameters : declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined; var parameters = []; var hasStringLiterals = false; @@ -9925,8 +10202,8 @@ var ts; returnType = getTypeFromTypeNode(declaration.type); } else { - if (declaration.kind === 132 && !ts.hasDynamicName(declaration)) { - var setter = ts.getDeclarationOfKind(declaration.symbol, 133); + if (declaration.kind === 134 && !ts.hasDynamicName(declaration)) { + var setter = ts.getDeclarationOfKind(declaration.symbol, 135); returnType = getAnnotatedAccessorType(setter); } if (!returnType && ts.nodeIsMissing(declaration.body)) { @@ -9944,19 +10221,19 @@ var ts; for (var i = 0, len = symbol.declarations.length; i < len; i++) { var node = symbol.declarations[i]; switch (node.kind) { - case 138: - case 139: - case 193: - case 130: - case 129: + case 140: + case 141: + case 195: + case 132: case 131: + case 133: + case 136: + case 137: + case 138: case 134: case 135: - case 136: - case 132: - case 133: - case 158: - case 159: + case 160: + case 161: if (i > 0 && node.body) { var previous = symbol.declarations[i - 1]; if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) { @@ -10025,7 +10302,7 @@ var ts; } function getOrCreateTypeFromSignature(signature) { if (!signature.isolatedSignatureType) { - var isConstructor = signature.declaration.kind === 131 || signature.declaration.kind === 135; + var isConstructor = signature.declaration.kind === 133 || signature.declaration.kind === 137; var type = createObjectType(32768 | 65536); type.members = emptySymbols; type.properties = emptyArray; @@ -10039,7 +10316,7 @@ var ts; return symbol.members["__index"]; } function getIndexDeclarationOfSymbol(symbol, kind) { - var syntaxKind = kind === 1 ? 117 : 119; + var syntaxKind = kind === 1 ? 119 : 121; var indexSymbol = getIndexSymbol(symbol); if (indexSymbol) { var len = indexSymbol.declarations.length; @@ -10066,7 +10343,7 @@ var ts; type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType; } else { - type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 125).constraint); + type.constraint = getTypeFromTypeNode(ts.getDeclarationOfKind(type.symbol, 127).constraint); } } return type.constraint === noConstraintType ? undefined : type.constraint; @@ -10114,13 +10391,13 @@ var ts; while (!ts.forEach(typeParameterSymbol.declarations, function (d) { return d.parent === currentNode.parent; })) { currentNode = currentNode.parent; } - links.isIllegalTypeReferenceInConstraint = currentNode.kind === 125; + links.isIllegalTypeReferenceInConstraint = currentNode.kind === 127; return links.isIllegalTypeReferenceInConstraint; } function checkTypeParameterHasIllegalReferencesInConstraint(typeParameter) { var typeParameterSymbol; function check(n) { - if (n.kind === 137 && n.typeName.kind === 64) { + if (n.kind === 139 && n.typeName.kind === 64) { var links = getNodeLinks(n); if (links.isIllegalTypeReferenceInConstraint === undefined) { var symbol = resolveName(typeParameter, n.typeName.text, 793056, undefined, undefined); @@ -10185,9 +10462,9 @@ var ts; for (var i = 0; i < declarations.length; i++) { var declaration = declarations[i]; switch (declaration.kind) { - case 194: - case 195: + case 196: case 197: + case 199: return declaration; } } @@ -10360,38 +10637,38 @@ var ts; } function getTypeFromTypeNode(node) { switch (node.kind) { - case 110: + case 112: return anyType; - case 119: + case 121: return stringType; - case 117: + case 119: return numberType; - case 111: + case 113: return booleanType; - case 120: + case 122: return esSymbolType; case 98: return voidType; case 8: return getTypeFromStringLiteral(node); - case 137: - return getTypeFromTypeReferenceNode(node); - case 140: - return getTypeFromTypeQueryNode(node); - case 142: - return getTypeFromArrayTypeNode(node); - case 143: - return getTypeFromTupleTypeNode(node); - case 144: - return getTypeFromUnionTypeNode(node); - case 145: - return getTypeFromTypeNode(node.type); - case 138: case 139: + return getTypeFromTypeReferenceNode(node); + case 142: + return getTypeFromTypeQueryNode(node); + case 144: + return getTypeFromArrayTypeNode(node); + case 145: + return getTypeFromTupleTypeNode(node); + case 146: + return getTypeFromUnionTypeNode(node); + case 147: + return getTypeFromTypeNode(node.type); + case 140: case 141: + case 143: return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); case 64: - case 123: + case 125: var symbol = getSymbolInfo(node); return symbol && getDeclaredTypeOfSymbol(symbol); default: @@ -10535,27 +10812,27 @@ var ts; return type; } function isContextSensitive(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); switch (node.kind) { - case 158: - case 159: + case 160: + case 161: return isContextSensitiveFunctionLikeDeclaration(node); - case 150: + case 152: return ts.forEach(node.properties, isContextSensitive); - case 149: + case 151: return ts.forEach(node.elements, isContextSensitive); - case 166: + case 168: return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse); - case 165: + case 167: return node.operatorToken.kind === 49 && (isContextSensitive(node.left) || isContextSensitive(node.right)); - case 207: + case 217: return isContextSensitive(node.initializer); - case 130: - case 129: + case 132: + case 131: return isContextSensitiveFunctionLikeDeclaration(node); - case 157: + case 159: return isContextSensitive(node.expression); } return false; @@ -11314,20 +11591,20 @@ var ts; function reportImplicitAnyError(declaration, type) { var typeAsString = typeToString(getWidenedType(type)); switch (declaration.kind) { - case 128: - case 127: - var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; - break; - case 126: - var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; - break; - case 193: case 130: case 129: + var diagnostic = ts.Diagnostics.Member_0_implicitly_has_an_1_type; + break; + case 128: + var diagnostic = declaration.dotDotDotToken ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type; + break; + case 195: case 132: - case 133: - case 158: - case 159: + case 131: + case 134: + case 135: + case 160: + case 161: if (!declaration.name) { error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); return; @@ -11556,10 +11833,10 @@ var ts; function isInTypeQuery(node) { while (node) { switch (node.kind) { - case 140: + case 142: return true; case 64: - case 123: + case 125: node = node.parent; continue; default: @@ -11598,7 +11875,7 @@ var ts; function isAssignedInBinaryExpression(node) { if (node.operatorToken.kind >= 52 && node.operatorToken.kind <= 63) { var n = node.left; - while (n.kind === 157) { + while (n.kind === 159) { n = n.expression; } if (n.kind === 64 && getResolvedSymbol(n) === symbol) { @@ -11615,46 +11892,46 @@ var ts; } function isAssignedIn(node) { switch (node.kind) { - case 165: + case 167: return isAssignedInBinaryExpression(node); - case 191: - case 148: - return isAssignedInVariableDeclaration(node); - case 146: - case 147: - case 149: + case 193: case 150: + return isAssignedInVariableDeclaration(node); + case 148: + case 149: case 151: case 152: case 153: case 154: + case 155: case 156: - case 157: - case 163: - case 160: - case 161: + case 158: + case 159: + case 165: case 162: + case 163: case 164: case 166: - case 169: - case 172: - case 173: + case 168: + case 171: + case 174: case 175: - case 176: case 177: case 178: case 179: case 180: case 181: - case 184: - case 185: + case 182: + case 183: case 186: - case 203: - case 204: case 187: case 188: + case 213: + case 214: case 189: - case 206: + case 190: + case 191: + case 216: return ts.forEachChild(node, isAssignedIn); } return false; @@ -11690,17 +11967,17 @@ var ts; node = node.parent; var narrowedType = type; switch (node.kind) { - case 176: + case 178: if (child !== node.expression) { narrowedType = narrowType(type, node.expression, child === node.thenStatement); } break; - case 166: + case 168: if (child !== node.condition) { narrowedType = narrowType(type, node.condition, child === node.whenTrue); } break; - case 165: + case 167: if (child === node.right) { if (node.operatorToken.kind === 48) { narrowedType = narrowType(type, node.left, true); @@ -11710,14 +11987,14 @@ var ts; } } break; - case 210: - case 198: - case 193: - case 130: - case 129: + case 220: + case 200: + case 195: case 132: - case 133: case 131: + case 134: + case 135: + case 133: break loop; } if (narrowedType !== type) { @@ -11730,7 +12007,7 @@ var ts; } return type; function narrowTypeByEquality(type, expr, assumeTrue) { - if (expr.left.kind !== 161 || expr.right.kind !== 8) { + if (expr.left.kind !== 163 || expr.right.kind !== 8) { return type; } var left = expr.left; @@ -11803,9 +12080,9 @@ var ts; } function narrowType(type, expr, assumeTrue) { switch (expr.kind) { - case 157: + case 159: return narrowType(type, expr.expression, assumeTrue); - case 165: + case 167: var operator = expr.operatorToken.kind; if (operator === 30 || operator === 31) { return narrowTypeByEquality(type, expr, assumeTrue); @@ -11820,7 +12097,7 @@ var ts; return narrowTypeByInstanceof(type, expr, assumeTrue); } break; - case 163: + case 165: if (expr.operator === 46) { return narrowType(type, expr.operand, !assumeTrue); } @@ -11830,27 +12107,29 @@ var ts; } } function markLinkedImportsAsReferenced(node) { - var nodeLinks = getNodeLinks(node); - while (nodeLinks.importOnRightSide) { - var rightSide = nodeLinks.importOnRightSide; - nodeLinks.importOnRightSide = undefined; - getSymbolLinks(rightSide).referenced = true; - ts.Debug.assert((rightSide.flags & 8388608) !== 0); - nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 200)); + if (node) { + var nodeLinks = getNodeLinks(node); + while (nodeLinks.importOnRightSide) { + var rightSide = nodeLinks.importOnRightSide; + nodeLinks.importOnRightSide = undefined; + getSymbolLinks(rightSide).referenced = true; + ts.Debug.assert((rightSide.flags & 8388608) !== 0); + nodeLinks = getNodeLinks(ts.getDeclarationOfKind(rightSide, 202)); + } } } function checkIdentifier(node) { var symbol = getResolvedSymbol(node); - if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 159) { + if (symbol === argumentsSymbol && ts.getContainingFunction(node).kind === 161) { error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_Consider_using_a_standard_function_expression); } if (symbol.flags & 8388608) { var symbolLinks = getSymbolLinks(symbol); if (!symbolLinks.referenced) { - var importOrExportAssignment = getLeftSideOfImportOrExportAssignment(node); + var importOrExportAssignment = getLeftSideOfImportEqualsOrExportAssignment(node); if (!importOrExportAssignment || (importOrExportAssignment.flags & 1) || - (importOrExportAssignment.kind === 201)) { + (importOrExportAssignment.kind === 208)) { symbolLinks.referenced = !isInTypeQuery(node) && !isConstEnumOrConstEnumOnlyModule(resolveImport(symbol)); } else { @@ -11860,7 +12139,7 @@ var ts; } } if (symbolLinks.referenced) { - markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 200)); + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); } } checkCollisionWithCapturedSuperVariable(node, node); @@ -11868,9 +12147,9 @@ var ts; return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node); } function captureLexicalThis(node, container) { - var classNode = container.parent && container.parent.kind === 194 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; getNodeLinks(node).flags |= 2; - if (container.kind === 128 || container.kind === 131) { + if (container.kind === 130 || container.kind === 133) { getNodeLinks(classNode).flags |= 4; } else { @@ -11880,36 +12159,36 @@ var ts; function checkThisExpression(node) { var container = ts.getThisContainer(node, true); var needToCaptureLexicalThis = false; - if (container.kind === 159) { + if (container.kind === 161) { container = ts.getThisContainer(container, false); needToCaptureLexicalThis = (languageVersion < 2); } switch (container.kind) { - case 198: + case 200: error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_body); break; - case 197: + case 199: error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); break; - case 131: + case 133: if (isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); } break; - case 128: - case 127: + case 130: + case 129: if (container.flags & 128) { error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer); } break; - case 124: + case 126: 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 === 194 ? container.parent : undefined; + var classNode = container.parent && container.parent.kind === 196 ? container.parent : undefined; if (classNode) { var symbol = getSymbolOfNode(classNode); return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); @@ -11918,15 +12197,15 @@ var ts; } function isInConstructorArgumentInitializer(node, constructorDecl) { for (var n = node; n && n !== constructorDecl; n = n.parent) { - if (n.kind === 126) { + if (n.kind === 128) { return true; } } return false; } function checkSuperExpression(node) { - var isCallExpression = node.parent.kind === 153 && node.parent.expression === node; - var enclosingClass = ts.getAncestor(node, 194); + var isCallExpression = node.parent.kind === 155 && node.parent.expression === node; + var enclosingClass = ts.getAncestor(node, 196); var baseClass; if (enclosingClass && ts.getClassBaseTypeNode(enclosingClass)) { var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass)); @@ -11940,31 +12219,31 @@ var ts; if (container) { var canUseSuperExpression = false; if (isCallExpression) { - canUseSuperExpression = container.kind === 131; + canUseSuperExpression = container.kind === 133; } else { var needToCaptureLexicalThis = false; - while (container && container.kind === 159) { + while (container && container.kind === 161) { container = ts.getSuperContainer(container, true); needToCaptureLexicalThis = true; } - if (container && container.parent && container.parent.kind === 194) { + if (container && container.parent && container.parent.kind === 196) { if (container.flags & 128) { canUseSuperExpression = - container.kind === 130 || - container.kind === 129 || container.kind === 132 || - container.kind === 133; + container.kind === 131 || + container.kind === 134 || + container.kind === 135; } else { canUseSuperExpression = + container.kind === 132 || + container.kind === 131 || + container.kind === 134 || + container.kind === 135 || container.kind === 130 || container.kind === 129 || - container.kind === 132 || - container.kind === 133 || - container.kind === 128 || - container.kind === 127 || - container.kind === 131; + container.kind === 133; } } } @@ -11978,7 +12257,7 @@ var ts; getNodeLinks(node).flags |= 16; returnType = baseClass; } - if (container.kind === 131 && isInConstructorArgumentInitializer(node, container)) { + if (container.kind === 133 && isInConstructorArgumentInitializer(node, container)) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); returnType = unknownType; } @@ -11988,7 +12267,7 @@ var ts; return returnType; } } - if (container.kind === 124) { + if (container.kind === 126) { error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); } else if (isCallExpression) { @@ -12026,7 +12305,7 @@ var ts; if (declaration.type) { return getTypeFromTypeNode(declaration.type); } - if (declaration.kind === 126) { + if (declaration.kind === 128) { var type = getContextuallyTypedParameterType(declaration); if (type) { return type; @@ -12041,7 +12320,7 @@ var ts; function getContextualTypeForReturnExpression(node) { var func = ts.getContainingFunction(node); if (func) { - if (func.type || func.kind === 131 || func.kind === 132 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 133))) { + if (func.type || func.kind === 133 || func.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(func.symbol, 135))) { return getReturnTypeOfSignature(getSignatureFromDeclaration(func)); } var signature = getContextualSignatureForFunctionLikeDeclaration(func); @@ -12061,7 +12340,7 @@ var ts; return undefined; } function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { - if (template.parent.kind === 155) { + if (template.parent.kind === 157) { return getContextualTypeForArgument(template.parent, substitutionExpression); } return undefined; @@ -12166,32 +12445,32 @@ var ts; } var parent = node.parent; switch (parent.kind) { - case 191: - case 126: + case 193: case 128: - case 127: - case 148: + case 130: + case 129: + case 150: return getContextualTypeForInitializerExpression(node); - case 159: - case 184: + case 161: + case 186: return getContextualTypeForReturnExpression(node); - case 153: - case 154: - return getContextualTypeForArgument(parent, node); + case 155: case 156: + return getContextualTypeForArgument(parent, node); + case 158: return getTypeFromTypeNode(parent.type); - case 165: + case 167: return getContextualTypeForBinaryOperand(node); - case 207: + case 217: return getContextualTypeForObjectLiteralElement(parent); - case 149: + case 151: return getContextualTypeForElementExpression(node); - case 166: + case 168: return getContextualTypeForConditionalOperand(node); - case 171: - ts.Debug.assert(parent.parent.kind === 167); + case 173: + ts.Debug.assert(parent.parent.kind === 169); return getContextualTypeForSubstitutionExpression(parent.parent, node); - case 157: + case 159: return getContextualType(parent); } return undefined; @@ -12206,13 +12485,13 @@ var ts; } } function isFunctionExpressionOrArrowFunction(node) { - return node.kind === 158 || node.kind === 159; + return node.kind === 160 || node.kind === 161; } function getContextualSignatureForFunctionLikeDeclaration(node) { return isFunctionExpressionOrArrowFunction(node) ? getContextualSignature(node) : undefined; } function getContextualSignature(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); var type = ts.isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node) : getContextualType(node); if (!type) { return undefined; @@ -12253,13 +12532,13 @@ var ts; } function isAssignmentTarget(node) { var parent = node.parent; - if (parent.kind === 165 && parent.operatorToken.kind === 52 && parent.left === node) { + if (parent.kind === 167 && parent.operatorToken.kind === 52 && parent.left === node) { return true; } - if (parent.kind === 207) { + if (parent.kind === 217) { return isAssignmentTarget(parent.parent); } - if (parent.kind === 149) { + if (parent.kind === 151) { return isAssignmentTarget(parent); } return false; @@ -12281,7 +12560,7 @@ var ts; var elementTypes = []; ts.forEach(elements, function (e) { var type = checkExpression(e, contextualMapper); - if (e.kind === 169) { + if (e.kind === 171) { elementTypes.push(getIndexTypeOfType(type, 1) || anyType); hasSpreadElement = true; } @@ -12298,7 +12577,7 @@ var ts; return createArrayType(getUnionType(elementTypes)); } function isNumericName(name) { - return name.kind === 124 ? isNumericComputedName(name) : isNumericLiteralName(name.text); + return name.kind === 126 ? isNumericComputedName(name) : isNumericLiteralName(name.text); } function isNumericComputedName(name) { return allConstituentTypesHaveKind(checkComputedPropertyName(name), 1 | 132); @@ -12328,18 +12607,18 @@ var ts; for (var i = 0; i < node.properties.length; i++) { var memberDecl = node.properties[i]; var member = memberDecl.symbol; - if (memberDecl.kind === 207 || - memberDecl.kind === 208 || + if (memberDecl.kind === 217 || + memberDecl.kind === 218 || ts.isObjectLiteralMethod(memberDecl)) { - if (memberDecl.kind === 207) { + if (memberDecl.kind === 217) { var type = checkPropertyAssignment(memberDecl, contextualMapper); } - else if (memberDecl.kind === 130) { + else if (memberDecl.kind === 132) { var type = checkObjectLiteralMethod(memberDecl, contextualMapper); } else { - ts.Debug.assert(memberDecl.kind === 208); - var type = memberDecl.name.kind === 124 ? unknownType : checkExpression(memberDecl.name, contextualMapper); + ts.Debug.assert(memberDecl.kind === 218); + var type = memberDecl.name.kind === 126 ? unknownType : checkExpression(memberDecl.name, contextualMapper); } typeFlags |= type.flags; var prop = createSymbol(4 | 67108864 | member.flags, member.name); @@ -12353,7 +12632,7 @@ var ts; member = prop; } else { - ts.Debug.assert(memberDecl.kind === 132 || memberDecl.kind === 133); + ts.Debug.assert(memberDecl.kind === 134 || memberDecl.kind === 135); checkAccessorDeclaration(memberDecl); } if (!ts.hasDynamicName(memberDecl)) { @@ -12386,7 +12665,7 @@ var ts; } } function getDeclarationKindFromSymbol(s) { - return s.valueDeclaration ? s.valueDeclaration.kind : 128; + return s.valueDeclaration ? s.valueDeclaration.kind : 130; } function getDeclarationFlagsFromSymbol(s) { return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0; @@ -12396,7 +12675,7 @@ var ts; if (!(flags & (32 | 64))) { return; } - var enclosingClassDeclaration = ts.getAncestor(node, 194); + var enclosingClassDeclaration = ts.getAncestor(node, 196); var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined; var declaringClass = getDeclaredTypeOfSymbol(prop.parent); if (flags & 32) { @@ -12443,7 +12722,7 @@ var ts; } getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & 32) { - if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 130) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { error(right, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); } else { @@ -12455,12 +12734,12 @@ var ts; return anyType; } function isValidPropertyAccess(node, propertyName) { - var left = node.kind === 151 ? node.expression : node.left; + var left = node.kind === 153 ? node.expression : node.left; var type = checkExpressionOrQualifiedName(left); if (type !== unknownType && type !== anyType) { var prop = getPropertyOfType(getWidenedType(type), propertyName); if (prop && prop.parent && prop.parent.flags & 32) { - if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 130) { + if (left.kind === 90 && getDeclarationKindFromSymbol(prop) !== 132) { return false; } else { @@ -12475,7 +12754,7 @@ var ts; function checkIndexedAccess(node) { if (!node.argumentExpression) { var sourceFile = getSourceFile(node); - if (node.parent.kind === 154 && node.parent.expression === node) { + if (node.parent.kind === 156 && 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); @@ -12571,7 +12850,7 @@ var ts; return true; } function resolveUntypedCall(node) { - if (node.kind === 155) { + if (node.kind === 157) { checkExpression(node.template); } else { @@ -12624,7 +12903,7 @@ var ts; } function getSpreadArgumentIndex(args) { for (var i = 0; i < args.length; i++) { - if (args[i].kind === 169) { + if (args[i].kind === 171) { return i; } } @@ -12634,11 +12913,11 @@ var ts; var adjustedArgCount; var typeArguments; var callIsIncomplete; - if (node.kind === 155) { + if (node.kind === 157) { var tagExpression = node; adjustedArgCount = args.length; typeArguments = undefined; - if (tagExpression.template.kind === 167) { + if (tagExpression.template.kind === 169) { var templateExpression = tagExpression.template; var lastSpan = ts.lastOrUndefined(templateExpression.templateSpans); ts.Debug.assert(lastSpan !== undefined); @@ -12653,7 +12932,7 @@ var ts; else { var callExpression = node; if (!callExpression.arguments) { - ts.Debug.assert(callExpression.kind === 154); + ts.Debug.assert(callExpression.kind === 156); return signature.minArgumentCount === 0; } adjustedArgCount = callExpression.arguments.hasTrailingComma ? args.length + 1 : args.length; @@ -12698,9 +12977,9 @@ var ts; var inferenceMapper = createInferenceMapper(context); for (var i = 0; i < args.length; i++) { var arg = args[i]; - if (arg.kind !== 170) { - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); - if (i === 0 && args[i].parent.kind === 155) { + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + if (i === 0 && args[i].parent.kind === 157) { var argType = globalTemplateStringsArrayType; } else { @@ -12714,7 +12993,7 @@ var ts; for (var i = 0; i < args.length; i++) { if (excludeArgument[i] === false) { var arg = args[i]; - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType); } } @@ -12747,9 +13026,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 !== 170) { - var paramType = getTypeAtPosition(signature, arg.kind === 169 ? -1 : i); - var argType = i === 0 && node.kind === 155 ? globalTemplateStringsArrayType : arg.kind === 8 && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined); + if (arg.kind !== 172) { + var paramType = getTypeAtPosition(signature, arg.kind === 171 ? -1 : i); + var argType = i === 0 && node.kind === 157 ? globalTemplateStringsArrayType : 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)) { return false; } @@ -12759,10 +13038,10 @@ var ts; } function getEffectiveCallArguments(node) { var args; - if (node.kind === 155) { + if (node.kind === 157) { var template = node.template; args = [template]; - if (template.kind === 167) { + if (template.kind === 169) { ts.forEach(template.templateSpans, function (span) { args.push(span.expression); }); @@ -12775,7 +13054,7 @@ var ts; } function getEffectiveTypeArguments(callExpression) { if (callExpression.expression.kind === 90) { - var containingClass = ts.getAncestor(callExpression, 194); + var containingClass = ts.getAncestor(callExpression, 196); var baseClassTypeNode = containingClass && ts.getClassBaseTypeNode(containingClass); return baseClassTypeNode && baseClassTypeNode.typeArguments; } @@ -12784,7 +13063,7 @@ var ts; } } function resolveCall(node, signatures, candidatesOutArray) { - var isTaggedTemplate = node.kind === 155; + var isTaggedTemplate = node.kind === 157; var typeArguments; if (!isTaggedTemplate) { typeArguments = getEffectiveTypeArguments(node); @@ -12990,13 +13269,13 @@ var ts; var links = getNodeLinks(node); if (!links.resolvedSignature || candidatesOutArray) { links.resolvedSignature = anySignature; - if (node.kind === 153) { + if (node.kind === 155) { links.resolvedSignature = resolveCallExpression(node, candidatesOutArray); } - else if (node.kind === 154) { + else if (node.kind === 156) { links.resolvedSignature = resolveNewExpression(node, candidatesOutArray); } - else if (node.kind === 155) { + else if (node.kind === 157) { links.resolvedSignature = resolveTaggedTemplateExpression(node, candidatesOutArray); } else { @@ -13011,12 +13290,12 @@ var ts; if (node.expression.kind === 90) { return voidType; } - if (node.kind === 154) { + if (node.kind === 156) { var declaration = signature.declaration; if (declaration && - declaration.kind !== 131 && - declaration.kind !== 135 && - declaration.kind !== 139) { + declaration.kind !== 133 && + declaration.kind !== 137 && + declaration.kind !== 141) { if (compilerOptions.noImplicitAny) { error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); } @@ -13066,7 +13345,7 @@ var ts; if (!func.body) { return unknownType; } - if (func.body.kind !== 172) { + if (func.body.kind !== 174) { var type = checkExpressionCached(func.body, contextualMapper); } else { @@ -13104,7 +13383,7 @@ var ts; }); } function bodyContainsSingleThrowStatement(body) { - return (body.statements.length === 1) && (body.statements[0].kind === 188); + return (body.statements.length === 1) && (body.statements[0].kind === 190); } function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) { if (!produceDiagnostics) { @@ -13113,7 +13392,7 @@ var ts; if (returnType === voidType || returnType === anyType) { return; } - if (ts.nodeIsMissing(func.body) || func.body.kind !== 172) { + if (ts.nodeIsMissing(func.body) || func.body.kind !== 174) { return; } var bodyBlock = func.body; @@ -13126,9 +13405,9 @@ 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 !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); - if (!hasGrammarError && node.kind === 158) { + if (!hasGrammarError && node.kind === 160) { checkGrammarFunctionName(node.name) || checkGrammarForGenerator(node); } if (contextualMapper === identityMapper && isContextSensitive(node)) { @@ -13156,19 +13435,19 @@ var ts; checkSignatureDeclaration(node); } } - if (produceDiagnostics && node.kind !== 130 && node.kind !== 129) { + if (produceDiagnostics && node.kind !== 132 && node.kind !== 131) { checkCollisionWithCapturedSuperVariable(node, node.name); checkCollisionWithCapturedThisVariable(node, node.name); } return type; } function checkFunctionExpressionOrObjectLiteralMethodBody(node) { - ts.Debug.assert(node.kind !== 130 || ts.isObjectLiteralMethod(node)); + ts.Debug.assert(node.kind !== 132 || ts.isObjectLiteralMethod(node)); if (node.type) { checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, getTypeFromTypeNode(node.type)); } if (node.body) { - if (node.body.kind === 172) { + if (node.body.kind === 174) { checkSourceElement(node.body); } else { @@ -13197,12 +13476,12 @@ var ts; case 64: var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & 3) !== 0; - case 151: + case 153: var symbol = findSymbol(n); return !symbol || symbol === unknownSymbol || (symbol.flags & ~8) !== 0; - case 152: + case 154: return true; - case 157: + case 159: return isReferenceOrErrorExpression(n.expression); default: return false; @@ -13211,10 +13490,10 @@ var ts; function isConstVariableReference(n) { switch (n.kind) { case 64: - case 151: + case 153: var symbol = findSymbol(n); return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 4096) !== 0; - case 152: + case 154: var index = n.argumentExpression; var symbol = findSymbol(n.expression); if (symbol && index && index.kind === 8) { @@ -13223,7 +13502,7 @@ var ts; return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 4096) !== 0; } return false; - case 157: + case 159: return isConstVariableReference(n.expression); default: return false; @@ -13346,7 +13625,7 @@ var ts; var properties = node.properties; for (var i = 0; i < properties.length; i++) { var p = properties[i]; - if (p.kind === 207 || p.kind === 208) { + if (p.kind === 217 || p.kind === 218) { var name = p.name; var type = sourceType.flags & 1 ? sourceType : getTypeOfPropertyOfType(sourceType, name.text) || isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, 1) || @@ -13372,8 +13651,8 @@ var ts; var elements = node.elements; for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 170) { - if (e.kind !== 169) { + if (e.kind !== 172) { + if (e.kind !== 171) { var propName = "" + i; var type = sourceType.flags & 1 ? sourceType : isTupleLikeType(sourceType) ? getTypeOfPropertyOfType(sourceType, propName) : getIndexTypeOfType(sourceType, 1); if (type) { @@ -13396,14 +13675,14 @@ var ts; return sourceType; } function checkDestructuringAssignment(target, sourceType, contextualMapper) { - if (target.kind === 165 && target.operatorToken.kind === 52) { + if (target.kind === 167 && target.operatorToken.kind === 52) { checkBinaryExpression(target, contextualMapper); target = target.left; } - if (target.kind === 150) { + if (target.kind === 152) { return checkObjectLiteralAssignment(target, sourceType, contextualMapper); } - if (target.kind === 149) { + if (target.kind === 151) { return checkArrayLiteralAssignment(target, sourceType, contextualMapper); } return checkReferenceAssignment(target, sourceType, contextualMapper); @@ -13420,7 +13699,7 @@ var ts; checkGrammarEvalOrArgumentsInStrictMode(node, node.left); } var operator = node.operatorToken.kind; - if (operator === 52 && (node.left.kind === 150 || node.left.kind === 149)) { + if (operator === 52 && (node.left.kind === 152 || node.left.kind === 151)) { return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); } var leftType = checkExpression(node.left, contextualMapper); @@ -13592,14 +13871,14 @@ var ts; return links.resolvedType; } function checkPropertyAssignment(node, contextualMapper) { - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } return checkExpression(node.initializer, contextualMapper); } function checkObjectLiteralMethod(node, contextualMapper) { checkGrammarMethod(node); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); @@ -13625,7 +13904,7 @@ var ts; } function checkExpressionOrQualifiedName(node, contextualMapper) { var type; - if (node.kind == 123) { + if (node.kind == 125) { type = checkQualifiedName(node); } else { @@ -13633,9 +13912,9 @@ var ts; type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper); } if (isConstEnumObjectType(type)) { - var ok = (node.parent.kind === 151 && node.parent.expression === node) || - (node.parent.kind === 152 && node.parent.expression === node) || - ((node.kind === 64 || node.kind === 123) && isInRightSideOfImportOrExportAssignment(node)); + var ok = (node.parent.kind === 153 && node.parent.expression === node) || + (node.parent.kind === 154 && node.parent.expression === node) || + ((node.kind === 64 || node.kind === 125) && 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); } @@ -13661,52 +13940,52 @@ var ts; return booleanType; case 7: return checkNumericLiteral(node); - case 167: + case 169: return checkTemplateExpression(node); case 8: case 10: return stringType; case 9: return globalRegExpType; - case 149: - return checkArrayLiteral(node, contextualMapper); - case 150: - return checkObjectLiteral(node, contextualMapper); case 151: - return checkPropertyAccessExpression(node); + return checkArrayLiteral(node, contextualMapper); case 152: - return checkIndexedAccess(node); + return checkObjectLiteral(node, contextualMapper); case 153: + return checkPropertyAccessExpression(node); case 154: - return checkCallExpression(node); + return checkIndexedAccess(node); case 155: - return checkTaggedTemplateExpression(node); case 156: - return checkTypeAssertion(node); + return checkCallExpression(node); case 157: - return checkExpression(node.expression, contextualMapper); + return checkTaggedTemplateExpression(node); case 158: + return checkTypeAssertion(node); case 159: - return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); - case 161: - return checkTypeOfExpression(node); + return checkExpression(node.expression, contextualMapper); case 160: - return checkDeleteExpression(node); - case 162: - return checkVoidExpression(node); + case 161: + return checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper); case 163: - return checkPrefixUnaryExpression(node); + return checkTypeOfExpression(node); + case 162: + return checkDeleteExpression(node); case 164: - return checkPostfixUnaryExpression(node); + return checkVoidExpression(node); case 165: - return checkBinaryExpression(node, contextualMapper); + return checkPrefixUnaryExpression(node); case 166: - return checkConditionalExpression(node, contextualMapper); - case 169: - return checkSpreadElementExpression(node, contextualMapper); - case 170: - return undefinedType; + return checkPostfixUnaryExpression(node); + case 167: + return checkBinaryExpression(node, contextualMapper); case 168: + return checkConditionalExpression(node, contextualMapper); + case 171: + return checkSpreadElementExpression(node, contextualMapper); + case 172: + return undefinedType; + case 170: checkYieldExpression(node); return unknownType; } @@ -13728,7 +14007,7 @@ var ts; var func = ts.getContainingFunction(node); if (node.flags & 112) { func = ts.getContainingFunction(node); - if (!(func.kind === 131 && ts.nodeIsPresent(func.body))) { + if (!(func.kind === 133 && ts.nodeIsPresent(func.body))) { error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); } } @@ -13742,12 +14021,12 @@ var ts; } } function checkSignatureDeclaration(node) { - if (node.kind === 136) { + if (node.kind === 138) { checkGrammarIndexSignature(node); } - else if (node.kind === 138 || node.kind === 193 || node.kind === 139 || - node.kind === 134 || node.kind === 131 || - node.kind === 135) { + else if (node.kind === 140 || node.kind === 195 || node.kind === 141 || + node.kind === 136 || node.kind === 133 || + node.kind === 137) { checkGrammarFunctionLikeDeclaration(node); } checkTypeParameters(node.typeParameters); @@ -13759,10 +14038,10 @@ var ts; checkCollisionWithArgumentsInGeneratedCode(node); if (compilerOptions.noImplicitAny && !node.type) { switch (node.kind) { - case 135: + case 137: error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; - case 134: + case 136: error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); break; } @@ -13771,7 +14050,7 @@ var ts; checkSpecializedSignatureDeclaration(node); } function checkTypeForDuplicateIndexSignatures(node) { - if (node.kind === 195) { + if (node.kind === 197) { var nodeSymbol = getSymbolOfNode(node); if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { return; @@ -13785,7 +14064,7 @@ var ts; var declaration = indexSymbol.declarations[i]; if (declaration.parameters.length === 1 && declaration.parameters[0].type) { switch (declaration.parameters[0].type.kind) { - case 119: + case 121: if (!seenStringIndexer) { seenStringIndexer = true; } @@ -13793,7 +14072,7 @@ var ts; error(declaration, ts.Diagnostics.Duplicate_string_index_signature); } break; - case 117: + case 119: if (!seenNumericIndexer) { seenNumericIndexer = true; } @@ -13830,17 +14109,17 @@ var ts; return; } function isSuperCallExpression(n) { - return n.kind === 153 && n.expression.kind === 90; + return n.kind === 155 && n.expression.kind === 90; } function containsSuperCall(n) { if (isSuperCallExpression(n)) { return true; } switch (n.kind) { - case 158: - case 193: - case 159: - case 150: return false; + case 160: + case 195: + case 161: + case 152: return false; default: return ts.forEachChild(n, containsSuperCall); } } @@ -13848,12 +14127,12 @@ var ts; if (n.kind === 92) { error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location); } - else if (n.kind !== 158 && n.kind !== 193) { + else if (n.kind !== 160 && n.kind !== 195) { ts.forEachChild(n, markThisReferencesAsErrors); } } function isInstancePropertyWithInitializer(n) { - return n.kind === 128 && + return n.kind === 130 && !(n.flags & 128) && !!n.initializer; } @@ -13863,7 +14142,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 !== 175 || !isSuperCallExpression(statements[0].expression)) { + if (!statements.length || statements[0].kind !== 177 || !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 { @@ -13879,13 +14158,13 @@ var ts; function checkAccessorDeclaration(node) { if (produceDiagnostics) { checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); - if (node.kind === 132) { + if (node.kind === 134) { 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 === 132 ? 133 : 132; + var otherKind = node.kind === 134 ? 135 : 134; var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind); if (otherAccessor) { if (((node.flags & 112) !== (otherAccessor.flags & 112))) { @@ -13959,9 +14238,9 @@ var ts; return; } var signaturesToCheck; - if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 195) { - ts.Debug.assert(signatureDeclarationNode.kind === 134 || signatureDeclarationNode.kind === 135); - var signatureKind = signatureDeclarationNode.kind === 134 ? 0 : 1; + if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === 197) { + ts.Debug.assert(signatureDeclarationNode.kind === 136 || signatureDeclarationNode.kind === 137); + var signatureKind = signatureDeclarationNode.kind === 136 ? 0 : 1; var containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent); var containingType = getDeclaredTypeOfSymbol(containingSymbol); signaturesToCheck = getSignaturesOfType(containingType, signatureKind); @@ -13979,7 +14258,7 @@ var ts; } function getEffectiveDeclarationFlags(n, flagsToCheck) { var flags = ts.getCombinedNodeFlags(n); - if (n.parent.kind !== 195 && ts.isInAmbientContext(n)) { + if (n.parent.kind !== 197 && ts.isInAmbientContext(n)) { if (!(flags & 2)) { flags |= 1; } @@ -14052,7 +14331,7 @@ var ts; if (subsequentNode.kind === node.kind) { var errorNode = subsequentNode.name || subsequentNode; if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) { - ts.Debug.assert(node.kind === 130 || node.kind === 129); + ts.Debug.assert(node.kind === 132 || node.kind === 131); 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, diagnostic); @@ -14078,11 +14357,11 @@ var ts; for (var i = 0; i < declarations.length; i++) { var node = declarations[i]; var inAmbientContext = ts.isInAmbientContext(node); - var inAmbientContextOrInterface = node.parent.kind === 195 || node.parent.kind === 141 || inAmbientContext; + var inAmbientContextOrInterface = node.parent.kind === 197 || node.parent.kind === 143 || inAmbientContext; if (inAmbientContextOrInterface) { previousDeclaration = undefined; } - if (node.kind === 193 || node.kind === 130 || node.kind === 129 || node.kind === 131) { + if (node.kind === 195 || node.kind === 132 || node.kind === 131 || node.kind === 133) { var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); someNodeFlags |= currentNodeFlags; allNodeFlags &= currentNodeFlags; @@ -14179,14 +14458,14 @@ var ts; } function getDeclarationSpaces(d) { switch (d.kind) { - case 195: - return 2097152; - case 198: - return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; - case 194: case 197: - return 2097152 | 1048576; + return 2097152; case 200: + return d.name.kind === 8 || ts.getModuleInstanceState(d) !== 0 ? 4194304 | 1048576 : 4194304; + case 196: + case 199: + return 2097152 | 1048576; + case 202: var result = 0; var target = resolveImport(getSymbolOfNode(d)); ts.forEach(target.declarations, function (d) { result |= getDeclarationSpaces(d); }); @@ -14209,7 +14488,7 @@ var ts; } function checkFunctionLikeDeclaration(node) { checkSignatureDeclaration(node); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); } if (!ts.hasDynamicName(node)) { @@ -14234,11 +14513,11 @@ var ts; } } function checkBlock(node) { - if (node.kind === 172) { + if (node.kind === 174) { checkGrammarStatementInAmbientContext(node); } ts.forEach(node.statements, checkSourceElement); - if (ts.isFunctionBlock(node) || node.kind === 199) { + if (ts.isFunctionBlock(node) || node.kind === 201) { checkFunctionExpressionBodies(node); } } @@ -14256,19 +14535,19 @@ var ts; if (!(identifier && identifier.text === name)) { return false; } - if (node.kind === 128 || - node.kind === 127 || - node.kind === 130 || + if (node.kind === 130 || node.kind === 129 || node.kind === 132 || - node.kind === 133) { + node.kind === 131 || + node.kind === 134 || + node.kind === 135) { return false; } if (ts.isInAmbientContext(node)) { return false; } var root = getRootDeclaration(node); - if (root.kind === 126 && ts.nodeIsMissing(root.parent.body)) { + if (root.kind === 128 && ts.nodeIsMissing(root.parent.body)) { return false; } return true; @@ -14298,7 +14577,7 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "_super")) { return; } - var enclosingClass = ts.getAncestor(node, 194); + var enclosingClass = ts.getAncestor(node, 196); if (!enclosingClass || ts.isInAmbientContext(enclosingClass)) { return; } @@ -14316,11 +14595,11 @@ var ts; if (!needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { return; } - if (node.kind === 198 && ts.getModuleInstanceState(node) !== 1) { + if (node.kind === 200 && ts.getModuleInstanceState(node) !== 1) { return; } var parent = getDeclarationContainer(node); - if (parent.kind === 210 && ts.isExternalModule(parent)) { + if (parent.kind === 220 && ts.isExternalModule(parent)) { error(name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); } } @@ -14333,13 +14612,13 @@ var ts; localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2) { if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 6144) { - var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 192); - var container = varDeclList.parent.kind === 173 && + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 194); + var container = varDeclList.parent.kind === 175 && varDeclList.parent.parent; var namesShareScope = container && - (container.kind === 172 && ts.isAnyFunction(container.parent) || - (container.kind === 199 && container.kind === 198) || - container.kind === 210); + (container.kind === 174 && ts.isAnyFunction(container.parent) || + (container.kind === 201 && container.kind === 200) || + container.kind === 220); if (!namesShareScope) { var name = symbolToString(localDeclarationSymbol); error(ts.getErrorSpanForNode(node), ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name); @@ -14350,13 +14629,13 @@ var ts; } } function isParameterDeclaration(node) { - while (node.kind === 148) { + while (node.kind === 150) { node = node.parent.parent; } - return node.kind === 126; + return node.kind === 128; } function checkParameterInitializer(node) { - if (getRootDeclaration(node).kind === 126) { + if (getRootDeclaration(node).kind === 128) { var func = ts.getContainingFunction(node); visit(node.initializer); } @@ -14364,7 +14643,7 @@ var ts; if (n.kind === 64) { var referencedSymbol = getNodeLinks(n).resolvedSymbol; if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, 107455) === referencedSymbol) { - if (referencedSymbol.valueDeclaration.kind === 126) { + if (referencedSymbol.valueDeclaration.kind === 128) { if (referencedSymbol.valueDeclaration === node) { error(n, ts.Diagnostics.Parameter_0_cannot_be_referenced_in_its_initializer, ts.declarationNameToString(node.name)); return; @@ -14383,7 +14662,7 @@ var ts; } function checkVariableLikeDeclaration(node) { checkSourceElement(node.type); - if (node.name.kind === 124) { + if (node.name.kind === 126) { checkComputedPropertyName(node.name); if (node.initializer) { checkExpressionCached(node.initializer); @@ -14392,7 +14671,7 @@ var ts; if (ts.isBindingPattern(node.name)) { ts.forEach(node.name.elements, checkSourceElement); } - if (node.initializer && getRootDeclaration(node).kind === 126 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + if (node.initializer && getRootDeclaration(node).kind === 128 && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); return; } @@ -14420,9 +14699,9 @@ var ts; checkTypeAssignableTo(checkExpressionCached(node.initializer), declarationType, node, undefined); } } - if (node.kind !== 128 && node.kind !== 127) { + if (node.kind !== 130 && node.kind !== 129) { checkExportsOnMergedDeclarations(node); - if (node.kind === 191 || node.kind === 148) { + if (node.kind === 193 || node.kind === 150) { checkVarDeclaredNamesNotShadowed(node); } checkCollisionWithCapturedSuperVariable(node, node.name); @@ -14451,7 +14730,7 @@ var ts; } function inBlockOrObjectLiteralExpression(node) { while (node) { - if (node.kind === 172 || node.kind === 150) { + if (node.kind === 174 || node.kind === 152) { return true; } node = node.parent; @@ -14479,12 +14758,12 @@ var ts; } function checkForStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { - if (node.initializer && node.initializer.kind == 192) { + if (node.initializer && node.initializer.kind == 194) { checkGrammarVariableDeclarationList(node.initializer); } } if (node.initializer) { - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { ts.forEach(node.initializer.declarations, checkVariableDeclaration); } else { @@ -14502,7 +14781,7 @@ var ts; } function checkForInStatement(node) { checkGrammarForInOrForOfStatement(node); - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; @@ -14529,7 +14808,7 @@ var ts; checkGrammarStatementInAmbientContext(node) || checkGrammarBreakOrContinueStatement(node); } function isGetAccessorWithAnnotatatedSetAccessor(node) { - return !!(node.kind === 132 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 133))); + return !!(node.kind === 134 && getSetAccessorTypeAnnotationNode(ts.getDeclarationOfKind(node.symbol, 135))); } function checkReturnStatement(node) { if (!checkGrammarStatementInAmbientContext(node)) { @@ -14543,11 +14822,11 @@ var ts; if (func) { var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); var exprType = checkExpressionCached(node.expression); - if (func.kind === 133) { + if (func.kind === 135) { error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value); } else { - if (func.kind === 131) { + if (func.kind === 133) { if (!isTypeAssignableTo(exprType, returnType)) { error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); } @@ -14574,7 +14853,7 @@ var ts; var hasDuplicateDefaultClause = false; var expressionType = checkExpression(node.expression); ts.forEach(node.clauses, function (clause) { - if (clause.kind === 204 && !hasDuplicateDefaultClause) { + if (clause.kind === 214 && !hasDuplicateDefaultClause) { if (firstDefaultClause === undefined) { firstDefaultClause = clause; } @@ -14586,7 +14865,7 @@ var ts; hasDuplicateDefaultClause = true; } } - if (produceDiagnostics && clause.kind === 203) { + if (produceDiagnostics && clause.kind === 213) { var caseClause = clause; var caseType = checkExpression(caseClause.expression); if (!isTypeAssignableTo(expressionType, caseType)) { @@ -14603,7 +14882,7 @@ var ts; if (ts.isAnyFunction(current)) { break; } - if (current.kind === 187 && current.label.text === node.label.text) { + if (current.kind === 189 && 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; @@ -14650,7 +14929,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 === 194) { + if (type.flags & 1024 && type.symbol.valueDeclaration.kind === 196) { var classDeclaration = type.symbol.valueDeclaration; for (var i = 0; i < classDeclaration.members.length; i++) { var member = classDeclaration.members[i]; @@ -14681,7 +14960,7 @@ var ts; return; } var errorNode; - if (prop.valueDeclaration.name.kind === 124 || prop.parent === containingType.symbol) { + if (prop.valueDeclaration.name.kind === 126 || prop.parent === containingType.symbol) { errorNode = prop.valueDeclaration; } else if (indexDeclaration) { @@ -14822,7 +15101,7 @@ var ts; } } function isAccessor(kind) { - return kind === 132 || kind === 133; + return kind === 134 || kind === 135; } function areTypeParametersIdentical(list1, list2) { if (!list1 && !list2) { @@ -14887,7 +15166,7 @@ var ts; checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); checkExportsOnMergedDeclarations(node); var symbol = getSymbolOfNode(node); - var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 195); + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 197); 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); @@ -14923,7 +15202,7 @@ var ts; var ambient = ts.isInAmbientContext(node); var enumIsConst = ts.isConst(node); ts.forEach(node.members, function (member) { - if (member.name.kind !== 124 && isNumericLiteralName(member.name.text)) { + if (member.name.kind !== 126 && isNumericLiteralName(member.name.text)) { error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); } var initializer = member.initializer; @@ -14959,7 +15238,7 @@ var ts; return evalConstant(initializer); function evalConstant(e) { switch (e.kind) { - case 163: + case 165: var value = evalConstant(e.operand); if (value === undefined) { return undefined; @@ -14970,7 +15249,7 @@ var ts; case 47: return enumIsConst ? ~value : undefined; } return undefined; - case 165: + case 167: if (!enumIsConst) { return undefined; } @@ -14998,11 +15277,11 @@ var ts; return undefined; case 7: return +e.text; - case 157: + case 159: return enumIsConst ? evalConstant(e.expression) : undefined; case 64: - case 152: - case 151: + case 154: + case 153: if (!enumIsConst) { return undefined; } @@ -15015,7 +15294,7 @@ var ts; propertyName = e.text; } else { - if (e.kind === 152) { + if (e.kind === 154) { if (e.argumentExpression === undefined || e.argumentExpression.kind !== 8) { return undefined; @@ -15073,7 +15352,7 @@ var ts; } var seenEnumMissingInitialInitializer = false; ts.forEach(enumSymbol.declarations, function (declaration) { - if (declaration.kind !== 197) { + if (declaration.kind !== 199) { return false; } var enumDeclaration = declaration; @@ -15096,7 +15375,7 @@ var ts; var declarations = symbol.declarations; for (var i = 0; i < declarations.length; i++) { var declaration = declarations[i]; - if ((declaration.kind === 194 || (declaration.kind === 193 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { + if ((declaration.kind === 196 || (declaration.kind === 195 && ts.nodeIsPresent(declaration.body))) && !ts.isInAmbientContext(declaration)) { return declaration; } } @@ -15108,16 +15387,13 @@ var ts; if (!ts.isInAmbientContext(node) && node.name.kind === 8) { grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); } - else if (node.name.kind === 64 && node.body.kind === 199) { + else if (node.name.kind === 64 && node.body.kind === 201) { var statements = node.body.statements; for (var i = 0, n = statements.length; i < n; i++) { var statement = statements[i]; - if (statement.kind === 201) { + if (statement.kind === 208) { grammarErrorOnNode(statement, ts.Diagnostics.An_export_assignment_cannot_be_used_in_an_internal_module); } - else if (ts.isExternalModuleImportDeclaration(statement)) { - grammarErrorOnNode(ts.getExternalModuleImportDeclarationExpression(statement), ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); - } } } } @@ -15148,19 +15424,73 @@ var ts; checkSourceElement(node.body); } function getFirstIdentifier(node) { - while (node.kind === 123) { + while (node.kind === 125) { node = node.left; } return node; } - function checkImportDeclaration(node) { - checkGrammarModifiers(node); + function checkExternalImportOrExportDeclaration(node) { + var moduleName = ts.getExternalModuleName(node); + if (ts.getFullWidth(moduleName) !== 0 && moduleName.kind !== 8) { + error(moduleName, ts.Diagnostics.String_literal_expected); + return false; + } + var inAmbientExternalModule = node.parent.kind === 201 && node.parent.parent.name.kind === 8; + if (node.parent.kind !== 220 && !inAmbientExternalModule) { + error(moduleName, node.kind === 209 ? ts.Diagnostics.Export_declarations_are_not_permitted_in_an_internal_module : ts.Diagnostics.Import_declarations_in_an_internal_module_cannot_reference_an_external_module); + return false; + } + if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) { + error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); + return false; + } + return true; + } + function checkImportSymbol(node) { + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); + if (target !== unknownSymbol) { + var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | + (symbol.flags & 793056 ? 793056 : 0) | + (symbol.flags & 1536 ? 1536 : 0); + if (target.flags & excludedMeanings) { + var message = node.kind === 211 ? 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)); + } + } + } + function checkImportBinding(node) { checkCollisionWithCapturedThisVariable(node, node.name); checkCollisionWithRequireExportsInGeneratedCode(node, node.name); - var symbol = getSymbolOfNode(node); - var target; - if (ts.isInternalModuleImportDeclaration(node)) { - target = resolveImport(symbol); + checkImportSymbol(node); + } + function checkImportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); + } + if (checkExternalImportOrExportDeclaration(node)) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + checkImportBinding(importClause); + } + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 205) { + checkImportBinding(importClause.namedBindings); + } + else { + ts.forEach(importClause.namedBindings.elements, checkImportBinding); + } + } + } + } + } + function checkImportEqualsDeclaration(node) { + checkGrammarModifiers(node); + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + checkImportBinding(node); + var symbol = getSymbolOfNode(node); + var target = resolveImport(symbol); if (target !== unknownSymbol) { if (target.flags & 107455) { var moduleName = getFirstIdentifier(node.moduleReference); @@ -15177,33 +15507,18 @@ var ts; } } else { - if (node.parent.kind === 210) { - target = resolveImport(symbol); - } - else if (node.parent.kind === 199 && node.parent.parent.name.kind === 8) { - if (ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - if (isExternalModuleNameRelative(ts.getExternalModuleImportDeclarationExpression(node).text)) { - error(node, ts.Diagnostics.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name); - target = unknownSymbol; - } - else { - target = resolveImport(symbol); - } - } - else { - target = unknownSymbol; - } - } - else { - target = unknownSymbol; + if (checkExternalImportOrExportDeclaration(node)) { + checkImportBinding(node); } } - if (target !== unknownSymbol) { - var excludedMeanings = (symbol.flags & 107455 ? 107455 : 0) | - (symbol.flags & 793056 ? 793056 : 0) | - (symbol.flags & 1536 ? 1536 : 0); - if (target.flags & excludedMeanings) { - error(node, ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0, symbolToString(symbol)); + } + function checkExportDeclaration(node) { + if (!checkGrammarModifiers(node) && (node.flags & 243)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); + } + if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { + if (node.exportClause) { + ts.forEach(node.exportClause.elements, checkImportSymbol); } } } @@ -15212,7 +15527,7 @@ var ts; grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); } var container = node.parent; - if (container.kind !== 210) { + if (container.kind !== 220) { container = container.parent; } checkTypeOfExportAssignmentSymbol(getSymbolOfNode(container)); @@ -15221,158 +15536,160 @@ var ts; if (!node) return; switch (node.kind) { - case 125: - return checkTypeParameter(node); - case 126: - return checkParameter(node); - case 128: case 127: - return checkPropertyDeclaration(node); - case 138: - case 139: - case 134: - case 135: - return checkSignatureDeclaration(node); - case 136: - return checkSignatureDeclaration(node); + return checkTypeParameter(node); + case 128: + return checkParameter(node); case 130: case 129: - return checkMethodDeclaration(node); - case 131: - return checkConstructorDeclaration(node); - case 132: - case 133: - return checkAccessorDeclaration(node); - case 137: - return checkTypeReference(node); + return checkPropertyDeclaration(node); case 140: - return checkTypeQuery(node); case 141: - return checkTypeLiteral(node); + case 136: + case 137: + return checkSignatureDeclaration(node); + case 138: + return checkSignatureDeclaration(node); + case 132: + case 131: + return checkMethodDeclaration(node); + case 133: + return checkConstructorDeclaration(node); + case 134: + case 135: + return checkAccessorDeclaration(node); + case 139: + return checkTypeReference(node); case 142: - return checkArrayType(node); + return checkTypeQuery(node); case 143: - return checkTupleType(node); + return checkTypeLiteral(node); case 144: - return checkUnionType(node); + return checkArrayType(node); case 145: + return checkTupleType(node); + case 146: + return checkUnionType(node); + case 147: return checkSourceElement(node.type); - case 193: - return checkFunctionDeclaration(node); - case 172: - case 199: - return checkBlock(node); - case 173: - return checkVariableStatement(node); - case 175: - return checkExpressionStatement(node); - case 176: - return checkIfStatement(node); - case 177: - return checkDoStatement(node); - case 178: - return checkWhileStatement(node); - case 179: - return checkForStatement(node); - case 180: - return checkForInStatement(node); - case 181: - return checkForOfStatement(node); - case 182: - case 183: - return checkBreakOrContinueStatement(node); - case 184: - return checkReturnStatement(node); - case 185: - return checkWithStatement(node); - case 186: - return checkSwitchStatement(node); - case 187: - return checkLabeledStatement(node); - case 188: - return checkThrowStatement(node); - case 189: - return checkTryStatement(node); - case 191: - return checkVariableDeclaration(node); - case 148: - return checkBindingElement(node); - case 194: - return checkClassDeclaration(node); case 195: - return checkInterfaceDeclaration(node); - case 196: - return checkTypeAliasDeclaration(node); - case 197: - return checkEnumDeclaration(node); - case 198: - return checkModuleDeclaration(node); - case 200: - return checkImportDeclaration(node); - case 201: - return checkExportAssignment(node); + return checkFunctionDeclaration(node); case 174: + case 201: + return checkBlock(node); + case 175: + return checkVariableStatement(node); + case 177: + return checkExpressionStatement(node); + case 178: + return checkIfStatement(node); + case 179: + return checkDoStatement(node); + case 180: + return checkWhileStatement(node); + case 181: + return checkForStatement(node); + case 182: + return checkForInStatement(node); + case 183: + return checkForOfStatement(node); + case 184: + case 185: + return checkBreakOrContinueStatement(node); + case 186: + return checkReturnStatement(node); + case 187: + return checkWithStatement(node); + case 188: + return checkSwitchStatement(node); + case 189: + return checkLabeledStatement(node); + case 190: + return checkThrowStatement(node); + case 191: + return checkTryStatement(node); + case 193: + return checkVariableDeclaration(node); + case 150: + return checkBindingElement(node); + case 196: + return checkClassDeclaration(node); + case 197: + return checkInterfaceDeclaration(node); + case 198: + return checkTypeAliasDeclaration(node); + case 199: + return checkEnumDeclaration(node); + case 200: + return checkModuleDeclaration(node); + case 203: + return checkImportDeclaration(node); + case 202: + return checkImportEqualsDeclaration(node); + case 209: + return checkExportDeclaration(node); + case 208: + return checkExportAssignment(node); + case 176: checkGrammarStatementInAmbientContext(node); return; - case 190: + case 192: checkGrammarStatementInAmbientContext(node); return; } } function checkFunctionExpressionBodies(node) { switch (node.kind) { - case 158: - case 159: + case 160: + case 161: ts.forEach(node.parameters, checkFunctionExpressionBodies); checkFunctionExpressionOrObjectLiteralMethodBody(node); break; - case 130: - case 129: + case 132: + case 131: ts.forEach(node.parameters, checkFunctionExpressionBodies); if (ts.isObjectLiteralMethod(node)) { checkFunctionExpressionOrObjectLiteralMethodBody(node); } break; - case 131: - case 132: case 133: - case 193: + case 134: + case 135: + case 195: ts.forEach(node.parameters, checkFunctionExpressionBodies); break; - case 185: + case 187: checkFunctionExpressionBodies(node.expression); break; - case 126: case 128: - case 127: - case 146: - case 147: + case 130: + case 129: case 148: case 149: case 150: - case 207: case 151: case 152: + case 217: case 153: case 154: case 155: - case 167: - case 171: case 156: case 157: - case 161: - case 162: - case 160: + case 169: + case 173: + case 158: + case 159: case 163: case 164: + case 162: case 165: case 166: - case 169: - case 172: - case 199: - case 173: + case 167: + case 168: + case 171: + case 174: + case 201: case 175: - case 176: case 177: case 178: case 179: @@ -15381,19 +15698,21 @@ var ts; case 182: case 183: case 184: + case 185: case 186: - case 203: - case 204: - case 187: case 188: + case 213: + case 214: case 189: - case 206: + case 190: case 191: - case 192: + case 216: + case 193: case 194: - case 197: - case 209: - case 210: + case 196: + case 199: + case 219: + case 220: ts.forEachChild(node, checkFunctionExpressionBodies); break; } @@ -15415,7 +15734,7 @@ var ts; var symbol = getExportAssignmentSymbol(node.symbol); if (symbol && symbol.flags & 8388608) { getSymbolLinks(symbol).referenced = true; - markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 200)); + markLinkedImportsAsReferenced(ts.getDeclarationOfKind(symbol, 202)); } } if (potentialThisCollisions.length) { @@ -15449,7 +15768,7 @@ var ts; function isInsideWithStatementBody(node) { if (node) { while (node.parent) { - if (node.parent.kind === 185 && node.parent.statement === node) { + if (node.parent.kind === 187 && node.parent.statement === node) { return true; } node = node.parent; @@ -15485,27 +15804,27 @@ var ts; copySymbols(location.locals, meaning); } switch (location.kind) { - case 210: + case 220: if (!ts.isExternalModule(location)) break; - case 198: + case 200: copySymbols(getSymbolOfNode(location).exports, meaning & 8914931); break; - case 197: + case 199: copySymbols(getSymbolOfNode(location).exports, meaning & 8); break; - case 194: - case 195: + case 196: + case 197: if (!(memberFlags & 128)) { copySymbols(getSymbolOfNode(location).members, meaning & 793056); } break; - case 158: + case 160: if (location.name) { copySymbol(location.symbol, meaning); } break; - case 206: + case 216: if (location.name.text) { copySymbol(location.symbol, meaning); } @@ -15524,109 +15843,109 @@ var ts; } function isTypeDeclaration(node) { switch (node.kind) { - case 125: - case 194: - case 195: + case 127: case 196: case 197: + case 198: + case 199: return true; } } function isTypeReferenceIdentifier(entityName) { var node = entityName; - while (node.parent && node.parent.kind === 123) + while (node.parent && node.parent.kind === 125) node = node.parent; - return node.parent && node.parent.kind === 137; + return node.parent && node.parent.kind === 139; } function isTypeNode(node) { - if (137 <= node.kind && node.kind <= 145) { + if (139 <= node.kind && node.kind <= 147) { return true; } switch (node.kind) { - case 110: - case 117: + case 112: case 119: - case 111: - case 120: + case 121: + case 113: + case 122: return true; case 98: - return node.parent.kind !== 162; + return node.parent.kind !== 164; case 8: - return node.parent.kind === 126; + return node.parent.kind === 128; case 64: - if (node.parent.kind === 123 && node.parent.right === node) { + if (node.parent.kind === 125 && node.parent.right === node) { node = node.parent; } - case 123: - ts.Debug.assert(node.kind === 64 || node.kind === 123, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); + case 125: + ts.Debug.assert(node.kind === 64 || node.kind === 125, "'node' was expected to be a qualified name or identifier in 'isTypeNode'."); var parent = node.parent; - if (parent.kind === 140) { + if (parent.kind === 142) { return false; } - if (137 <= parent.kind && parent.kind <= 145) { + if (139 <= parent.kind && parent.kind <= 147) { return true; } switch (parent.kind) { - case 125: - return node === parent.constraint; - case 128: case 127: - case 126: - case 191: - return node === parent.type; - case 193: - case 158: - case 159: - case 131: + return node === parent.constraint; case 130: case 129: - case 132: - case 133: + case 128: + case 193: return node === parent.type; + case 195: + case 160: + case 161: + case 133: + case 132: + case 131: case 134: case 135: + return node === parent.type; case 136: + case 137: + case 138: return node === parent.type; - case 156: + case 158: return node === parent.type; - case 153: - case 154: - return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; case 155: + case 156: + return parent.typeArguments && ts.indexOf(parent.typeArguments, node) >= 0; + case 157: return false; } } return false; } - function getLeftSideOfImportOrExportAssignment(nodeOnRightSide) { - while (nodeOnRightSide.parent.kind === 123) { + function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { + while (nodeOnRightSide.parent.kind === 125) { nodeOnRightSide = nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 200) { + if (nodeOnRightSide.parent.kind === 202) { return nodeOnRightSide.parent.moduleReference === nodeOnRightSide && nodeOnRightSide.parent; } - if (nodeOnRightSide.parent.kind === 201) { + if (nodeOnRightSide.parent.kind === 208) { return nodeOnRightSide.parent.exportName === nodeOnRightSide && nodeOnRightSide.parent; } return undefined; } function isInRightSideOfImportOrExportAssignment(node) { - return getLeftSideOfImportOrExportAssignment(node) !== undefined; + return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; } function isRightSideOfQualifiedNameOrPropertyAccess(node) { - return (node.parent.kind === 123 && node.parent.right === node) || - (node.parent.kind === 151 && node.parent.name === node); + return (node.parent.kind === 125 && node.parent.right === node) || + (node.parent.kind === 153 && node.parent.name === node); } function getSymbolOfEntityNameOrPropertyAccessExpression(entityName) { if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) { return getSymbolOfNode(entityName.parent); } - if (entityName.parent.kind === 201) { + if (entityName.parent.kind === 208) { return resolveEntityName(entityName.parent.parent, entityName, 107455 | 793056 | 1536 | 8388608); } - if (entityName.kind !== 151) { + if (entityName.kind !== 153) { if (isInRightSideOfImportOrExportAssignment(entityName)) { - return getSymbolOfPartOfRightHandSideOfImport(entityName); + return getSymbolOfPartOfRightHandSideOfImportEquals(entityName); } } if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { @@ -15640,14 +15959,14 @@ var ts; var meaning = 107455 | 8388608; return resolveEntityName(entityName, entityName, meaning); } - else if (entityName.kind === 151) { + else if (entityName.kind === 153) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkPropertyAccessExpression(entityName); } return getNodeLinks(entityName).resolvedSymbol; } - else if (entityName.kind === 123) { + else if (entityName.kind === 125) { var symbol = getNodeLinks(entityName).resolvedSymbol; if (!symbol) { checkQualifiedName(entityName); @@ -15656,7 +15975,7 @@ var ts; } } else if (isTypeReferenceIdentifier(entityName)) { - var meaning = entityName.parent.kind === 137 ? 793056 : 1536; + var meaning = entityName.parent.kind === 139 ? 793056 : 1536; meaning |= 8388608; return resolveEntityName(entityName, entityName, meaning); } @@ -15670,32 +15989,32 @@ var ts; return getSymbolOfNode(node.parent); } if (node.kind === 64 && isInRightSideOfImportOrExportAssignment(node)) { - return node.parent.kind === 201 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImport(node); + return node.parent.kind === 208 ? getSymbolOfEntityNameOrPropertyAccessExpression(node) : getSymbolOfPartOfRightHandSideOfImportEquals(node); } switch (node.kind) { case 64: - case 151: - case 123: + case 153: + case 125: return getSymbolOfEntityNameOrPropertyAccessExpression(node); case 92: case 90: var type = checkExpression(node); return type.symbol; - case 112: + case 114: var constructorDeclaration = node.parent; - if (constructorDeclaration && constructorDeclaration.kind === 131) { + if (constructorDeclaration && constructorDeclaration.kind === 133) { return constructorDeclaration.parent.symbol; } return undefined; case 8: - if (ts.isExternalModuleImportDeclaration(node.parent.parent) && - ts.getExternalModuleImportDeclarationExpression(node.parent.parent) === node) { + if (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && + ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) { var importSymbol = getSymbolOfNode(node.parent.parent); var moduleType = getTypeOfSymbol(importSymbol); return moduleType ? moduleType.symbol : undefined; } case 7: - if (node.parent.kind == 152 && node.parent.argumentExpression === node) { + if (node.parent.kind == 154 && node.parent.argumentExpression === node) { var objectType = checkExpression(node.parent.expression); if (objectType === unknownType) return undefined; @@ -15709,7 +16028,7 @@ var ts; return undefined; } function getShorthandAssignmentValueSymbol(location) { - if (location && location.kind === 208) { + if (location && location.kind === 218) { return resolveEntityName(location, location.name, 107455); } return undefined; @@ -15783,7 +16102,7 @@ var ts; return [symbol]; } function isExternalModuleSymbol(symbol) { - return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 210; + return symbol.flags & 512 && symbol.declarations.length === 1 && symbol.declarations[0].kind === 220; } function isNodeDescendentOf(node, ancestor) { while (node) { @@ -15796,60 +16115,144 @@ var ts; function isUniqueLocalName(name, container) { for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) { if (node.locals && ts.hasProperty(node.locals, name)) { - var symbolWithRelevantName = node.locals[name]; - if (symbolWithRelevantName.flags & (107455 | 1048576)) { + if (node.locals[name].flags & (107455 | 1048576 | 8388608)) { return false; } - if (symbolWithRelevantName.flags & 8388608) { - var importDeclarationWithRelevantName = ts.getDeclarationOfKind(symbolWithRelevantName, 200); - if (isReferencedImportDeclaration(importDeclarationWithRelevantName)) { - return false; - } - } } } return true; } - function getLocalNameOfContainer(container) { - var links = getNodeLinks(container); - if (!links.localModuleName) { - var prefix = ""; - var name = ts.unescapeIdentifier(container.name.text); - while (!isUniqueLocalName(ts.escapeIdentifier(prefix + name), container)) { - prefix += "_"; - } - links.localModuleName = prefix + ts.getTextOfNode(container.name); + function getGeneratedNamesForSourceFile(sourceFile) { + var links = getNodeLinks(sourceFile); + var generatedNames = links.generatedNames; + if (!generatedNames) { + generatedNames = links.generatedNames = {}; + generateNames(sourceFile); + } + return generatedNames; + function generateNames(node) { + switch (node.kind) { + case 200: + generateNameForModuleOrEnum(node); + generateNames(node.body); + break; + case 199: + generateNameForModuleOrEnum(node); + break; + case 203: + generateNameForImportDeclaration(node); + break; + case 209: + generateNameForExportDeclaration(node); + break; + case 220: + case 201: + ts.forEach(node.statements, generateNames); + break; + } + } + function isExistingName(name) { + return ts.hasProperty(globals, name) || ts.hasProperty(sourceFile.identifiers, name) || ts.hasProperty(generatedNames, name); + } + function makeUniqueName(baseName) { + if (baseName.charCodeAt(0) !== 95) { + var baseName = "_" + baseName; + if (!isExistingName(baseName)) { + return generatedNames[baseName] = baseName; + } + } + if (baseName.charCodeAt(baseName.length - 1) !== 95) { + baseName += "_"; + } + var i = 1; + while (true) { + name = baseName + i; + if (!isExistingName(name)) { + return generatedNames[name] = name; + } + i++; + } + } + function assignGeneratedName(node, name) { + getNodeLinks(node).generatedName = ts.unescapeIdentifier(name); + } + function generateNameForModuleOrEnum(node) { + if (node.name.kind === 64) { + var name = node.name.text; + assignGeneratedName(node, 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)); + } + function generateNameForImportDeclaration(node) { + if (node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === 206) { + generateNameForImportOrExportDeclaration(node); + } + } + function generateNameForExportDeclaration(node) { + if (node.moduleSpecifier) { + generateNameForImportOrExportDeclaration(node); + } } - return links.localModuleName; } - function getLocalNameForSymbol(symbol, location) { + function getGeneratedNameForNode(node) { + var links = getNodeLinks(node); + if (!links.generatedName) { + getGeneratedNamesForSourceFile(getSourceFile(node)); + } + return links.generatedName; + } + function getLocalNameOfContainer(container) { + return getGeneratedNameForNode(container); + } + function getLocalNameForImportDeclaration(node) { + return getGeneratedNameForNode(node); + } + function getImportNameSubstitution(symbol) { + var declaration = getDeclarationOfImportSymbol(symbol); + if (declaration && declaration.kind === 207) { + var moduleName = getGeneratedNameForNode(declaration.parent.parent.parent); + var propertyName = declaration.propertyName || declaration.name; + return moduleName + "." + ts.unescapeIdentifier(propertyName.text); + } + } + function getExportNameSubstitution(symbol, location) { + if (isExternalModuleSymbol(symbol.parent)) { + return "exports." + ts.unescapeIdentifier(symbol.name); + } var node = location; + var containerSymbol = getParentOfSymbol(symbol); while (node) { - if ((node.kind === 198 || node.kind === 197) && getSymbolOfNode(node) === symbol) { - return getLocalNameOfContainer(node); + if ((node.kind === 200 || node.kind === 199) && getSymbolOfNode(node) === containerSymbol) { + return getGeneratedNameForNode(node) + "." + ts.unescapeIdentifier(symbol.name); } node = node.parent; } - ts.Debug.fail("getLocalNameForSymbol failed"); } - function getExpressionNamePrefix(node) { + function getExpressionNameSubstitution(node) { var symbol = getNodeLinks(node).resolvedSymbol; if (symbol) { + if (symbol.parent) { + return getExportNameSubstitution(symbol, node.parent); + } var exportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); if (symbol !== exportSymbol && !(exportSymbol.flags & 944)) { - symbol = exportSymbol; + return getExportNameSubstitution(exportSymbol, node.parent); } - if (symbol.parent) { - return isExternalModuleSymbol(symbol.parent) ? "exports" : getLocalNameForSymbol(getParentOfSymbol(symbol), node.parent); + if (symbol.flags & 8388608) { + return getImportNameSubstitution(symbol); } } } function getExportAssignmentName(node) { var symbol = getExportAssignmentSymbol(getSymbolOfNode(node)); - return symbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; + return symbol && symbol !== unknownSymbol && symbolIsValue(symbol) && !isConstEnumSymbol(symbol) ? symbolToString(symbol) : undefined; } - function isTopLevelValueImportWithEntityName(node) { - if (node.parent.kind !== 210 || !ts.isInternalModuleImportDeclaration(node)) { + function isTopLevelValueImportEqualsWithEntityName(node) { + if (node.parent.kind !== 220 || !ts.isInternalModuleImportEqualsDeclaration(node)) { return false; } return isImportResolvedToValue(getSymbolOfNode(node)); @@ -15862,14 +16265,16 @@ var ts; return isConstEnumSymbol(s) || s.constEnumOnlyModule; } function isReferencedImportDeclaration(node) { - var symbol = getSymbolOfNode(node); - if (getSymbolLinks(symbol).referenced) { - return true; + if (isImportSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + if (getSymbolLinks(symbol).referenced) { + return true; + } + if (node.kind === 202 && node.flags & 1 && isImportResolvedToValue(symbol)) { + return true; + } } - if (node.flags & 1) { - return isImportResolvedToValue(symbol); - } - return false; + return ts.forEachChild(node, isReferencedImportDeclaration); } function isImplementationOfOverload(node) { if (ts.nodeIsPresent(node.body)) { @@ -15888,14 +16293,14 @@ var ts; return getNodeLinks(node).enumMemberValue; } function getConstantValue(node) { - if (node.kind === 209) { + if (node.kind === 219) { return getEnumMemberValue(node); } var symbol = getNodeLinks(node).resolvedSymbol; if (symbol && (symbol.flags & 8)) { var declaration = symbol.valueDeclaration; var constantValue; - if (declaration.kind === 209) { + if (declaration.kind === 219) { return getEnumMemberValue(declaration); } } @@ -15911,16 +16316,17 @@ var ts; getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags); } function isUnknownIdentifier(location, name) { - return !resolveName(location, name, 107455, undefined, undefined); + return !resolveName(location, name, 107455, undefined, undefined) && + !ts.hasProperty(getGeneratedNamesForSourceFile(getSourceFile(location)), name); } function createResolver() { return { - getLocalNameOfContainer: getLocalNameOfContainer, - getExpressionNamePrefix: getExpressionNamePrefix, + getGeneratedNameForNode: getGeneratedNameForNode, + getExpressionNameSubstitution: getExpressionNameSubstitution, getExportAssignmentName: getExportAssignmentName, isReferencedImportDeclaration: isReferencedImportDeclaration, getNodeCheckFlags: getNodeCheckFlags, - isTopLevelValueImportWithEntityName: isTopLevelValueImportWithEntityName, + isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName, isDeclarationVisible: isDeclarationVisible, isImplementationOfOverload: isImplementationOfOverload, writeTypeOfDeclaration: writeTypeOfDeclaration, @@ -15937,7 +16343,7 @@ var ts; }); ts.forEach(host.getSourceFiles(), function (file) { if (!ts.isExternalModule(file)) { - extendSymbolTable(globals, file.locals); + mergeSymbolTable(globals, file.locals); } }); getSymbolLinks(undefinedSymbol).type = undefinedType; @@ -15966,24 +16372,26 @@ var ts; } function checkGrammarModifiers(node) { switch (node.kind) { - case 132: + case 134: + case 135: case 133: - case 131: - case 128: - case 127: case 130: case 129: - case 136: - case 194: + case 132: + case 131: + case 138: + case 196: + case 197: + case 200: + case 199: + case 175: case 195: case 198: - case 197: - case 201: - case 173: - case 193: - case 196: - case 200: - case 126: + case 203: + case 202: + case 209: + case 208: + case 128: break; default: return false; @@ -15996,14 +16404,14 @@ var ts; for (var i = 0, n = node.modifiers.length; i < n; i++) { var modifier = node.modifiers[i]; switch (modifier.kind) { + case 109: + case 108: case 107: - case 106: - case 105: var text; - if (modifier.kind === 107) { + if (modifier.kind === 109) { text = "public"; } - else if (modifier.kind === 106) { + else if (modifier.kind === 108) { text = "protected"; lastProtected = modifier; } @@ -16017,19 +16425,19 @@ var ts; else if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); } - else if (node.parent.kind === 199 || node.parent.kind === 210) { + else if (node.parent.kind === 201 || node.parent.kind === 220) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text); } flags |= ts.modifierToFlag(modifier.kind); break; - case 108: + case 110: if (flags & 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); } - else if (node.parent.kind === 199 || node.parent.kind === 210) { + else if (node.parent.kind === 201 || node.parent.kind === 220) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, "static"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); } flags |= 128; @@ -16042,25 +16450,25 @@ var ts; else if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); } - else if (node.parent.kind === 194) { + else if (node.parent.kind === 196) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "export"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); } flags |= 1; break; - case 113: + case 115: if (flags & 2) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); } - else if (node.parent.kind === 194) { + else if (node.parent.kind === 196) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_class_element, "declare"); } - else if (node.kind === 126) { + else if (node.kind === 128) { return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); } - else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 199) { + else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 201) { return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); } flags |= 2; @@ -16068,7 +16476,7 @@ var ts; break; } } - if (node.kind === 131) { + if (node.kind === 133) { if (flags & 128) { return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); } @@ -16079,13 +16487,13 @@ var ts; return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private"); } } - else if (node.kind === 200 && flags & 2) { + else if ((node.kind === 203 || node.kind === 202) && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_import_declaration, "declare"); } - else if (node.kind === 195 && flags & 2) { + else if (node.kind === 197 && flags & 2) { return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_declare_modifier_cannot_be_used_with_an_interface_declaration, "declare"); } - else if (node.kind === 126 && (flags & 112) && ts.isBindingPattern(node.name)) { + else if (node.kind === 128 && (flags & 112) && ts.isBindingPattern(node.name)) { return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern); } } @@ -16168,7 +16576,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 !== 119 && parameter.type.kind !== 117) { + if (parameter.type.kind !== 121 && parameter.type.kind !== 119) { return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_or_number); } if (!node.type) { @@ -16200,7 +16608,7 @@ var ts; var sourceFile = ts.getSourceFileOfNode(node); for (var i = 0, n = arguments.length; i < n; i++) { var arg = arguments[i]; - if (arg.kind === 170) { + if (arg.kind === 172) { return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected); } } @@ -16241,7 +16649,7 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 101); + ts.Debug.assert(heritageClause.token === 103); if (seenImplementsClause) { return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); } @@ -16264,7 +16672,7 @@ var ts; seenExtendsClause = true; } else { - ts.Debug.assert(heritageClause.token === 101); + ts.Debug.assert(heritageClause.token === 103); return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); } checkGrammarHeritageClause(heritageClause); @@ -16273,11 +16681,11 @@ var ts; return false; } function checkGrammarComputedPropertyName(node) { - if (node.kind !== 124) { + if (node.kind !== 126) { return false; } var computedPropertyName = node; - if (computedPropertyName.expression.kind === 165 && computedPropertyName.expression.operatorToken.kind === 23) { + if (computedPropertyName.expression.kind === 167 && computedPropertyName.expression.operatorToken.kind === 23) { return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); } } @@ -16304,26 +16712,26 @@ var ts; for (var i = 0, n = node.properties.length; i < n; i++) { var prop = node.properties[i]; var name = prop.name; - if (prop.kind === 170 || - name.kind === 124) { + if (prop.kind === 172 || + name.kind === 126) { checkGrammarComputedPropertyName(name); continue; } var currentKind; - if (prop.kind === 207 || prop.kind === 208) { + if (prop.kind === 217 || prop.kind === 218) { checkGrammarForInvalidQuestionMark(prop, prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); if (name.kind === 7) { checkGrammarNumbericLiteral(name); } currentKind = Property; } - else if (prop.kind === 130) { + else if (prop.kind === 132) { currentKind = Property; } - else if (prop.kind === 132) { + else if (prop.kind === 134) { currentKind = GetAccessor; } - else if (prop.kind === 133) { + else if (prop.kind === 135) { currentKind = SetAccesor; } else { @@ -16357,20 +16765,20 @@ var ts; if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { return true; } - if (forInOrOfStatement.initializer.kind === 192) { + if (forInOrOfStatement.initializer.kind === 194) { var variableList = forInOrOfStatement.initializer; if (!checkGrammarVariableDeclarationList(variableList)) { if (variableList.declarations.length > 1) { - var diagnostic = forInOrOfStatement.kind === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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 === 180 ? 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; + var diagnostic = forInOrOfStatement.kind === 182 ? 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); } } @@ -16398,10 +16806,10 @@ var ts; else if (accessor.typeParameters) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); } - else if (kind === 132 && accessor.parameters.length) { + else if (kind === 134 && accessor.parameters.length) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_get_accessor_cannot_have_parameters); } - else if (kind === 133) { + else if (kind === 135) { if (accessor.type) { return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); } @@ -16426,7 +16834,7 @@ var ts; } } function checkGrammarForNonSymbolComputedProperty(node, message) { - if (node.kind === 124 && !ts.isWellKnownSymbolSyntactically(node.expression)) { + if (node.kind === 126 && !ts.isWellKnownSymbolSyntactically(node.expression)) { return grammarErrorOnNode(node, message); } } @@ -16436,7 +16844,7 @@ var ts; checkGrammarForGenerator(node)) { return true; } - if (node.parent.kind === 150) { + if (node.parent.kind === 152) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -16444,7 +16852,7 @@ var ts; return grammarErrorAtPos(getSourceFile(node), node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); } } - if (node.parent.kind === 194) { + if (node.parent.kind === 196) { if (checkGrammarForInvalidQuestionMark(node, node.questionToken, ts.Diagnostics.A_class_member_cannot_be_declared_optional)) { return true; } @@ -16455,22 +16863,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 === 195) { + else if (node.parent.kind === 197) { 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 === 141) { + else if (node.parent.kind === 143) { 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 181: + case 182: + case 183: case 179: case 180: - case 181: - case 177: - case 178: return true; - case 187: + case 189: return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); } return false; @@ -16482,17 +16890,17 @@ var ts; return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); } switch (current.kind) { - case 187: + case 189: if (node.label && current.label.text === node.label.text) { - var isMisplacedContinueLabel = node.kind === 182 && !isIterationStatement(current.statement, true); + var isMisplacedContinueLabel = node.kind === 184 && !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); } return false; } break; - case 186: - if (node.kind === 183 && !node.label) { + case 188: + if (node.kind === 185 && !node.label) { return false; } break; @@ -16505,11 +16913,11 @@ var ts; current = current.parent; } if (node.label) { - var message = node.kind === 183 ? 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; + var message = node.kind === 185 ? 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 === 183 ? 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; + var message = node.kind === 185 ? 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); } } @@ -16580,15 +16988,15 @@ var ts; } function allowLetAndConstDeclarations(parent) { switch (parent.kind) { - case 176: - case 177: case 178: - case 185: case 179: case 180: - case 181: - return false; case 187: + case 181: + case 182: + case 183: + return false; + case 189: return allowLetAndConstDeclarations(parent.parent); } return true; @@ -16604,7 +17012,7 @@ var ts; } } function isIntegerLiteral(expression) { - if (expression.kind === 163) { + if (expression.kind === 165) { var unaryExpression = expression; if (unaryExpression.operator === 33 || unaryExpression.operator === 34) { expression = unaryExpression.operand; @@ -16623,7 +17031,7 @@ var ts; var inAmbientContext = ts.isInAmbientContext(enumDecl); for (var i = 0, n = enumDecl.members.length; i < n; i++) { var node = enumDecl.members[i]; - if (node.name.kind === 124) { + if (node.name.kind === 126) { hasError = grammarErrorOnNode(node.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); } else if (inAmbientContext) { @@ -16691,18 +17099,18 @@ var ts; } } function checkGrammarProperty(node) { - if (node.parent.kind === 194) { + if (node.parent.kind === 196) { 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 === 195) { + else if (node.parent.kind === 197) { 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 === 141) { + else if (node.parent.kind === 143) { if (checkGrammarForNonSymbolComputedProperty(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol)) { return true; } @@ -16712,9 +17120,11 @@ var ts; } } function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { - if (node.kind === 195 || - node.kind === 200 || - node.kind === 201 || + if (node.kind === 197 || + node.kind === 203 || + node.kind === 202 || + node.kind === 209 || + node.kind === 208 || (node.flags & 2)) { return false; } @@ -16723,7 +17133,7 @@ var ts; function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { for (var i = 0, n = file.statements.length; i < n; i++) { var decl = file.statements[i]; - if (ts.isDeclaration(decl) || decl.kind === 173) { + if (ts.isDeclaration(decl) || decl.kind === 175) { if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { return true; } @@ -16742,7 +17152,7 @@ var ts; if (!links.hasReportedStatementInAmbientContext && ts.isAnyFunction(node.parent)) { return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); } - if (node.parent.kind === 172 || node.parent.kind === 199 || node.parent.kind === 210) { + if (node.parent.kind === 174 || node.parent.kind === 201 || node.parent.kind === 220) { var links = getNodeLinks(node.parent); if (!links.hasReportedStatementInAmbientContext) { return links.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); @@ -16951,7 +17361,7 @@ var ts; } function getFirstConstructorWithBody(node) { return ts.forEach(node.members, function (member) { - if (member.kind === 131 && ts.nodeIsPresent(member.body)) { + if (member.kind === 133 && ts.nodeIsPresent(member.body)) { return member; } }); @@ -16962,10 +17372,10 @@ var ts; var setAccessor; if (ts.hasDynamicName(accessor)) { firstAccessor = accessor; - if (accessor.kind === 132) { + if (accessor.kind === 134) { getAccessor = accessor; } - else if (accessor.kind === 133) { + else if (accessor.kind === 135) { setAccessor = accessor; } else { @@ -16974,17 +17384,17 @@ var ts; } else { ts.forEach(declarations, function (member) { - if ((member.kind === 132 || member.kind === 133) && (member.flags & 128) === (accessor.flags & 128)) { + if ((member.kind === 134 || member.kind === 135) && (member.flags & 128) === (accessor.flags & 128)) { var memberName = ts.getPropertyNameForPropertyNameNode(member.name); var accessorName = ts.getPropertyNameForPropertyNameNode(accessor.name); if (memberName === accessorName) { if (!firstAccessor) { firstAccessor = member; } - if (member.kind === 132 && !getAccessor) { + if (member.kind === 134 && !getAccessor) { getAccessor = member; } - if (member.kind === 133 && !setAccessor) { + if (member.kind === 135 && !setAccessor) { setAccessor = member; } } @@ -17110,16 +17520,16 @@ var ts; increaseIndent = newWriter.increaseIndent; decreaseIndent = newWriter.decreaseIndent; } - function writeAsychronousImportDeclarations(importDeclarations) { + function writeAsychronousImportEqualsDeclarations(importEqualsDeclarations) { var oldWriter = writer; - ts.forEach(importDeclarations, function (aliasToWrite) { + ts.forEach(importEqualsDeclarations, function (aliasToWrite) { var aliasEmitInfo = ts.forEach(aliasDeclarationEmitInfo, function (declEmitInfo) { return declEmitInfo.declaration === aliasToWrite ? declEmitInfo : undefined; }); if (aliasEmitInfo) { createAndSetNewTextWriterWithSymbolWriter(); for (var declarationIndent = aliasEmitInfo.indent; declarationIndent; declarationIndent--) { increaseIndent(); } - writeImportDeclaration(aliasToWrite); + writeImportEqualsDeclaration(aliasToWrite); aliasEmitInfo.asynchronousOutput = writer.getText(); } }); @@ -17128,7 +17538,7 @@ var ts; function handleSymbolAccessibilityError(symbolAccesibilityResult) { if (symbolAccesibilityResult.accessibility === 0) { if (symbolAccesibilityResult && symbolAccesibilityResult.aliasesToMakeVisible) { - writeAsychronousImportDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); + writeAsychronousImportEqualsDeclarations(symbolAccesibilityResult.aliasesToMakeVisible); } } else { @@ -17198,40 +17608,40 @@ var ts; } function emitType(type) { switch (type.kind) { - case 110: + case 112: + case 121: case 119: - case 117: - case 111: - case 120: + case 113: + case 122: case 98: case 8: return writeTextOfNode(currentSourceFile, type); - case 137: - return emitTypeReference(type); - case 140: - return emitTypeQuery(type); - case 142: - return emitArrayType(type); - case 143: - return emitTupleType(type); - case 144: - return emitUnionType(type); - case 145: - return emitParenType(type); - case 138: case 139: - return emitSignatureDeclarationWithJsDocComments(type); + return emitTypeReference(type); + case 142: + return emitTypeQuery(type); + case 144: + return emitArrayType(type); + case 145: + return emitTupleType(type); + case 146: + return emitUnionType(type); + case 147: + return emitParenType(type); + case 140: case 141: + return emitSignatureDeclarationWithJsDocComments(type); + case 143: return emitTypeLiteral(type); case 64: return emitEntityName(type); - case 123: + case 125: return emitEntityName(type); default: ts.Debug.fail("Unknown type annotation: " + type.kind); } function emitEntityName(entityName) { - var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 200 ? entityName.parent : enclosingDeclaration); + var visibilityResult = resolver.isEntityNameVisible(entityName, entityName.parent.kind === 202 ? entityName.parent : enclosingDeclaration); handleSymbolAccessibilityError(visibilityResult); writeEntityName(entityName); function writeEntityName(entityName) { @@ -17302,7 +17712,7 @@ var ts; if (node.flags & 1) { write("export "); } - if (node.kind !== 195) { + if (node.kind !== 197) { write("declare "); } } @@ -17318,7 +17728,7 @@ var ts; write("static "); } } - function emitImportDeclaration(node) { + function emitImportEqualsDeclaration(node) { var nodeEmitInfo = { declaration: node, outputPos: writer.getTextPos(), @@ -17327,10 +17737,10 @@ var ts; }; aliasDeclarationEmitInfo.push(nodeEmitInfo); if (nodeEmitInfo.hasWritten) { - writeImportDeclaration(node); + writeImportEqualsDeclaration(node); } } - function writeImportDeclaration(node) { + function writeImportEqualsDeclaration(node) { emitJsDocComments(node); if (node.flags & 1) { write("export "); @@ -17338,13 +17748,13 @@ var ts; write("import "); writeTextOfNode(currentSourceFile, node.name); write(" = "); - if (ts.isInternalModuleImportDeclaration(node)) { + if (ts.isInternalModuleImportEqualsDeclaration(node)) { emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.moduleReference, getImportEntityNameVisibilityError); write(";"); } else { write("require("); - writeTextOfNode(currentSourceFile, ts.getExternalModuleImportDeclarationExpression(node)); + writeTextOfNode(currentSourceFile, ts.getExternalModuleImportEqualsDeclarationExpression(node)); write(");"); } writer.writeLine(); @@ -17362,7 +17772,7 @@ var ts; emitModuleElementDeclarationFlags(node); write("module "); writeTextOfNode(currentSourceFile, node.name); - while (node.body.kind !== 199) { + while (node.body.kind !== 201) { node = node.body; write("."); writeTextOfNode(currentSourceFile, node.name); @@ -17428,7 +17838,7 @@ var ts; writeLine(); } function isPrivateMethodTypeParameter(node) { - return node.parent.kind === 130 && (node.parent.flags & 32); + return node.parent.kind === 132 && (node.parent.flags & 32); } function emitTypeParameters(typeParameters) { function emitTypeParameter(node) { @@ -17438,15 +17848,15 @@ var ts; writeTextOfNode(currentSourceFile, node.name); if (node.constraint && !isPrivateMethodTypeParameter(node)) { write(" extends "); - if (node.parent.kind === 138 || - node.parent.kind === 139 || - (node.parent.parent && node.parent.parent.kind === 141)) { - ts.Debug.assert(node.parent.kind === 130 || - node.parent.kind === 129 || - node.parent.kind === 138 || - node.parent.kind === 139 || - node.parent.kind === 134 || - node.parent.kind === 135); + if (node.parent.kind === 140 || + node.parent.kind === 141 || + (node.parent.parent && node.parent.parent.kind === 143)) { + ts.Debug.assert(node.parent.kind === 132 || + node.parent.kind === 131 || + node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.kind === 136 || + node.parent.kind === 137); emitType(node.constraint); } else { @@ -17456,31 +17866,31 @@ var ts; function getTypeParameterConstraintVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 194: + case 196: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; break; - case 195: + case 197: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; break; - case 135: + case 137: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 134: + case 136: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; break; - case 130: - case 129: + case 132: + case 131: 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 === 194) { + else if (node.parent.parent.kind === 196) { 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 193: + case 195: diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -17508,7 +17918,7 @@ var ts; emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError); function getHeritageClauseVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.parent.parent.kind === 194) { + if (node.parent.parent.kind === 196) { 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; } else { @@ -17587,12 +17997,12 @@ var ts; writeLine(); } function emitVariableDeclaration(node) { - if (node.kind !== 191 || resolver.isDeclarationVisible(node)) { + if (node.kind !== 193 || resolver.isDeclarationVisible(node)) { writeTextOfNode(currentSourceFile, node.name); - if ((node.kind === 128 || node.kind === 127) && ts.hasQuestionToken(node)) { + if ((node.kind === 130 || node.kind === 129) && ts.hasQuestionToken(node)) { write("?"); } - if ((node.kind === 128 || node.kind === 127) && node.parent.kind === 141) { + if ((node.kind === 130 || node.kind === 129) && node.parent.kind === 143) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.flags & 32)) { @@ -17601,14 +18011,14 @@ var ts; } function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (node.kind === 191) { + if (node.kind === 193) { diagnosticMessage = 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 === 128 || node.kind === 127) { + else if (node.kind === 130 || node.kind === 129) { if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 194) { + else if (node.parent.kind === 196) { diagnosticMessage = 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 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; } else { @@ -17661,7 +18071,7 @@ var ts; var accessorWithTypeAnnotation = node; var type = getTypeAnnotationFromAccessor(node); if (!type) { - var anotherAccessor = node.kind === 132 ? accessors.setAccessor : accessors.getAccessor; + var anotherAccessor = node.kind === 134 ? accessors.setAccessor : accessors.getAccessor; type = getTypeAnnotationFromAccessor(anotherAccessor); if (type) { accessorWithTypeAnnotation = anotherAccessor; @@ -17674,12 +18084,12 @@ var ts; } function getTypeAnnotationFromAccessor(accessor) { if (accessor) { - return accessor.kind === 132 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; + return accessor.kind === 134 ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : undefined; } } function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; - if (accessorWithTypeAnnotation.kind === 133) { + if (accessorWithTypeAnnotation.kind === 135) { 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 : ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1; } @@ -17711,20 +18121,20 @@ var ts; if (ts.hasDynamicName(node)) { return; } - if ((node.kind !== 193 || resolver.isDeclarationVisible(node)) && + if ((node.kind !== 195 || resolver.isDeclarationVisible(node)) && !resolver.isImplementationOfOverload(node)) { emitJsDocComments(node); - if (node.kind === 193) { + if (node.kind === 195) { emitModuleElementDeclarationFlags(node); } - else if (node.kind === 130) { + else if (node.kind === 132) { emitClassMemberDeclarationFlags(node); } - if (node.kind === 193) { + if (node.kind === 195) { write("function "); writeTextOfNode(currentSourceFile, node.name); } - else if (node.kind === 131) { + else if (node.kind === 133) { write("constructor"); } else { @@ -17741,11 +18151,11 @@ var ts; emitSignatureDeclaration(node); } function emitSignatureDeclaration(node) { - if (node.kind === 135 || node.kind === 139) { + if (node.kind === 137 || node.kind === 141) { write("new "); } emitTypeParameters(node.typeParameters); - if (node.kind === 136) { + if (node.kind === 138) { write("["); } else { @@ -17754,20 +18164,20 @@ var ts; var prevEnclosingDeclaration = enclosingDeclaration; enclosingDeclaration = node; emitCommaList(node.parameters, emitParameterDeclaration); - if (node.kind === 136) { + if (node.kind === 138) { write("]"); } else { write(")"); } - var isFunctionTypeOrConstructorType = node.kind === 138 || node.kind === 139; - if (isFunctionTypeOrConstructorType || node.parent.kind === 141) { + var isFunctionTypeOrConstructorType = node.kind === 140 || node.kind === 141; + if (isFunctionTypeOrConstructorType || node.parent.kind === 143) { if (node.type) { write(isFunctionTypeOrConstructorType ? " => " : ": "); emitType(node.type); } } - else if (node.kind !== 131 && !(node.flags & 32)) { + else if (node.kind !== 133 && !(node.flags & 32)) { writeReturnTypeAtSignature(node, getReturnTypeVisibilityError); } enclosingDeclaration = prevEnclosingDeclaration; @@ -17778,28 +18188,28 @@ var ts; function getReturnTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.kind) { - case 135: + case 137: 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 134: + case 136: 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 136: + case 138: 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 130: - case 129: + case 132: + case 131: if (node.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : 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 === 194) { + else if (node.parent.kind === 196) { 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 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; } break; - case 193: + case 195: 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 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; break; default: @@ -17827,9 +18237,9 @@ var ts; write("?"); } decreaseIndent(); - if (node.parent.kind === 138 || - node.parent.kind === 139 || - node.parent.parent.kind === 141) { + if (node.parent.kind === 140 || + node.parent.kind === 141 || + node.parent.parent.kind === 143) { emitTypeOfVariableDeclarationFromTypeLiteral(node); } else if (!(node.parent.flags & 32)) { @@ -17838,28 +18248,28 @@ var ts; function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) { var diagnosticMessage; switch (node.parent.kind) { - case 131: + case 133: diagnosticMessage = 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; break; - case 135: + case 137: diagnosticMessage = 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; break; - case 134: + case 136: diagnosticMessage = 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; break; - case 130: - case 129: + case 132: + case 131: if (node.parent.flags & 128) { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? symbolAccesibilityResult.accessibility === 2 ? ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : 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 === 194) { + else if (node.parent.parent.kind === 196) { diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; } else { diagnosticMessage = symbolAccesibilityResult.errorModuleName ? 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; } break; - case 193: + case 195: diagnosticMessage = 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 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; break; default: @@ -17874,40 +18284,40 @@ var ts; } function emitNode(node) { switch (node.kind) { + case 133: + case 195: + case 132: case 131: - case 193: + return emitFunctionDeclaration(node); + case 137: + case 136: + case 138: + return emitSignatureDeclarationWithJsDocComments(node); + case 134: + case 135: + return emitAccessorDeclaration(node); + case 175: + return emitVariableStatement(node); case 130: case 129: - return emitFunctionDeclaration(node); - case 135: - case 134: - case 136: - return emitSignatureDeclarationWithJsDocComments(node); - case 132: - case 133: - return emitAccessorDeclaration(node); - case 173: - return emitVariableStatement(node); - case 128: - case 127: return emitPropertyDeclaration(node); - case 195: - return emitInterfaceDeclaration(node); - case 194: - return emitClassDeclaration(node); - case 196: - return emitTypeAliasDeclaration(node); - case 209: - return emitEnumMemberDeclaration(node); case 197: - return emitEnumDeclaration(node); + return emitInterfaceDeclaration(node); + case 196: + return emitClassDeclaration(node); case 198: - return emitModuleDeclaration(node); + return emitTypeAliasDeclaration(node); + case 219: + return emitEnumMemberDeclaration(node); + case 199: + return emitEnumDeclaration(node); case 200: - return emitImportDeclaration(node); - case 201: + return emitModuleDeclaration(node); + case 202: + return emitImportEqualsDeclaration(node); + case 208: return emitExportAssignment(node); - case 210: + case 220: return emitSourceFile(node); } } @@ -17968,6 +18378,8 @@ var ts; var tempCount = 0; var tempVariables; var tempParameters; + var externalImports; + var exportSpecifiers; var writeEmittedFiles = writeJavaScriptFile; var emitLeadingComments = compilerOptions.removeComments ? function (node) { } : emitLeadingDeclarationComments; var emitTrailingComments = compilerOptions.removeComments ? function (node) { } : emitTrailingDeclarationComments; @@ -18124,7 +18536,7 @@ var ts; var parentIndex = getSourceMapNameIndex(); if (parentIndex !== -1) { var name = node.name; - if (!name || name.kind !== 124) { + if (!name || name.kind !== 126) { scopeName = "." + scopeName; } scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName; @@ -18141,18 +18553,18 @@ var ts; if (scopeName) { recordScopeNameStart(scopeName); } - else if (node.kind === 193 || - node.kind === 158 || - node.kind === 130 || - node.kind === 129 || + else if (node.kind === 195 || + node.kind === 160 || node.kind === 132 || - node.kind === 133 || - node.kind === 198 || - node.kind === 194 || - node.kind === 197) { + node.kind === 131 || + node.kind === 134 || + node.kind === 135 || + node.kind === 200 || + node.kind === 196 || + node.kind === 199) { if (node.name) { var name = node.name; - scopeName = name.kind === 124 ? ts.getTextOfNode(name) : node.name.text; + scopeName = name.kind === 126 ? ts.getTextOfNode(name) : node.name.text; } recordScopeNameStart(scopeName); } @@ -18232,7 +18644,7 @@ var ts; } function emitNodeWithMap(node) { if (node) { - if (node.kind != 210) { + if (node.kind != 220) { recordEmitNodeStartSpan(node); emitNode(node); recordEmitNodeEndSpan(node); @@ -18436,7 +18848,7 @@ var ts; } for (var i = 0; i < node.templateSpans.length; i++) { var templateSpan = node.templateSpans[i]; - var needsParens = templateSpan.expression.kind !== 157 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; + var needsParens = templateSpan.expression.kind !== 159 && comparePrecedenceToBinaryPlus(templateSpan.expression) !== 1; if (i > 0 || headEmitted) { write(" + "); } @@ -18455,11 +18867,11 @@ var ts; } function templateNeedsParens(template, parent) { switch (parent.kind) { - case 153: - case 154: - return parent.expression === template; case 155: + case 156: + return parent.expression === template; case 157: + case 159: return false; default: return comparePrecedenceToBinaryPlus(parent) !== -1; @@ -18467,7 +18879,7 @@ var ts; } function comparePrecedenceToBinaryPlus(expression) { switch (expression.kind) { - case 165: + case 167: switch (expression.operatorToken.kind) { case 35: case 36: @@ -18479,7 +18891,7 @@ var ts; default: return -1; } - case 166: + case 168: return -1; default: return 1; @@ -18491,11 +18903,11 @@ var ts; emit(span.literal); } function emitExpressionForPropertyName(node) { - ts.Debug.assert(node.kind !== 148); + ts.Debug.assert(node.kind !== 150); if (node.kind === 8) { emitLiteral(node); } - else if (node.kind === 124) { + else if (node.kind === 126) { emit(node.expression); } else { @@ -18512,43 +18924,44 @@ var ts; function isNotExpressionIdentifier(node) { var parent = node.parent; switch (parent.kind) { - case 126: - case 191: - case 148: case 128: - case 127: - case 207: - case 208: - case 209: + case 193: + case 150: case 130: case 129: - case 193: + case 217: + case 218: + case 219: case 132: - case 133: - case 158: - case 194: + case 131: case 195: + case 134: + case 135: + case 160: + case 196: case 197: - case 198: + case 199: case 200: + case 202: return parent.name === node; - case 183: - case 182: - case 201: + case 185: + case 184: + case 208: return false; - case 187: + case 189: return node.parent.label === node; - case 206: + case 216: return node.parent.name === node; } } function emitExpressionIdentifier(node) { - var prefix = resolver.getExpressionNamePrefix(node); - if (prefix) { - write(prefix); - write("."); + var substitution = resolver.getExpressionNameSubstitution(node); + if (substitution) { + write(substitution); + } + else { + writeTextOfNode(currentSourceFile, node); } - writeTextOfNode(currentSourceFile, node); } function emitIdentifier(node) { if (!node.parent) { @@ -18616,11 +19029,11 @@ var ts; function needsParenthesisForPropertyAccess(node) { switch (node.kind) { case 64: - case 149: case 151: - case 152: case 153: - case 157: + case 154: + case 155: + case 159: return false; } return true; @@ -18637,14 +19050,14 @@ var ts; write(", "); } var e = elements[pos]; - if (e.kind === 169) { + if (e.kind === 171) { e = e.expression; emitParenthesized(e, group === 0 && needsParenthesisForPropertyAccess(e)); pos++; } else { var i = pos; - while (i < length && elements[i].kind !== 169) { + while (i < length && elements[i].kind !== 171) { i++; } write("["); @@ -18665,7 +19078,7 @@ var ts; } } function isSpreadElementExpression(node) { - return node.kind === 169; + return node.kind === 171; } function emitArrayLiteral(node) { var elements = node.elements; @@ -18693,7 +19106,7 @@ var ts; } function createDownlevelObjectLiteralWithComputedProperties(originalObjectLiteral, firstComputedPropertyIndex) { var tempVar = createAndRecordTempVariable(originalObjectLiteral); - var initialObjectLiteral = createSynthesizedNode(150); + var initialObjectLiteral = createSynthesizedNode(152); initialObjectLiteral.properties = originalObjectLiteral.properties.slice(0, firstComputedPropertyIndex); initialObjectLiteral.flags |= 256; var propertyPatches = createBinaryExpression(tempVar, 52, initialObjectLiteral); @@ -18718,20 +19131,19 @@ var ts; } function tryGetRightHandSideOfPatchingPropertyAssignment(objectLiteral, property) { switch (property.kind) { - case 207: + case 217: return property.initializer; - case 208: - var prefix = createIdentifier(resolver.getExpressionNamePrefix(property.name)); - return createPropertyAccessExpression(prefix, property.name); - case 130: - return createFunctionExpression(property.parameters, property.body); + case 218: + return createIdentifier(resolver.getExpressionNameSubstitution(property.name)); case 132: - case 133: + return createFunctionExpression(property.parameters, property.body); + case 134: + case 135: var _a = getAllAccessorDeclarations(objectLiteral.properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; if (firstAccessor !== property) { return undefined; } - var propertyDescriptor = createSynthesizedNode(150); + var propertyDescriptor = createSynthesizedNode(152); var descriptorProperties = []; if (getAccessor) { var getProperty = createPropertyAssignment(createIdentifier("get"), createFunctionExpression(getAccessor.parameters, getAccessor.body)); @@ -18754,7 +19166,7 @@ var ts; } } function createParenthesizedExpression(expression) { - var result = createSynthesizedNode(157); + var result = createSynthesizedNode(159); result.expression = expression; return result; } @@ -18769,7 +19181,7 @@ var ts; return result; } function createBinaryExpression(left, operator, right) { - var result = createSynthesizedNode(165); + var result = createSynthesizedNode(167); result.operatorToken = createSynthesizedNode(operator); result.left = left; result.right = right; @@ -18782,7 +19194,7 @@ var ts; else if (memberName.kind === 8 || memberName.kind === 7) { return createElementAccessExpression(expression, memberName); } - else if (memberName.kind === 124) { + else if (memberName.kind === 126) { return createElementAccessExpression(expression, memberName.expression); } else { @@ -18790,25 +19202,25 @@ var ts; } } function createPropertyAssignment(name, initializer) { - var result = createSynthesizedNode(207); + var result = createSynthesizedNode(217); result.name = name; result.initializer = initializer; return result; } function createFunctionExpression(parameters, body) { - var result = createSynthesizedNode(158); + var result = createSynthesizedNode(160); result.parameters = parameters; result.body = body; return result; } function createPropertyAccessExpression(expression, name) { - var result = createSynthesizedNode(151); + var result = createSynthesizedNode(153); result.expression = expression; result.name = name; return result; } function createElementAccessExpression(expression, argumentExpression) { - var result = createSynthesizedNode(152); + var result = createSynthesizedNode(154); result.expression = expression; result.argumentExpression = argumentExpression; return result; @@ -18819,7 +19231,7 @@ var ts; return result; } function createCallExpression(invokedExpression, arguments) { - var result = createSynthesizedNode(153); + var result = createSynthesizedNode(155); result.expression = invokedExpression; result.arguments = arguments; return result; @@ -18830,7 +19242,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 === 124) { + if (properties[i].name.kind === 126) { numInitialNonComputedProperties = i; break; } @@ -18867,7 +19279,7 @@ var ts; } function emitShorthandPropertyAssignment(node) { emit(node.name); - if (languageVersion <= 1 || resolver.getExpressionNamePrefix(node.name)) { + if (languageVersion < 2 || resolver.getExpressionNameSubstitution(node.name)) { write(": "); emitExpressionIdentifier(node.name); } @@ -18877,7 +19289,7 @@ var ts; if (constantValue !== undefined) { write(constantValue.toString()); if (!compilerOptions.removeComments) { - var propertyName = node.kind === 151 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); + var propertyName = node.kind === 153 ? ts.declarationNameToString(node.name) : ts.getTextOfNode(node.argumentExpression); write(" /* " + propertyName + " */"); } return true; @@ -18907,10 +19319,10 @@ var ts; write("]"); } function hasSpreadElement(elements) { - return ts.forEach(elements, function (e) { return e.kind === 169; }); + return ts.forEach(elements, function (e) { return e.kind === 171; }); } function skipParentheses(node) { - while (node.kind === 157 || node.kind === 156) { + while (node.kind === 159 || node.kind === 158) { node = node.expression; } return node; @@ -18931,12 +19343,12 @@ var ts; function emitCallWithSpread(node) { var target; var expr = skipParentheses(node.expression); - if (expr.kind === 151) { + if (expr.kind === 153) { target = emitCallTarget(expr.expression); write("."); emit(expr.name); } - else if (expr.kind === 152) { + else if (expr.kind === 154) { target = emitCallTarget(expr.expression); write("["); emit(expr.argumentExpression); @@ -18977,7 +19389,7 @@ var ts; } else { emit(node.expression); - superCall = node.expression.kind === 151 && node.expression.expression.kind === 90; + superCall = node.expression.kind === 153 && node.expression.expression.kind === 90; } if (superCall) { write(".call("); @@ -19009,19 +19421,19 @@ var ts; emit(node.template); } function emitParenExpression(node) { - if (node.expression.kind === 156) { + if (node.expression.kind === 158) { var operand = node.expression.expression; - while (operand.kind == 156) { + while (operand.kind == 158) { operand = operand.expression; } - if (operand.kind !== 163 && - operand.kind !== 162 && - operand.kind !== 161 && - operand.kind !== 160 && + if (operand.kind !== 165 && operand.kind !== 164 && - operand.kind !== 154 && - !(operand.kind === 153 && node.parent.kind === 154) && - !(operand.kind === 158 && node.parent.kind === 153)) { + operand.kind !== 163 && + operand.kind !== 162 && + operand.kind !== 166 && + operand.kind !== 156 && + !(operand.kind === 155 && node.parent.kind === 156) && + !(operand.kind === 160 && node.parent.kind === 155)) { emit(operand); return; } @@ -19047,7 +19459,7 @@ var ts; } function emitPrefixUnaryExpression(node) { write(ts.tokenToString(node.operator)); - if (node.operand.kind === 163) { + if (node.operand.kind === 165) { var operand = node.operand; if (node.operator === 33 && (operand.operator === 33 || operand.operator === 38)) { write(" "); @@ -19064,7 +19476,7 @@ var ts; } function emitBinaryExpression(node) { if (languageVersion < 2 && node.operatorToken.kind === 52 && - (node.left.kind === 150 || node.left.kind === 149)) { + (node.left.kind === 152 || node.left.kind === 151)) { emitDestructuring(node); } else { @@ -19113,7 +19525,7 @@ var ts; emit(node.whenFalse); } function isSingleLineEmptyBlock(node) { - if (node && node.kind === 172) { + if (node && node.kind === 174) { var block = node; return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block); } @@ -19128,12 +19540,12 @@ var ts; emitToken(14, node.pos); increaseIndent(); scopeEmitStart(node.parent); - if (node.kind === 199) { - ts.Debug.assert(node.parent.kind === 198); + if (node.kind === 201) { + ts.Debug.assert(node.parent.kind === 200); emitCaptureThisForNodeIfNecessary(node.parent); } emitLines(node.statements); - if (node.kind === 199) { + if (node.kind === 201) { emitTempDeclarations(true); } decreaseIndent(); @@ -19142,7 +19554,7 @@ var ts; scopeEmitEnd(); } function emitEmbeddedStatement(node) { - if (node.kind === 172) { + if (node.kind === 174) { write(" "); emit(node); } @@ -19154,7 +19566,7 @@ var ts; } } function emitExpressionStatement(node) { - emitParenthesized(node.expression, node.expression.kind === 159); + emitParenthesized(node.expression, node.expression.kind === 161); write(";"); } function emitIfStatement(node) { @@ -19167,7 +19579,7 @@ var ts; if (node.elseStatement) { writeLine(); emitToken(75, node.thenStatement.end); - if (node.elseStatement.kind === 176) { + if (node.elseStatement.kind === 178) { write(" "); emit(node.elseStatement); } @@ -19179,7 +19591,7 @@ var ts; function emitDoStatement(node) { write("do"); emitEmbeddedStatement(node.statement); - if (node.statement.kind === 172) { + if (node.statement.kind === 174) { write(" "); } else { @@ -19199,11 +19611,11 @@ var ts; var endPos = emitToken(81, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer && node.initializer.kind === 192) { + if (node.initializer && node.initializer.kind === 194) { var variableDeclarationList = node.initializer; var declarations = variableDeclarationList.declarations; if (declarations[0] && ts.isLet(declarations[0])) { - emitToken(103, endPos); + emitToken(105, endPos); } else if (declarations[0] && ts.isConst(declarations[0])) { emitToken(69, endPos); @@ -19228,12 +19640,12 @@ var ts; var endPos = emitToken(81, node.pos); write(" "); endPos = emitToken(16, endPos); - if (node.initializer.kind === 192) { + if (node.initializer.kind === 194) { var variableDeclarationList = node.initializer; if (variableDeclarationList.declarations.length >= 1) { var decl = variableDeclarationList.declarations[0]; if (ts.isLet(decl)) { - emitToken(103, endPos); + emitToken(105, endPos); } else { emitToken(97, endPos); @@ -19245,7 +19657,7 @@ var ts; else { emit(node.initializer); } - if (node.kind === 180) { + if (node.kind === 182) { write(" in "); } else { @@ -19256,7 +19668,7 @@ var ts; emitEmbeddedStatement(node.statement); } function emitBreakOrContinueStatement(node) { - emitToken(node.kind === 183 ? 65 : 70, node.pos); + emitToken(node.kind === 185 ? 65 : 70, node.pos); emitOptional(" ", node.label); write(";"); } @@ -19298,7 +19710,7 @@ var ts; getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node2.pos)); } function emitCaseOrDefaultClause(node) { - if (node.kind === 203) { + if (node.kind === 213) { write("case "); emit(node.expression); write(":"); @@ -19353,23 +19765,41 @@ var ts; function getContainingModule(node) { do { node = node.parent; - } while (node && node.kind !== 198); + } while (node && node.kind !== 200); return node; } + function emitContainingModuleName(node) { + var container = getContainingModule(node); + write(container ? resolver.getGeneratedNameForNode(container) : "exports"); + } function emitModuleMemberName(node) { emitStart(node.name); if (ts.getCombinedNodeFlags(node) & 1) { - var container = getContainingModule(node); - write(container ? resolver.getLocalNameOfContainer(container) : "exports"); + emitContainingModuleName(node); write("."); } emitNode(node.name); emitEnd(node.name); } + function emitExportMemberAssignments(name) { + if (exportSpecifiers && ts.hasProperty(exportSpecifiers, name.text)) { + ts.forEach(exportSpecifiers[name.text], function (specifier) { + writeLine(); + emitStart(specifier.name); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + emitEnd(specifier.name); + write(" = "); + emitNode(name); + write(";"); + }); + } + } function emitDestructuring(root, value) { var emitCount = 0; - var isDeclaration = (root.kind === 191 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 126; - if (root.kind === 165) { + var isDeclaration = (root.kind === 193 && !(ts.getCombinedNodeFlags(root) & 1)) || root.kind === 128; + if (root.kind === 167) { emitAssignmentExpression(root); } else { @@ -19379,7 +19809,7 @@ var ts; if (emitCount++) { write(", "); } - if (name.parent && (name.parent.kind === 191 || name.parent.kind === 148)) { + if (name.parent && (name.parent.kind === 193 || name.parent.kind === 150)) { emitModuleMemberName(name.parent); } else { @@ -19402,17 +19832,17 @@ var ts; function createVoidZero() { var zero = ts.createNode(7); zero.text = "0"; - var result = ts.createNode(162); + var result = ts.createNode(164); result.expression = zero; return result; } function createDefaultValueCheck(value, defaultValue) { value = ensureIdentifier(value); - var equals = ts.createNode(165); + var equals = ts.createNode(167); equals.left = value; equals.operatorToken = ts.createNode(30); equals.right = createVoidZero(); - var cond = ts.createNode(166); + var cond = ts.createNode(168); cond.condition = equals; cond.whenTrue = defaultValue; cond.whenFalse = value; @@ -19424,10 +19854,10 @@ var ts; return node; } function parenthesizeForAccess(expr) { - if (expr.kind === 64 || expr.kind === 151 || expr.kind === 152) { + if (expr.kind === 64 || expr.kind === 153 || expr.kind === 154) { return expr; } - var node = ts.createNode(157); + var node = ts.createNode(159); node.expression = expr; return node; } @@ -19435,13 +19865,13 @@ var ts; if (propName.kind !== 64) { return createElementAccess(object, propName); } - var node = ts.createNode(151); + var node = ts.createNode(153); node.expression = parenthesizeForAccess(object); node.name = propName; return node; } function createElementAccess(object, index) { - var node = ts.createNode(152); + var node = ts.createNode(154); node.expression = parenthesizeForAccess(object); node.argumentExpression = index; return node; @@ -19453,7 +19883,7 @@ var ts; } for (var i = 0; i < properties.length; i++) { var p = properties[i]; - if (p.kind === 207 || p.kind === 208) { + if (p.kind === 217 || p.kind === 218) { var propName = (p.name); emitDestructuringAssignment(p.initializer || propName, createPropertyAccess(value, propName)); } @@ -19466,8 +19896,8 @@ var ts; } for (var i = 0; i < elements.length; i++) { var e = elements[i]; - if (e.kind !== 170) { - if (e.kind !== 169) { + if (e.kind !== 172) { + if (e.kind !== 171) { emitDestructuringAssignment(e, createElementAccess(value, createNumericLiteral(i))); } else { @@ -19481,14 +19911,14 @@ var ts; } } function emitDestructuringAssignment(target, value) { - if (target.kind === 165 && target.operatorToken.kind === 52) { + if (target.kind === 167 && target.operatorToken.kind === 52) { value = createDefaultValueCheck(value, target.right); target = target.left; } - if (target.kind === 150) { + if (target.kind === 152) { emitObjectLiteralAssignment(target, value); } - else if (target.kind === 149) { + else if (target.kind === 151) { emitArrayLiteralAssignment(target, value); } else { @@ -19498,18 +19928,18 @@ var ts; function emitAssignmentExpression(root) { var target = root.left; var value = root.right; - if (root.parent.kind === 175) { + if (root.parent.kind === 177) { emitDestructuringAssignment(target, value); } else { - if (root.parent.kind !== 157) { + if (root.parent.kind !== 159) { write("("); } value = ensureIdentifier(value); emitDestructuringAssignment(target, value); write(", "); emit(value); - if (root.parent.kind !== 157) { + if (root.parent.kind !== 159) { write(")"); } } @@ -19529,11 +19959,11 @@ var ts; } for (var i = 0; i < elements.length; i++) { var element = elements[i]; - if (pattern.kind === 146) { + if (pattern.kind === 148) { var propName = element.propertyName || element.name; emitBindingElement(element, createPropertyAccess(value, propName)); } - else if (element.kind !== 170) { + else if (element.kind !== 172) { if (!element.dotDotDotToken) { emitBindingElement(element, createElementAccess(value, createNumericLiteral(i))); } @@ -19567,6 +19997,15 @@ var ts; emitOptional(" = ", node.initializer); } } + function emitExportVariableAssignments(node) { + var name = node.name; + if (name.kind === 64) { + emitExportMemberAssignments(name); + } + else if (ts.isBindingPattern(name)) { + ts.forEach(name.elements, emitExportVariableAssignments); + } + } function emitVariableStatement(node) { if (!(node.flags & 1)) { if (ts.isLet(node.declarationList)) { @@ -19581,6 +20020,9 @@ var ts; } emitCommaList(node.declarationList.declarations); write(";"); + if (languageVersion < 2 && node.parent === currentSourceFile) { + ts.forEach(node.declarationList.declarations, emitExportVariableAssignments); + } } function emitParameter(node) { if (languageVersion < 2) { @@ -19672,28 +20114,31 @@ var ts; } } function emitAccessor(node) { - write(node.kind === 132 ? "get " : "set "); + write(node.kind === 134 ? "get " : "set "); emit(node.name); emitSignatureAndBody(node); } function shouldEmitAsArrowFunction(node) { - return node.kind === 159 && languageVersion >= 2; + return node.kind === 161 && languageVersion >= 2; } function emitFunctionDeclaration(node) { if (ts.nodeIsMissing(node.body)) { return emitPinnedOrTripleSlashComments(node); } - if (node.kind !== 130 && node.kind !== 129) { + if (node.kind !== 132 && node.kind !== 131) { emitLeadingComments(node); } if (!shouldEmitAsArrowFunction(node)) { write("function "); } - if (node.kind === 193 || (node.kind === 158 && node.name)) { + if (node.kind === 195 || (node.kind === 160 && node.name)) { emit(node.name); } emitSignatureAndBody(node); - if (node.kind !== 130 && node.kind !== 129) { + if (languageVersion < 2 && node.kind === 195 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + if (node.kind !== 132 && node.kind !== 131) { emitTrailingComments(node); } } @@ -19737,10 +20182,10 @@ var ts; else { emitSignatureParameters(node); } - if (isSingleLineEmptyBlock(node.body) || !node.body) { + if (!node.body) { write(" { }"); } - else if (node.body.kind === 172) { + else if (node.body.kind === 174) { emitBlockFunctionBody(node, node.body); } else { @@ -19765,6 +20210,14 @@ var ts; emitRestParameter(node); } function emitExpressionFunctionBody(node, body) { + if (languageVersion < 2) { + emitDownLevelExpressionFunctionBody(node, body); + return; + } + write(" "); + emit(body); + } + function emitDownLevelExpressionFunctionBody(node, body) { write(" {"); scopeEmitStart(node); increaseIndent(); @@ -19801,6 +20254,36 @@ var ts; scopeEmitEnd(); } function emitBlockFunctionBody(node, body) { + if (body.statements.length === 0 && !anyParameterHasBindingPatternOrInitializer(node)) { + emitFunctionBodyWithNoStatements(node, body); + } + else { + emitFunctionBodyWithStatements(node, body); + } + } + function anyParameterHasBindingPatternOrInitializer(func) { + return ts.forEach(func.parameters, hasBindingPatternOrInitializer); + } + function hasBindingPatternOrInitializer(parameter) { + return parameter.initializer || ts.isBindingPattern(parameter.name); + } + function emitFunctionBodyWithNoStatements(node, body) { + var singleLine = isSingleLineEmptyBlock(node.body); + write(" {"); + if (singleLine) { + write(" "); + } + else { + increaseIndent(); + writeLine(); + } + emitLeadingCommentsOfPosition(body.statements.end); + if (!singleLine) { + decreaseIndent(); + } + emitToken(15, body.statements.end); + } + function emitFunctionBodyWithStatements(node, body) { write(" {"); scopeEmitStart(node); var outPos = writer.getTextPos(); @@ -19833,9 +20316,9 @@ var ts; function findInitialSuperCall(ctor) { if (ctor.body) { var statement = ctor.body.statements[0]; - if (statement && statement.kind === 175) { + if (statement && statement.kind === 177) { var expr = statement.expression; - if (expr && expr.kind === 153) { + if (expr && expr.kind === 155) { var func = expr.expression; if (func && func.kind === 90) { return statement; @@ -19866,7 +20349,7 @@ var ts; emitNode(memberName); write("]"); } - else if (memberName.kind === 124) { + else if (memberName.kind === 126) { emitComputedPropertyName(memberName); } else { @@ -19876,7 +20359,7 @@ var ts; } function emitMemberAssignments(node, staticFlag) { ts.forEach(node.members, function (member) { - if (member.kind === 128 && (member.flags & 128) === staticFlag && member.initializer) { + if (member.kind === 130 && (member.flags & 128) === staticFlag && member.initializer) { writeLine(); emitLeadingComments(member); emitStart(member); @@ -19899,7 +20382,7 @@ var ts; } function emitMemberFunctions(node) { ts.forEach(node.members, function (member) { - if (member.kind === 130 || node.kind === 129) { + if (member.kind === 132 || node.kind === 131) { if (!member.body) { return emitPinnedOrTripleSlashComments(member); } @@ -19921,7 +20404,7 @@ var ts; write(";"); emitTrailingComments(member); } - else if (member.kind === 132 || member.kind === 133) { + else if (member.kind === 134 || member.kind === 135) { var accessors = getAllAccessorDeclarations(node.members, member); if (member === accessors.firstAccessor) { writeLine(); @@ -20021,6 +20504,9 @@ var ts; emitEnd(node); write(";"); } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } function emitConstructorOfClass() { var saveTempCount = tempCount; var saveTempVariables = tempVariables; @@ -20029,7 +20515,7 @@ var ts; tempVariables = undefined; tempParameters = undefined; ts.forEach(node.members, function (member) { - if (member.kind === 131 && !member.body) { + if (member.kind === 133 && !member.body) { emitPinnedOrTripleSlashComments(member); } }); @@ -20114,7 +20600,7 @@ var ts; emitStart(node); write("(function ("); emitStart(node.name); - write(resolver.getLocalNameOfContainer(node)); + write(resolver.getGeneratedNameForNode(node)); emitEnd(node.name); write(") {"); increaseIndent(); @@ -20140,13 +20626,16 @@ var ts; emitEnd(node); write(";"); } + if (languageVersion < 2 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } } function emitEnumMember(node) { var enumParent = node.parent; emitStart(node); - write(resolver.getLocalNameOfContainer(enumParent)); + write(resolver.getGeneratedNameForNode(enumParent)); write("["); - write(resolver.getLocalNameOfContainer(enumParent)); + write(resolver.getGeneratedNameForNode(enumParent)); write("["); emitExpressionForPropertyName(node.name); write("] = "); @@ -20172,7 +20661,7 @@ var ts; } } function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { - if (moduleDeclaration.body.kind === 198) { + if (moduleDeclaration.body.kind === 200) { var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); return recursiveInnerModule || moduleDeclaration.body; } @@ -20194,10 +20683,10 @@ var ts; emitStart(node); write("(function ("); emitStart(node.name); - write(resolver.getLocalNameOfContainer(node)); + write(resolver.getGeneratedNameForNode(node)); emitEnd(node.name); write(") "); - if (node.body.kind === 199) { + if (node.body.kind === 201) { var saveTempCount = tempCount; var saveTempVariables = tempVariables; tempCount = 0; @@ -20229,63 +20718,194 @@ var ts; emitModuleMemberName(node); write(" = {}));"); emitEnd(node); + if (languageVersion < 2 && node.name.kind === 64 && node.parent === currentSourceFile) { + emitExportMemberAssignments(node.name); + } + } + function emitRequire(moduleName) { + if (moduleName.kind === 8) { + write("require("); + emitStart(moduleName); + emitLiteral(moduleName); + emitEnd(moduleName); + emitToken(17, moduleName.end); + write(";"); + } + else { + write("require();"); + } } function emitImportDeclaration(node) { - var emitImportDeclaration = resolver.isReferencedImportDeclaration(node); - if (!emitImportDeclaration) { - emitImportDeclaration = !ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportWithEntityName(node); - } - if (emitImportDeclaration) { - if (ts.isExternalModuleImportDeclaration(node) && node.parent.kind === 210 && compilerOptions.module === 2) { - if (node.flags & 1) { - writeLine(); - emitLeadingComments(node); - emitStart(node); - emitModuleMemberName(node); - write(" = "); - emit(node.name); - write(";"); - emitEnd(node); - emitTrailingComments(node); - } - } - else { - writeLine(); + var info = getExternalImportInfo(node); + if (info) { + var declarationNode = info.declarationNode; + var namedImports = info.namedImports; + if (compilerOptions.module !== 2) { emitLeadingComments(node); emitStart(node); - if (!(node.flags & 1)) + var moduleName = ts.getExternalModuleName(node); + if (declarationNode) { + if (!(declarationNode.flags & 1)) + write("var "); + emitModuleMemberName(declarationNode); + write(" = "); + emitRequire(moduleName); + } + else if (namedImports) { write("var "); - emitModuleMemberName(node); - write(" = "); - if (ts.isInternalModuleImportDeclaration(node)) { - emit(node.moduleReference); + write(resolver.getGeneratedNameForNode(node)); + write(" = "); + emitRequire(moduleName); } else { - var literal = ts.getExternalModuleImportDeclarationExpression(node); - write("require("); - emitStart(literal); - emitLiteral(literal); - emitEnd(literal); - emitToken(17, literal.end); + emitRequire(moduleName); } - write(";"); emitEnd(node); emitTrailingComments(node); } + else { + if (declarationNode) { + if (declarationNode.flags & 1) { + emitModuleMemberName(declarationNode); + write(" = "); + emit(declarationNode.name); + write(";"); + } + } + } } } - function getExternalImportDeclarations(node) { - var result = []; - ts.forEach(node.statements, function (statement) { - if (ts.isExternalModuleImportDeclaration(statement) && resolver.isReferencedImportDeclaration(statement)) { - result.push(statement); + function emitImportEqualsDeclaration(node) { + if (ts.isExternalModuleImportEqualsDeclaration(node)) { + emitImportDeclaration(node); + return; + } + if (resolver.isReferencedImportDeclaration(node) || + (!ts.isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node))) { + emitLeadingComments(node); + emitStart(node); + if (!(node.flags & 1)) + write("var "); + emitModuleMemberName(node); + write(" = "); + emit(node.moduleReference); + write(";"); + emitEnd(node); + emitTrailingComments(node); + } + } + function emitExportDeclaration(node) { + if (node.moduleSpecifier) { + emitStart(node); + var generatedName = resolver.getGeneratedNameForNode(node); + if (compilerOptions.module !== 2) { + write("var "); + write(generatedName); + write(" = "); + emitRequire(ts.getExternalModuleName(node)); + } + if (node.exportClause) { + ts.forEach(node.exportClause.elements, function (specifier) { + writeLine(); + emitStart(specifier); + emitContainingModuleName(specifier); + write("."); + emitNode(specifier.name); + write(" = "); + write(generatedName); + write("."); + emitNode(specifier.propertyName || specifier.name); + write(";"); + emitEnd(specifier); + }); + } + else { + var tempName = createTempVariable(node).text; + writeLine(); + write("for (var " + tempName + " in " + generatedName + ") if (!"); + emitContainingModuleName(node); + write(".hasOwnProperty(" + tempName + ")) "); + emitContainingModuleName(node); + write("[" + tempName + "] = " + generatedName + "[" + tempName + "];"); + } + emitEnd(node); + } + } + function createExternalImportInfo(node) { + if (node.kind === 202) { + if (node.moduleReference.kind === 212) { + return { + rootNode: node, + declarationNode: node + }; + } + } + else if (node.kind === 203) { + var importClause = node.importClause; + if (importClause) { + if (importClause.name) { + return { + rootNode: node, + declarationNode: importClause + }; + } + if (importClause.namedBindings.kind === 205) { + return { + rootNode: node, + declarationNode: importClause.namedBindings + }; + } + return { + rootNode: node, + namedImports: importClause.namedBindings, + localName: resolver.getGeneratedNameForNode(node) + }; + } + return { + rootNode: node + }; + } + else if (node.kind === 209) { + if (node.moduleSpecifier) { + return { + rootNode: node + }; + } + } + } + function createExternalModuleInfo(sourceFile) { + externalImports = []; + exportSpecifiers = {}; + ts.forEach(sourceFile.statements, function (node) { + if (node.kind === 209 && !node.moduleSpecifier) { + ts.forEach(node.exportClause.elements, function (specifier) { + var name = (specifier.propertyName || specifier.name).text; + (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier); + }); + } + else { + var info = createExternalImportInfo(node); + if (info) { + if ((!info.declarationNode && !info.namedImports) || resolver.isReferencedImportDeclaration(node)) { + externalImports.push(info); + } + } } }); - return result; + } + function getExternalImportInfo(node) { + if (externalImports) { + for (var i = 0; i < externalImports.length; i++) { + var info = externalImports[i]; + if (info.rootNode === node) { + return info; + } + } + } } function getFirstExportAssignment(sourceFile) { return ts.forEach(sourceFile.statements, function (node) { - if (node.kind === 201) { + if (node.kind === 208) { return node; } }); @@ -20304,7 +20924,6 @@ var ts; }); } function emitAMDModule(node, startIndex) { - var imports = getExternalImportDeclarations(node); writeLine(); write("define("); sortAMDModules(node.amdDependencies); @@ -20312,9 +20931,15 @@ var ts; write("\"" + node.amdModuleName + "\", "); } write("[\"require\", \"exports\""); - ts.forEach(imports, function (imp) { + ts.forEach(externalImports, function (info) { write(", "); - emitLiteral(ts.getExternalModuleImportDeclarationExpression(imp)); + var moduleName = ts.getExternalModuleName(info.rootNode); + if (moduleName.kind === 8) { + emitLiteral(moduleName); + } + else { + write("\"\""); + } }); ts.forEach(node.amdDependencies, function (amdDependency) { var text = "\"" + amdDependency.path + "\""; @@ -20322,9 +20947,14 @@ var ts; write(text); }); write("], function (require, exports"); - ts.forEach(imports, function (imp) { + ts.forEach(externalImports, function (info) { write(", "); - emit(imp.name); + if (info.declarationNode) { + emit(info.declarationNode.name); + } + else { + write(resolver.getGeneratedNameForNode(info.rootNode)); + } }); ts.forEach(node.amdDependencies, function (amdDependency) { if (amdDependency.name) { @@ -20407,6 +21037,7 @@ var ts; extendsEmitted = true; } if (ts.isExternalModule(node)) { + createExternalModuleInfo(node); if (compilerOptions.module === 2) { emitAMDModule(node, startIndex); } @@ -20415,6 +21046,8 @@ var ts; } } else { + externalImports = undefined; + exportSpecifiers = undefined; emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); emitTempDeclarations(true); @@ -20439,15 +21072,16 @@ var ts; } function shouldEmitLeadingAndTrailingComments(node) { switch (node.kind) { - case 195: - case 193: - case 200: - case 196: - case 201: - return false; - case 198: - return shouldEmitModuleDeclaration(node); case 197: + case 195: + case 203: + case 202: + case 198: + case 208: + return false; + case 200: + return shouldEmitModuleDeclaration(node); + case 199: return shouldEmitEnumDeclaration(node); } return true; @@ -20456,13 +21090,13 @@ var ts; switch (node.kind) { case 64: return emitIdentifier(node); - case 126: + case 128: return emitParameter(node); - case 130: - case 129: - return emitMethod(node); case 132: - case 133: + case 131: + return emitMethod(node); + case 134: + case 135: return emitAccessor(node); case 92: return emitThis(node); @@ -20482,121 +21116,125 @@ var ts; case 12: case 13: return emitLiteral(node); - case 167: - return emitTemplateExpression(node); - case 171: - return emitTemplateSpan(node); - case 123: - return emitQualifiedName(node); - case 146: - return emitObjectBindingPattern(node); - case 147: - return emitArrayBindingPattern(node); - case 148: - return emitBindingElement(node); - case 149: - return emitArrayLiteral(node); - case 150: - return emitObjectLiteral(node); - case 207: - return emitPropertyAssignment(node); - case 208: - return emitShorthandPropertyAssignment(node); - case 124: - return emitComputedPropertyName(node); - case 151: - return emitPropertyAccess(node); - case 152: - return emitIndexedAccess(node); - case 153: - return emitCallExpression(node); - case 154: - return emitNewExpression(node); - case 155: - return emitTaggedTemplateExpression(node); - case 156: - return emit(node.expression); - case 157: - return emitParenExpression(node); - case 193: - case 158: - case 159: - return emitFunctionDeclaration(node); - case 160: - return emitDeleteExpression(node); - case 161: - return emitTypeOfExpression(node); - case 162: - return emitVoidExpression(node); - case 163: - return emitPrefixUnaryExpression(node); - case 164: - return emitPostfixUnaryExpression(node); - case 165: - return emitBinaryExpression(node); - case 166: - return emitConditionalExpression(node); case 169: - return emitSpreadElementExpression(node); - case 170: - return; - case 172: - case 199: - return emitBlock(node); + return emitTemplateExpression(node); case 173: - return emitVariableStatement(node); - case 174: - return write(";"); - case 175: - return emitExpressionStatement(node); - case 176: - return emitIfStatement(node); - case 177: - return emitDoStatement(node); - case 178: - return emitWhileStatement(node); - case 179: - return emitForStatement(node); - case 181: - case 180: - return emitForInOrForOfStatement(node); - case 182: - case 183: - return emitBreakOrContinueStatement(node); - case 184: - return emitReturnStatement(node); - case 185: - return emitWithStatement(node); - case 186: - return emitSwitchStatement(node); - case 203: - case 204: - return emitCaseOrDefaultClause(node); - case 187: - return emitLabelledStatement(node); - case 188: - return emitThrowStatement(node); - case 189: - return emitTryStatement(node); - case 206: - return emitCatchClause(node); - case 190: - return emitDebuggerStatement(node); - case 191: - return emitVariableDeclaration(node); - case 194: - return emitClassDeclaration(node); + return emitTemplateSpan(node); + case 125: + return emitQualifiedName(node); + case 148: + return emitObjectBindingPattern(node); + case 149: + return emitArrayBindingPattern(node); + case 150: + return emitBindingElement(node); + case 151: + return emitArrayLiteral(node); + case 152: + return emitObjectLiteral(node); + case 217: + return emitPropertyAssignment(node); + case 218: + return emitShorthandPropertyAssignment(node); + case 126: + return emitComputedPropertyName(node); + case 153: + return emitPropertyAccess(node); + case 154: + return emitIndexedAccess(node); + case 155: + return emitCallExpression(node); + case 156: + return emitNewExpression(node); + case 157: + return emitTaggedTemplateExpression(node); + case 158: + return emit(node.expression); + case 159: + return emitParenExpression(node); case 195: - return emitInterfaceDeclaration(node); + case 160: + case 161: + return emitFunctionDeclaration(node); + case 162: + return emitDeleteExpression(node); + case 163: + return emitTypeOfExpression(node); + case 164: + return emitVoidExpression(node); + case 165: + return emitPrefixUnaryExpression(node); + case 166: + return emitPostfixUnaryExpression(node); + case 167: + return emitBinaryExpression(node); + case 168: + return emitConditionalExpression(node); + case 171: + return emitSpreadElementExpression(node); + case 172: + return; + case 174: + case 201: + return emitBlock(node); + case 175: + return emitVariableStatement(node); + case 176: + return write(";"); + case 177: + return emitExpressionStatement(node); + case 178: + return emitIfStatement(node); + case 179: + return emitDoStatement(node); + case 180: + return emitWhileStatement(node); + case 181: + return emitForStatement(node); + case 183: + case 182: + return emitForInOrForOfStatement(node); + case 184: + case 185: + return emitBreakOrContinueStatement(node); + case 186: + return emitReturnStatement(node); + case 187: + return emitWithStatement(node); + case 188: + return emitSwitchStatement(node); + case 213: + case 214: + return emitCaseOrDefaultClause(node); + case 189: + return emitLabelledStatement(node); + case 190: + return emitThrowStatement(node); + case 191: + return emitTryStatement(node); + case 216: + return emitCatchClause(node); + case 192: + return emitDebuggerStatement(node); + case 193: + return emitVariableDeclaration(node); + case 196: + return emitClassDeclaration(node); case 197: + return emitInterfaceDeclaration(node); + case 199: return emitEnumDeclaration(node); - case 209: + case 219: return emitEnumMember(node); - case 198: - return emitModuleDeclaration(node); case 200: + return emitModuleDeclaration(node); + case 203: return emitImportDeclaration(node); - case 210: + case 202: + return emitImportEqualsDeclaration(node); + case 209: + return emitExportDeclaration(node); + case 220: return emitSourceFile(node); } } @@ -20615,7 +21253,7 @@ var ts; } function getLeadingCommentsToEmit(node) { if (node.parent) { - if (node.parent.kind === 210 || node.pos !== node.parent.pos) { + if (node.parent.kind === 220 || node.pos !== node.parent.pos) { var leadingComments; if (hasDetachedComments(node.pos)) { leadingComments = getLeadingCommentsWithoutDetachedComments(); @@ -20634,7 +21272,7 @@ var ts; } function emitTrailingDeclarationComments(node) { if (node.parent) { - if (node.parent.kind === 210 || node.end !== node.parent.end) { + if (node.parent.kind === 220 || node.end !== node.parent.end) { var trailingComments = ts.getTrailingCommentRanges(currentSourceFile.text, node.end); emitComments(currentSourceFile, writer, trailingComments, false, newLine, writeComment); } @@ -21014,30 +21652,31 @@ var ts; } function processImportedModules(file, basePath) { ts.forEach(file.statements, function (node) { - if (ts.isExternalModuleImportDeclaration(node) && - ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - var nameLiteral = ts.getExternalModuleImportDeclarationExpression(node); - var moduleName = nameLiteral.text; - if (moduleName) { - var searchPath = basePath; - while (true) { - var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleName)); - if (findModuleSourceFile(searchName + ".ts", nameLiteral) || findModuleSourceFile(searchName + ".d.ts", nameLiteral)) { - break; + if (node.kind === 203 || node.kind === 202 || node.kind === 209) { + var moduleNameExpr = ts.getExternalModuleName(node); + if (moduleNameExpr && moduleNameExpr.kind === 8) { + var moduleNameText = moduleNameExpr.text; + if (moduleNameText) { + var searchPath = basePath; + while (true) { + var searchName = ts.normalizePath(ts.combinePaths(searchPath, moduleNameText)); + if (findModuleSourceFile(searchName + ".ts", moduleNameExpr) || findModuleSourceFile(searchName + ".d.ts", moduleNameExpr)) { + break; + } + var parentPath = ts.getDirectoryPath(searchPath); + if (parentPath === searchPath) { + break; + } + searchPath = parentPath; } - var parentPath = ts.getDirectoryPath(searchPath); - if (parentPath === searchPath) { - break; - } - searchPath = parentPath; } } } - else if (node.kind === 198 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { + else if (node.kind === 200 && node.name.kind === 8 && (node.flags & 2 || ts.isDeclarationFile(file))) { ts.forEachChild(node.body, function (node) { - if (ts.isExternalModuleImportDeclaration(node) && - ts.getExternalModuleImportDeclarationExpression(node).kind === 8) { - var nameLiteral = ts.getExternalModuleImportDeclarationExpression(node); + if (ts.isExternalModuleImportEqualsDeclaration(node) && + ts.getExternalModuleImportEqualsDeclarationExpression(node).kind === 8) { + var nameLiteral = ts.getExternalModuleImportEqualsDeclarationExpression(node); var moduleName = nameLiteral.text; if (moduleName) { var searchName = ts.normalizePath(ts.combinePaths(basePath, moduleName)); @@ -21474,14 +22113,7 @@ var ts; } } function autoCollapse(node) { - switch (node.kind) { - case 199: - case 194: - case 195: - case 197: - return false; - } - return true; + return ts.isFunctionBlock(node) && node.parent.kind !== 161; } var depth = 0; var maxDepth = 20; @@ -21490,23 +22122,23 @@ var ts; return; } switch (n.kind) { - case 172: + case 174: if (!ts.isFunctionBlock(n)) { var parent = n.parent; var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); - if (parent.kind === 177 || - parent.kind === 180 || + if (parent.kind === 179 || + parent.kind === 182 || + parent.kind === 183 || parent.kind === 181 || - parent.kind === 179 || - parent.kind === 176 || parent.kind === 178 || - parent.kind === 185 || - parent.kind === 206) { + parent.kind === 180 || + parent.kind === 187 || + parent.kind === 216) { addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n)); break; } - if (parent.kind === 189) { + if (parent.kind === 191) { var tryStatement = parent; if (tryStatement.tryBlock === n) { addOutliningSpan(parent, openBrace, closeBrace, autoCollapse(n)); @@ -21529,21 +22161,21 @@ var ts; }); break; } - case 199: + case 201: var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n.parent, openBrace, closeBrace, autoCollapse(n)); break; - case 194: - case 195: + case 196: case 197: - case 150: - case 186: + case 199: + case 152: + case 188: var openBrace = ts.findChildOfKind(n, 14, sourceFile); var closeBrace = ts.findChildOfKind(n, 15, sourceFile); addOutliningSpan(n, openBrace, closeBrace, autoCollapse(n)); break; - case 149: + case 151: var openBracket = ts.findChildOfKind(n, 18, sourceFile); var closeBracket = ts.findChildOfKind(n, 19, sourceFile); addOutliningSpan(n, openBracket, closeBracket, autoCollapse(n)); @@ -21563,27 +22195,33 @@ var ts; (function (ts) { var NavigateTo; (function (NavigateTo) { - var MatchKind; - (function (MatchKind) { - MatchKind[MatchKind["none"] = 0] = "none"; - MatchKind[MatchKind["exact"] = 1] = "exact"; - MatchKind[MatchKind["substring"] = 2] = "substring"; - MatchKind[MatchKind["prefix"] = 3] = "prefix"; - })(MatchKind || (MatchKind = {})); function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) { - var terms = searchValue.split(" "); - var searchTerms = ts.map(terms, function (t) { return ({ caseSensitive: hasAnyUpperCaseCharacter(t), term: t }); }); + var patternMatcher = ts.createPatternMatcher(searchValue); var rawItems = []; ts.forEach(program.getSourceFiles(), function (sourceFile) { cancellationToken.throwIfCancellationRequested(); - var fileName = sourceFile.fileName; var declarations = sourceFile.getNamedDeclarations(); for (var i = 0, n = declarations.length; i < n; i++) { var declaration = declarations[i]; - var name = declaration.name.text; - var matchKind = getMatchKind(searchTerms, name); - if (matchKind !== 0) { - rawItems.push({ name: name, fileName: fileName, matchKind: matchKind, declaration: declaration }); + var name = getDeclarationName(declaration); + if (name !== undefined) { + var matches = patternMatcher.getMatchesForLastSegmentOfPattern(name); + if (!matches) { + continue; + } + if (patternMatcher.patternContainsDots) { + var containers = getContainers(declaration); + if (!containers) { + return undefined; + } + matches = patternMatcher.getMatches(containers, name); + if (!matches) { + continue; + } + } + var fileName = sourceFile.fileName; + var matchKind = bestMatchKind(matches); + rawItems.push({ name: name, fileName: fileName, matchKind: matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration: declaration }); } } }); @@ -21593,6 +22231,96 @@ var ts; } var items = ts.map(rawItems, createNavigateToItem); return items; + function allMatchesAreCaseSensitive(matches) { + ts.Debug.assert(matches.length > 0); + for (var i = 0, n = matches.length; i < n; i++) { + if (!matches[i].isCaseSensitive) { + return false; + } + } + return true; + } + function getDeclarationName(declaration) { + var result = getTextOfIdentifierOrLiteral(declaration.name); + if (result !== undefined) { + return result; + } + if (declaration.name.kind === 126) { + var expr = declaration.name.expression; + if (expr.kind === 153) { + return expr.name.text; + } + return getTextOfIdentifierOrLiteral(expr); + } + return undefined; + } + function getTextOfIdentifierOrLiteral(node) { + if (node.kind === 64 || + node.kind === 8 || + node.kind === 7) { + return node.text; + } + return undefined; + } + function tryAddSingleDeclarationName(declaration, containers) { + if (declaration && declaration.name) { + var text = getTextOfIdentifierOrLiteral(declaration.name); + if (text !== undefined) { + containers.unshift(text); + } + else if (declaration.name.kind === 126) { + return tryAddComputedPropertyName(declaration.name.expression, containers, true); + } + else { + return false; + } + } + return true; + } + function tryAddComputedPropertyName(expression, containers, includeLastPortion) { + var text = getTextOfIdentifierOrLiteral(expression); + if (text !== undefined) { + if (includeLastPortion) { + containers.unshift(text); + } + return true; + } + if (expression.kind === 153) { + var propertyAccess = expression; + if (includeLastPortion) { + containers.unshift(propertyAccess.name.text); + } + return tryAddComputedPropertyName(propertyAccess.expression, containers, true); + } + return false; + } + function getContainers(declaration) { + var containers = []; + if (declaration.name.kind === 126) { + if (!tryAddComputedPropertyName(declaration.name.expression, containers, false)) { + return undefined; + } + } + declaration = ts.getContainerNode(declaration); + while (declaration) { + if (!tryAddSingleDeclarationName(declaration, containers)) { + return undefined; + } + declaration = ts.getContainerNode(declaration); + } + return containers; + } + function bestMatchKind(matches) { + ts.Debug.assert(matches.length > 0); + var bestMatchKind = 3; + for (var i = 0, n = matches.length; i < n; i++) { + var kind = matches[i].kind; + if (kind < bestMatchKind) { + bestMatchKind = kind; + } + } + return bestMatchKind; + } var baseSensitivity = { sensitivity: "base" }; function compareNavigateToItems(i1, i2) { return i1.matchKind - i2.matchKind || @@ -21606,44 +22334,14 @@ var ts; name: rawItem.name, kind: ts.getNodeKind(declaration), kindModifiers: ts.getNodeModifiers(declaration), - matchKind: MatchKind[rawItem.matchKind], + matchKind: ts.PatternMatchKind[rawItem.matchKind], + isCaseSensitive: rawItem.isCaseSensitive, fileName: rawItem.fileName, textSpan: ts.createTextSpanFromBounds(declaration.getStart(), declaration.getEnd()), containerName: container && container.name ? container.name.text : "", containerKind: container && container.name ? ts.getNodeKind(container) : "" }; } - function hasAnyUpperCaseCharacter(s) { - for (var i = 0, n = s.length; i < n; i++) { - var c = s.charCodeAt(i); - if ((65 <= c && c <= 90) || - (c >= 127 && s.charAt(i).toLocaleLowerCase() !== s.charAt(i))) { - return true; - } - } - return false; - } - function getMatchKind(searchTerms, name) { - var matchKind = 0; - if (name) { - for (var j = 0, n = searchTerms.length; j < n; j++) { - var searchTerm = searchTerms[j]; - var nameToSearch = searchTerm.caseSensitive ? name : name.toLocaleLowerCase(); - var index = nameToSearch.indexOf(searchTerm.term); - if (index < 0) { - return 0; - } - var termKind = 2; - if (index === 0) { - termKind = name.length === searchTerm.term.length ? 1 : 3; - } - if (matchKind === 0 || termKind < matchKind) { - matchKind = termKind; - } - } - } - return matchKind; - } } NavigateTo.getNavigateToItems = getNavigateToItems; })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {})); @@ -21660,14 +22358,14 @@ var ts; var current = node.parent; while (current) { switch (current.kind) { - case 198: + case 200: do { current = current.parent; - } while (current.kind === 198); - case 194: + } while (current.kind === 200); + case 196: + case 199: case 197: case 195: - case 193: indent++; } current = current.parent; @@ -21678,24 +22376,24 @@ var ts; var childNodes = []; function visit(node) { switch (node.kind) { - case 173: + case 175: ts.forEach(node.declarationList.declarations, visit); break; - case 146: - case 147: + case 148: + case 149: ts.forEach(node.elements, visit); break; - case 148: - case 191: + case 150: + case 193: if (ts.isBindingPattern(node.name)) { visit(node.name); break; } - case 194: + case 196: + case 199: case 197: + case 200: case 195: - case 198: - case 193: childNodes.push(node); } } @@ -21729,17 +22427,17 @@ var ts; for (var i = 0, n = nodes.length; i < n; i++) { var node = nodes[i]; switch (node.kind) { - case 194: + case 196: + case 199: case 197: - case 195: topLevelNodes.push(node); break; - case 198: + case 200: var moduleDeclaration = node; topLevelNodes.push(node); addTopLevelNodes(getInnermostModule(moduleDeclaration).body.statements, topLevelNodes); break; - case 193: + case 195: var functionDeclaration = node; if (isTopLevelFunctionDeclaration(functionDeclaration)) { topLevelNodes.push(node); @@ -21750,9 +22448,9 @@ var ts; } } function isTopLevelFunctionDeclaration(functionDeclaration) { - if (functionDeclaration.kind === 193) { - if (functionDeclaration.body && functionDeclaration.body.kind === 172) { - if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 193 && !isEmpty(s.name.text); })) { + if (functionDeclaration.kind === 195) { + if (functionDeclaration.body && functionDeclaration.body.kind === 174) { + if (ts.forEach(functionDeclaration.body.statements, function (s) { return s.kind === 195 && !isEmpty(s.name.text); })) { return true; } if (!ts.isFunctionBlock(functionDeclaration.parent)) { @@ -21805,7 +22503,7 @@ var ts; } function createChildItem(node) { switch (node.kind) { - case 126: + case 128: if (ts.isBindingPattern(node.name)) { break; } @@ -21813,34 +22511,34 @@ var ts; return undefined; } return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 132: + case 131: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); + case 134: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); + case 135: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); + case 138: + return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); + case 219: + return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); + case 136: + return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); + case 137: + return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); case 130: case 129: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberFunctionElement); - case 132: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberGetAccessorElement); - case 133: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberSetAccessorElement); - case 136: - return createItem(node, "[]", ts.ScriptElementKind.indexSignatureElement); - case 209: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 134: - return createItem(node, "()", ts.ScriptElementKind.callSignatureElement); - case 135: - return createItem(node, "new()", ts.ScriptElementKind.constructSignatureElement); - case 128: - case 127: - return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement); - case 193: + case 195: return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.functionElement); - case 191: - case 148: + case 193: + case 150: var variableDeclarationNode; var name; - if (node.kind === 148) { + if (node.kind === 150) { name = node.name; variableDeclarationNode = node; - while (variableDeclarationNode && variableDeclarationNode.kind !== 191) { + while (variableDeclarationNode && variableDeclarationNode.kind !== 193) { variableDeclarationNode = variableDeclarationNode.parent; } ts.Debug.assert(variableDeclarationNode !== undefined); @@ -21859,7 +22557,7 @@ var ts; else { return createItem(node, getTextOfNode(name), ts.ScriptElementKind.variableElement); } - case 131: + case 133: return createItem(node, "constructor", ts.ScriptElementKind.constructorImplementationElement); } return undefined; @@ -21889,17 +22587,17 @@ var ts; } function createTopLevelItem(node) { switch (node.kind) { - case 210: + case 220: return createSourceFileItem(node); - case 194: + case 196: return createClassItem(node); - case 197: + case 199: return createEnumItem(node); - case 195: + case 197: return createIterfaceItem(node); - case 198: + case 200: return createModuleItem(node); - case 193: + case 195: return createFunctionItem(node); } return undefined; @@ -21909,7 +22607,7 @@ var ts; } var result = []; result.push(moduleDeclaration.name.text); - while (moduleDeclaration.body && moduleDeclaration.body.kind === 198) { + while (moduleDeclaration.body && moduleDeclaration.body.kind === 200) { moduleDeclaration = moduleDeclaration.body; result.push(moduleDeclaration.name.text); } @@ -21921,7 +22619,7 @@ var ts; return getNavigationBarItem(moduleName, ts.ScriptElementKind.moduleElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } function createFunctionItem(node) { - if (node.name && node.body && node.body.kind === 172) { + if (node.name && node.body && node.body.kind === 174) { var childItems = getItemsWorker(sortNodes(node.body.statements), createChildItem); return getNavigationBarItem(node.name.text, ts.ScriptElementKind.functionElement, ts.getNodeModifiers(node), [getNodeSpan(node)], childItems, getIndent(node)); } @@ -21940,11 +22638,11 @@ var ts; var childItems; if (node.members) { var constructor = ts.forEach(node.members, function (member) { - return member.kind === 131 && member; + return member.kind === 133 && member; }); var nodes = removeDynamicallyNamedProperties(node); if (constructor) { - nodes.push.apply(nodes, constructor.parameters); + nodes.push.apply(nodes, ts.filter(constructor.parameters, function (p) { return !ts.isBindingPattern(p.name); })); } var childItems = getItemsWorker(sortNodes(nodes), createChildItem); } @@ -21960,19 +22658,19 @@ var ts; } } function removeComputedProperties(node) { - return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 124; }); + return ts.filter(node.members, function (member) { return member.name === undefined || member.name.kind !== 126; }); } function removeDynamicallyNamedProperties(node) { return ts.filter(node.members, function (member) { return !ts.hasDynamicName(member); }); } function getInnermostModule(node) { - while (node.body.kind === 198) { + while (node.body.kind === 200) { node = node.body; } return node; } function getNodeSpan(node) { - return node.kind === 210 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); + return node.kind === 220 ? ts.createTextSpanFromBounds(node.getFullStart(), node.getEnd()) : ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); } function getTextOfNode(node) { return ts.getTextOfNodeFromSourceText(sourceFile.text, node); @@ -21984,10 +22682,10 @@ var ts; var ts; (function (ts) { (function (PatternMatchKind) { - PatternMatchKind[PatternMatchKind["Exact"] = 0] = "Exact"; - PatternMatchKind[PatternMatchKind["Prefix"] = 1] = "Prefix"; - PatternMatchKind[PatternMatchKind["Substring"] = 2] = "Substring"; - PatternMatchKind[PatternMatchKind["CamelCase"] = 3] = "CamelCase"; + PatternMatchKind[PatternMatchKind["exact"] = 0] = "exact"; + PatternMatchKind[PatternMatchKind["prefix"] = 1] = "prefix"; + PatternMatchKind[PatternMatchKind["substring"] = 2] = "substring"; + PatternMatchKind[PatternMatchKind["camelCase"] = 3] = "camelCase"; })(ts.PatternMatchKind || (ts.PatternMatchKind = {})); var PatternMatchKind = ts.PatternMatchKind; function createPatternMatch(kind, punctuationStripped, isCaseSensitive, camelCaseWeight) { @@ -22018,7 +22716,7 @@ var ts; } return matchSegment(candidate, ts.lastOrUndefined(dotSeparatedSegments)); } - function getMatches(candidate, dottedContainer) { + function getMatches(candidateContainers, candidate) { if (skipMatch(candidate)) { return undefined; } @@ -22026,15 +22724,14 @@ var ts; if (!candidateMatch) { return undefined; } - dottedContainer = dottedContainer || ""; - var containerParts = dottedContainer.split("."); - if (dotSeparatedSegments.length - 1 > containerParts.length) { - return null; + candidateContainers = candidateContainers || []; + if (dotSeparatedSegments.length - 1 > candidateContainers.length) { + return undefined; } var totalMatch = candidateMatch; - for (var i = dotSeparatedSegments.length - 2, j = containerParts.length - 1; i >= 0; i--, j--) { + for (var i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i--, j--) { var segment = dotSeparatedSegments[i]; - var containerName = containerParts[j]; + var containerName = candidateContainers[j]; var containerMatch = matchSegment(containerName, segment); if (!containerMatch) { return undefined; @@ -22461,7 +23158,7 @@ var ts; } return createSignatureHelpItems(candidates, resolvedSignature, argumentInfo); function getImmediatelyContainingArgumentInfo(node) { - if (node.parent.kind === 153 || node.parent.kind === 154) { + if (node.parent.kind === 155 || node.parent.kind === 156) { var callExpression = node.parent; if (node.kind === 24 || node.kind === 16) { @@ -22490,23 +23187,23 @@ var ts; }; } } - else if (node.kind === 10 && node.parent.kind === 155) { + else if (node.kind === 10 && node.parent.kind === 157) { if (ts.isInsideTemplateLiteral(node, position)) { return getArgumentListInfoForTemplate(node.parent, 0); } } - else if (node.kind === 11 && node.parent.parent.kind === 155) { + else if (node.kind === 11 && node.parent.parent.kind === 157) { var templateExpression = node.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 167); + ts.Debug.assert(templateExpression.kind === 169); var argumentIndex = ts.isInsideTemplateLiteral(node, position) ? 0 : 1; return getArgumentListInfoForTemplate(tagExpression, argumentIndex); } - else if (node.parent.kind === 171 && node.parent.parent.parent.kind === 155) { + else if (node.parent.kind === 173 && node.parent.parent.parent.kind === 157) { var templateSpan = node.parent; var templateExpression = templateSpan.parent; var tagExpression = templateExpression.parent; - ts.Debug.assert(templateExpression.kind === 167); + ts.Debug.assert(templateExpression.kind === 169); if (node.kind === 13 && !ts.isInsideTemplateLiteral(node, position)) { return undefined; } @@ -22548,7 +23245,7 @@ var ts; var template = taggedTemplate.template; var applicableSpanStart = template.getStart(); var applicableSpanEnd = template.getEnd(); - if (template.kind === 167) { + if (template.kind === 169) { var lastSpan = ts.lastOrUndefined(template.templateSpans); if (lastSpan.literal.getFullWidth() === 0) { applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, false); @@ -22557,7 +23254,7 @@ var ts; return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); } function getContainingArgumentInfo(node) { - for (var n = node; n.kind !== 210; n = n.parent) { + for (var n = node; n.kind !== 220; n = n.parent) { if (ts.isFunctionBlock(n)) { return undefined; } @@ -22747,7 +23444,7 @@ var ts; ts.findChildOfKind = findChildOfKind; function findContainingList(node) { var syntaxList = ts.forEach(node.parent.getChildren(), function (c) { - if (c.kind === 211 && c.pos <= node.pos && c.end >= node.end) { + if (c.kind === 221 && c.pos <= node.pos && c.end >= node.end) { return c; } }); @@ -22852,7 +23549,7 @@ var ts; } } } - ts.Debug.assert(startNode !== undefined || n.kind === 210); + ts.Debug.assert(startNode !== undefined || n.kind === 220); if (children.length) { var candidate = findRightmostChildNodeWithTokens(children, children.length); return candidate && findRightmostToken(candidate); @@ -22889,17 +23586,17 @@ var ts; } ts.getNodeModifiers = getNodeModifiers; function getTypeArgumentOrTypeParameterList(node) { - if (node.kind === 137 || node.kind === 153) { + if (node.kind === 139 || node.kind === 155) { return node.typeArguments; } - if (ts.isAnyFunction(node) || node.kind === 194 || node.kind === 195) { + if (ts.isAnyFunction(node) || node.kind === 196 || node.kind === 197) { return node.typeParameters; } return undefined; } ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; function isToken(n) { - return n.kind >= 0 && n.kind <= 122; + return n.kind >= 0 && n.kind <= 124; } ts.isToken = isToken; function isWord(kind) { @@ -22940,7 +23637,7 @@ var ts; var ts; (function (ts) { function isFirstDeclarationOfSymbolParameter(symbol) { - return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 126; + return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === 128; } ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; var displayPartWriter = getDisplayPartWriter(); @@ -23510,9 +24207,10 @@ var ts; this.IgnoreAfterLineComment = new formatting.Rule(formatting.RuleDescriptor.create3(2, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create1(1)); this.NoSpaceBeforeSemicolon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.NoSpaceBeforeColon = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 51), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); - this.NoSpaceBeforeQMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); + this.NoSpaceBeforeQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 50), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 8)); this.SpaceAfterColon = new formatting.Rule(formatting.RuleDescriptor.create3(51, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2)); - this.SpaceAfterQMark = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsNotBinaryOpContext), 2)); + this.SpaceAfterQuestionMarkInConditionalOperator = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsConditionalOperatorContext), 2)); + this.NoSpaceAfterQuestionMark = new formatting.Rule(formatting.RuleDescriptor.create3(50, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceAfterSemicolon = new formatting.Rule(formatting.RuleDescriptor.create3(22, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); this.SpaceAfterCloseBrace = new formatting.Rule(formatting.RuleDescriptor.create3(15, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsAfterCodeBlockContext), 2)); this.SpaceBetweenCloseBraceAndElse = new formatting.Rule(formatting.RuleDescriptor.create1(15, 75), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); @@ -23525,7 +24223,7 @@ var ts; this.NoSpaceBeforeCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 19), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.NoSpaceAfterCloseBracket = new formatting.Rule(formatting.RuleDescriptor.create3(19, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.FunctionOpenBraceLeftTokenRange = formatting.Shared.TokenRange.AnyIncludingMultilineComments; - this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); + this.SpaceBeforeOpenBraceInFunction = new formatting.Rule(formatting.RuleDescriptor.create2(this.FunctionOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext, Rules.IsBeforeBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); this.TypeScriptOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([64, 3]); this.SpaceBeforeOpenBraceInTypeScriptDeclWithBlock = new formatting.Rule(formatting.RuleDescriptor.create2(this.TypeScriptOpenBraceLeftTokenRange, 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsTypeScriptDeclWithBlockContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), 2), 1); this.ControlOpenBraceLeftTokenRange = formatting.Shared.TokenRange.FromTokens([17, 3, 74, 95, 80, 75]); @@ -23548,6 +24246,7 @@ var ts; this.SpaceAfterSubtractWhenFollowedByPredecrement = new formatting.Rule(formatting.RuleDescriptor.create1(34, 39), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsBinaryOpContext), 2)); this.NoSpaceBeforeComma = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 23), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceAfterCertainKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([97, 93, 87, 73, 89, 96]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); + this.SpaceAfterLetConstInVariableDeclaration = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([105, 69]), formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), 2)); this.NoSpaceBeforeOpenParenInFuncCall = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), 8)); this.SpaceAfterFunctionInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create3(82, formatting.Shared.TokenRange.Any), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); this.NoSpaceBeforeOpenParenInFuncDecl = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.Any, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsFunctionDeclContext), 8)); @@ -23555,13 +24254,13 @@ var ts; this.NoSpaceBetweenReturnAndSemicolon = new formatting.Rule(formatting.RuleDescriptor.create1(89, 22), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); this.SpaceBetweenStatements = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([17, 74, 75, 66]), 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([95, 80]), 14), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 2)); - this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([114, 118]), 64), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsFunctionDeclContext), 2)); + this.SpaceAfterGetSetInMember = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([116, 120]), 64), 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(112, 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.NoSpaceAfterModuleImport = new formatting.Rule(formatting.RuleDescriptor.create2(formatting.Shared.TokenRange.FromTokens([115, 116]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); - this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([68, 113, 76, 77, 78, 114, 101, 84, 102, 115, 105, 107, 118, 108]), 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([78, 101])), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 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, 118]), 16), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); + this.SpaceAfterCertainTypeScriptKeywords = new formatting.Rule(formatting.RuleDescriptor.create4(formatting.Shared.TokenRange.FromTokens([68, 115, 76, 77, 78, 116, 103, 84, 104, 117, 107, 109, 120, 110]), 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([78, 103])), 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)); this.NoSpaceAfterEllipsis = new formatting.Rule(formatting.RuleDescriptor.create1(21, 64), formatting.RuleOperation.create2(new formatting.RuleOperationContext(Rules.IsSameLineTokenContext), 8)); @@ -23575,7 +24274,8 @@ var ts; this.HighPriorityCommonRules = [ this.IgnoreBeforeComment, this.IgnoreAfterLineComment, - this.NoSpaceBeforeColon, this.SpaceAfterColon, this.NoSpaceBeforeQMark, this.SpaceAfterQMark, + this.NoSpaceBeforeColon, this.SpaceAfterColon, this.NoSpaceBeforeQuestionMark, this.SpaceAfterQuestionMarkInConditionalOperator, + this.NoSpaceAfterQuestionMark, this.NoSpaceBeforeDot, this.NoSpaceAfterDot, this.NoSpaceAfterUnaryPrefixOperator, this.NoSpaceAfterUnaryPreincrementOperator, this.NoSpaceAfterUnaryPredecrementOperator, @@ -23590,6 +24290,7 @@ var ts; this.SpaceAfterFunctionInFuncDecl, this.NewLineAfterOpenBraceInBlockContext, this.SpaceAfterGetSetInMember, this.NoSpaceBetweenReturnAndSemicolon, this.SpaceAfterCertainKeywords, + this.SpaceAfterLetConstInVariableDeclaration, this.NoSpaceBeforeOpenParenInFuncCall, this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator, this.SpaceAfterVoidOperator, @@ -23648,33 +24349,38 @@ var ts; throw new Error("Unknown rule"); }; Rules.IsForContext = function (context) { - return context.contextNode.kind === 179; + return context.contextNode.kind === 181; }; Rules.IsNotForContext = function (context) { return !Rules.IsForContext(context); }; Rules.IsBinaryOpContext = function (context) { switch (context.contextNode.kind) { - case 165: - case 166: + case 167: + case 168: return true; - case 200: - case 191: - case 126: - case 209: + case 202: + case 193: case 128: - case 127: + case 219: + case 130: + case 129: return context.currentTokenSpan.kind === 52 || context.nextTokenSpan.kind === 52; - case 180: + case 182: return context.currentTokenSpan.kind === 85 || context.nextTokenSpan.kind === 85; - case 181: - return context.currentTokenSpan.kind === 122 || context.nextTokenSpan.kind === 122; + case 183: + return context.currentTokenSpan.kind === 124 || context.nextTokenSpan.kind === 124; + case 150: + return context.currentTokenSpan.kind === 52 || context.nextTokenSpan.kind === 52; } return false; }; Rules.IsNotBinaryOpContext = function (context) { return !Rules.IsBinaryOpContext(context); }; + Rules.IsConditionalOperatorContext = function (context) { + return context.contextNode.kind === 168; + }; Rules.IsSameLineTokenOrBeforeMultilineBlockContext = function (context) { return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context); }; @@ -23698,26 +24404,26 @@ var ts; return true; } switch (node.kind) { - case 172: - case 186: - case 150: - case 199: + case 174: + case 188: + case 152: + case 201: return true; } return false; }; Rules.IsFunctionDeclContext = function (context) { switch (context.contextNode.kind) { - case 193: - case 130: - case 129: - case 132: - case 133: - case 134: - case 158: - case 131: - case 159: case 195: + case 132: + case 131: + case 134: + case 135: + case 136: + case 160: + case 133: + case 161: + case 197: return true; } return false; @@ -23727,53 +24433,53 @@ var ts; }; Rules.NodeIsTypeScriptDeclWithBlockContext = function (node) { switch (node.kind) { - case 194: - case 195: + case 196: case 197: - case 141: - case 198: + case 199: + case 143: + case 200: return true; } return false; }; Rules.IsAfterCodeBlockContext = function (context) { switch (context.currentTokenParent.kind) { - case 194: - case 198: - case 197: - case 172: - case 206: + case 196: + case 200: case 199: - case 186: + case 174: + case 216: + case 201: + case 188: return true; } return false; }; Rules.IsControlDeclContext = function (context) { switch (context.contextNode.kind) { - case 176: - case 186: - case 179: - case 180: - case 181: case 178: - case 189: - case 177: - case 185: - case 206: + case 188: + case 181: + case 182: + case 183: + case 180: + case 191: + case 179: + case 187: + case 216: return true; default: return false; } }; Rules.IsObjectContext = function (context) { - return context.contextNode.kind === 150; + return context.contextNode.kind === 152; }; Rules.IsFunctionCallContext = function (context) { - return context.contextNode.kind === 153; + return context.contextNode.kind === 155; }; Rules.IsNewContext = function (context) { - return context.contextNode.kind === 154; + return context.contextNode.kind === 156; }; Rules.IsFunctionCallOrNewContext = function (context) { return Rules.IsFunctionCallContext(context) || Rules.IsNewContext(context); @@ -23784,32 +24490,36 @@ var ts; Rules.IsSameLineTokenContext = function (context) { return context.TokensAreOnSameLine(); }; + Rules.IsStartOfVariableDeclarationList = function (context) { + return context.currentTokenParent.kind === 194 && + context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; + }; Rules.IsNotFormatOnEnter = function (context) { return context.formattingRequestKind != 2; }; Rules.IsModuleDeclContext = function (context) { - return context.contextNode.kind === 198; + return context.contextNode.kind === 200; }; Rules.IsObjectTypeContext = function (context) { - return context.contextNode.kind === 141; + return context.contextNode.kind === 143; }; Rules.IsTypeArgumentOrParameter = function (token, parent) { if (token.kind !== 24 && token.kind !== 25) { return false; } switch (parent.kind) { - case 137: - case 194: + case 139: + case 196: + case 197: case 195: - case 193: - case 158: - case 159: - case 130: - case 129: - case 134: - case 135: - case 153: - case 154: + case 160: + case 161: + case 132: + case 131: + case 136: + case 137: + case 155: + case 156: return true; default: return false; @@ -23820,7 +24530,7 @@ var ts; Rules.IsTypeArgumentOrParameter(context.nextTokenSpan, context.nextTokenParent); }; Rules.IsVoidOpContext = function (context) { - return context.currentTokenSpan.kind === 98 && context.currentTokenParent.kind === 162; + return context.currentTokenSpan.kind === 98 && context.currentTokenParent.kind === 164; }; return Rules; })(); @@ -23842,7 +24552,7 @@ var ts; return result; }; RulesMap.prototype.Initialize = function (rules) { - this.mapRowLength = 122 + 1; + this.mapRowLength = 124 + 1; this.map = new Array(this.mapRowLength * this.mapRowLength); var rulesBucketConstructionStateList = new Array(this.map.length); this.FillRules(rules, rulesBucketConstructionStateList); @@ -24011,7 +24721,7 @@ var ts; } TokenAllAccess.prototype.GetTokens = function () { var result = []; - for (var token = 0; token <= 122; token++) { + for (var token = 0; token <= 124; token++) { result.push(token); } return result; @@ -24053,9 +24763,9 @@ var ts; }; TokenRange.Any = TokenRange.AllTokens(); TokenRange.AnyIncludingMultilineComments = TokenRange.FromTokens(TokenRange.Any.GetTokens().concat([3])); - TokenRange.Keywords = TokenRange.FromRange(65, 122); + TokenRange.Keywords = TokenRange.FromRange(65, 124); TokenRange.BinaryOperators = TokenRange.FromRange(24, 63); - TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([85, 86, 122]); + TokenRange.BinaryKeywordOperators = TokenRange.FromTokens([85, 86, 124]); TokenRange.UnaryPrefixOperators = TokenRange.FromTokens([38, 39, 47, 46]); TokenRange.UnaryPrefixExpressions = TokenRange.FromTokens([7, 64, 16, 18, 14, 92, 87]); TokenRange.UnaryPreincrementExpressions = TokenRange.FromTokens([64, 16, 92, 87]); @@ -24063,7 +24773,7 @@ var ts; TokenRange.UnaryPredecrementExpressions = TokenRange.FromTokens([64, 16, 92, 87]); TokenRange.UnaryPostdecrementExpressions = TokenRange.FromTokens([64, 17, 19, 87]); TokenRange.Comments = TokenRange.FromTokens([2, 3]); - TokenRange.TypeNames = TokenRange.FromTokens([64, 117, 119, 111, 120, 98, 110]); + TokenRange.TypeNames = TokenRange.FromTokens([64, 119, 121, 113, 122, 98, 112]); return TokenRange; })(); Shared.TokenRange = TokenRange; @@ -24228,17 +24938,17 @@ var ts; } function isListElement(parent, node) { switch (parent.kind) { - case 194: - case 195: + case 196: + case 197: return ts.rangeContainsRange(parent.members, node); - case 198: + case 200: var body = parent.body; - return body && body.kind === 172 && ts.rangeContainsRange(body.statements, node); - case 210: - case 172: - case 199: + return body && body.kind === 174 && ts.rangeContainsRange(body.statements, node); + case 220: + case 174: + case 201: return ts.rangeContainsRange(parent.statements, node); - case 206: + case 216: return ts.rangeContainsRange(parent.block.statements, node); } return false; @@ -24355,9 +25065,9 @@ var ts; if (indentation === -1) { if (isSomeBlock(node.kind)) { if (isSomeBlock(parent.kind) || - parent.kind === 210 || - parent.kind === 203 || - parent.kind === 204) { + parent.kind === 220 || + parent.kind === 213 || + parent.kind === 214) { indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(); } else { @@ -24674,8 +25384,8 @@ var ts; parts.push({ pos: startPos, end: commentRange.end }); } var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); - var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceColumn(startLinePos, parts[0].pos, sourceFile, options); - if (indentation === nonWhitespaceColumnInFirstPart) { + var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].pos, sourceFile, options); + if (indentation === nonWhitespaceColumnInFirstPart.column) { return; } var startIndex = 0; @@ -24683,17 +25393,17 @@ var ts; startIndex = 1; startLine++; } - var delta = indentation - nonWhitespaceColumnInFirstPart; + var delta = indentation - nonWhitespaceColumnInFirstPart.column; for (var i = startIndex, len = parts.length; i < len; ++i, ++startLine) { var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); - var nonWhitespaceColumn = i === 0 ? nonWhitespaceColumnInFirstPart : formatting.SmartIndenter.findFirstNonWhitespaceColumn(parts[i].pos, parts[i].end, sourceFile, options); - var newIndentation = nonWhitespaceColumn + delta; + var nonWhitespaceCharacterAndColumn = i === 0 ? nonWhitespaceColumnInFirstPart : formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(parts[i].pos, parts[i].end, sourceFile, options); + var newIndentation = nonWhitespaceCharacterAndColumn.column + delta; if (newIndentation > 0) { var indentationString = getIndentationString(newIndentation, options); - recordReplace(startLinePos, nonWhitespaceColumn, indentationString); + recordReplace(startLinePos, nonWhitespaceCharacterAndColumn.character, indentationString); } else { - recordDelete(startLinePos, nonWhitespaceColumn); + recordDelete(startLinePos, nonWhitespaceCharacterAndColumn.character); } } } @@ -24760,20 +25470,20 @@ var ts; } function isSomeBlock(kind) { switch (kind) { - case 172: - case 199: + case 174: + case 201: return true; } return false; } function getOpenTokenForList(node, list) { switch (node.kind) { + case 133: + case 195: + case 160: + case 132: case 131: - case 193: - case 158: - case 130: - case 129: - case 159: + case 161: if (node.typeParameters === list) { return 24; } @@ -24781,8 +25491,8 @@ var ts; return 16; } break; - case 153: - case 154: + case 155: + case 156: if (node.typeArguments === list) { return 24; } @@ -24790,7 +25500,7 @@ var ts; return 16; } break; - case 137: + case 139: if (node.typeArguments === list) { return 24; } @@ -24875,7 +25585,7 @@ var ts; return 0; } var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; - if (precedingToken.kind === 23 && precedingToken.parent.kind !== 165) { + if (precedingToken.kind === 23 && precedingToken.parent.kind !== 167) { var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); if (actualIndentation !== -1) { return actualIndentation; @@ -24961,7 +25671,7 @@ var ts; } function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) { var useActualIndentation = (ts.isDeclaration(current) || ts.isStatement(current)) && - (parent.kind === 210 || !parentAndChildShareLine); + (parent.kind === 220 || !parentAndChildShareLine); if (!useActualIndentation) { return -1; } @@ -24988,7 +25698,7 @@ var ts; return candidate.end > position || !isCompletedNode(candidate, sourceFile); } function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { - if (parent.kind === 176 && parent.elseStatement === child) { + if (parent.kind === 178 && parent.elseStatement === child) { var elseKeyword = ts.findChildOfKind(parent, 75, sourceFile); ts.Debug.assert(elseKeyword !== undefined); var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; @@ -25000,23 +25710,23 @@ var ts; function getContainingList(node, sourceFile) { if (node.parent) { switch (node.parent.kind) { - case 137: + case 139: if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, node.getStart(sourceFile), node.getEnd())) { return node.parent.typeArguments; } break; - case 150: + case 152: return node.parent.properties; - case 149: + case 151: return node.parent.elements; - case 193: - case 158: - case 159: - case 130: - case 129: - case 134: - case 135: + case 195: + case 160: + case 161: + case 132: + case 131: + case 136: + case 137: var start = node.getStart(sourceFile); if (node.parent.typeParameters && ts.rangeContainsStartEnd(node.parent.typeParameters, start, node.getEnd())) { @@ -25026,8 +25736,8 @@ var ts; return node.parent.parameters; } break; - case 154: - case 153: + case 156: + case 155: var start = node.getStart(sourceFile); if (node.parent.typeArguments && ts.rangeContainsStartEnd(node.parent.typeArguments, start, node.getEnd())) { @@ -25070,12 +25780,13 @@ var ts; var lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0); return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options); } - function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) { + function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) { + var character = 0; var column = 0; for (var pos = startPos; pos < endPos; ++pos) { var ch = sourceFile.text.charCodeAt(pos); if (!ts.isWhiteSpace(ch)) { - return column; + break; } if (ch === 9) { column += options.TabSize + (column % options.TabSize); @@ -25083,31 +25794,36 @@ var ts; else { column++; } + character++; } - return column; + return { column: column, character: character }; + } + SmartIndenter.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn; + function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) { + return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column; } SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; function nodeContentIsAlwaysIndented(kind) { switch (kind) { - case 194: - case 195: + case 196: case 197: - case 149: - case 172: case 199: - case 150: - case 141: - case 186: - case 204: - case 203: - case 157: - case 153: - case 154: - case 173: - case 191: + case 151: + case 174: case 201: - case 184: - case 166: + case 152: + case 143: + case 188: + case 214: + case 213: + case 159: + case 155: + case 156: + case 175: + case 193: + case 208: + case 186: + case 168: return true; } return false; @@ -25117,21 +25833,21 @@ var ts; return true; } switch (parent) { - case 177: - case 178: - case 180: - case 181: case 179: - case 176: - case 193: - case 158: - case 130: - case 129: - case 159: - case 131: + case 180: + case 182: + case 183: + case 181: + case 178: + case 195: + case 160: case 132: + case 131: + case 161: case 133: - return child !== 172; + case 134: + case 135: + return child !== 174; default: return false; } @@ -25155,44 +25871,44 @@ var ts; return false; } switch (n.kind) { - case 194: - case 195: + case 196: case 197: - case 150: - case 172: case 199: - case 186: + case 152: + case 174: + case 201: + case 188: return nodeEndsWith(n, 15, sourceFile); - case 206: + case 216: return isCompletedNode(n.block, sourceFile); - case 157: - case 134: - case 153: - case 135: - return nodeEndsWith(n, 17, sourceFile); - case 193: - case 158: - case 130: - case 129: case 159: + case 136: + case 155: + case 137: + return nodeEndsWith(n, 17, sourceFile); + case 195: + case 160: + case 132: + case 131: + case 161: return !n.body || isCompletedNode(n.body, sourceFile); - case 198: + case 200: return n.body && isCompletedNode(n.body, sourceFile); - case 176: + case 178: if (n.elseStatement) { return isCompletedNode(n.elseStatement, sourceFile); } return isCompletedNode(n.thenStatement, sourceFile); - case 175: - return isCompletedNode(n.expression, sourceFile); - case 149: - return nodeEndsWith(n, 19, sourceFile); - case 203: - case 204: - return false; - case 178: - return isCompletedNode(n.statement, sourceFile); case 177: + return isCompletedNode(n.expression, sourceFile); + case 151: + return nodeEndsWith(n, 19, sourceFile); + case 213: + case 214: + return false; + case 180: + return isCompletedNode(n.statement, sourceFile); + case 179: var hasWhileKeyword = ts.findChildOfKind(n, 99, sourceFile); if (hasWhileKeyword) { return nodeEndsWith(n, 17, sourceFile); @@ -25288,7 +26004,7 @@ var ts; return pos; }; NodeObject.prototype.createSyntaxList = function (nodes) { - var list = createNode(211, nodes.pos, nodes.end, 512, this); + var list = createNode(221, nodes.pos, nodes.end, 512, this); list._children = []; var pos = nodes.pos; for (var i = 0, len = nodes.length; i < len; i++) { @@ -25306,7 +26022,7 @@ var ts; }; NodeObject.prototype.createChildren = function (sourceFile) { var _this = this; - if (this.kind >= 123) { + if (this.kind >= 125) { scanner.setText((sourceFile || this.getSourceFile()).text); var children = []; var pos = this.pos; @@ -25351,7 +26067,7 @@ var ts; var children = this.getChildren(); for (var i = 0; i < children.length; i++) { var child = children[i]; - if (child.kind < 123) { + if (child.kind < 125) { return child; } return child.getFirstToken(sourceFile); @@ -25361,7 +26077,7 @@ var ts; var children = this.getChildren(sourceFile); for (var i = children.length - 1; i >= 0; i--) { var child = children[i]; - if (child.kind < 123) { + if (child.kind < 125) { return child; } return child.getLastToken(sourceFile); @@ -25407,7 +26123,7 @@ var ts; ts.forEach(declarations, function (declaration, indexOfDeclaration) { if (ts.indexOf(declarations, declaration) === indexOfDeclaration) { var sourceFileOfDeclaration = ts.getSourceFileOfNode(declaration); - if (canUseParsedParamTagComments && declaration.kind === 126) { + if (canUseParsedParamTagComments && declaration.kind === 128) { ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedParamJsDocComment) { @@ -25415,13 +26131,13 @@ var ts; } }); } - if (declaration.kind === 198 && declaration.body.kind === 198) { + if (declaration.kind === 200 && declaration.body.kind === 200) { return; } - while (declaration.kind === 198 && declaration.parent.kind === 198) { + while (declaration.kind === 200 && declaration.parent.kind === 200) { declaration = declaration.parent; } - ts.forEach(getJsDocCommentTextRange(declaration.kind === 191 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { + ts.forEach(getJsDocCommentTextRange(declaration.kind === 193 ? declaration.parent.parent : declaration, sourceFileOfDeclaration), function (jsDocCommentTextRange) { var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration); if (cleanedJsDocComment) { jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment); @@ -25705,9 +26421,9 @@ var ts; var namedDeclarations = []; ts.forEachChild(sourceFile, function visit(node) { switch (node.kind) { - case 193: - case 130: - case 129: + case 195: + case 132: + case 131: var functionDeclaration = node; if (functionDeclaration.name && functionDeclaration.name.getFullWidth() > 0) { var lastDeclaration = namedDeclarations.length > 0 ? namedDeclarations[namedDeclarations.length - 1] : undefined; @@ -25722,44 +26438,44 @@ var ts; ts.forEachChild(node, visit); } break; - case 194: - case 195: case 196: case 197: case 198: + case 199: case 200: - case 132: - case 133: - case 141: + case 202: + case 134: + case 135: + case 143: if (node.name) { namedDeclarations.push(node); } - case 131: - case 173: - case 192: - case 146: - case 147: - case 199: + case 133: + case 175: + case 194: + case 148: + case 149: + case 201: ts.forEachChild(node, visit); break; - case 172: + case 174: if (ts.isFunctionBlock(node)) { ts.forEachChild(node, visit); } break; - case 126: + case 128: if (!(node.flags & 112)) { break; } - case 191: - case 148: + case 193: + case 150: if (ts.isBindingPattern(node.name)) { ts.forEachChild(node.name, visit); break; } - case 209: - case 128: - case 127: + case 219: + case 130: + case 129: namedDeclarations.push(node); break; } @@ -25908,14 +26624,14 @@ var ts; return false; } return ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 158) { + if (declaration.kind === 160) { return true; } - if (declaration.kind !== 191 && declaration.kind !== 193) { + if (declaration.kind !== 193 && declaration.kind !== 195) { return false; } for (var parent = declaration.parent; !ts.isFunctionBlock(parent); parent = parent.parent) { - if (parent.kind === 210 || parent.kind === 199) { + if (parent.kind === 220 || parent.kind === 201) { return false; } } @@ -26005,60 +26721,34 @@ var ts; var file = this.getEntry(fileName); return file && file.scriptSnapshot; }; - HostCache.prototype.getChangeRange = function (fileName, lastKnownVersion, oldScriptSnapshot) { - var currentVersion = this.getVersion(fileName); - if (lastKnownVersion === currentVersion) { - return ts.unchangedTextChangeRange; - } - var scriptSnapshot = this.getScriptSnapshot(fileName); - return scriptSnapshot.getChangeRange(oldScriptSnapshot); - }; return HostCache; })(); var SyntaxTreeCache = (function () { function SyntaxTreeCache(host) { this.host = host; - this.currentFileName = ""; - this.currentFileVersion = null; - this.currentSourceFile = null; } - SyntaxTreeCache.prototype.log = function (message) { - if (this.host.log) { - this.host.log(message); + SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { + var scriptSnapshot = this.host.getScriptSnapshot(fileName); + if (!scriptSnapshot) { + throw new Error("Could not find file: '" + fileName + "'."); } - }; - SyntaxTreeCache.prototype.initialize = function (fileName) { - var start = new Date().getTime(); - this.hostCache = new HostCache(this.host); - this.log("SyntaxTreeCache.Initialize: new HostCache: " + (new Date().getTime() - start)); - var version = this.hostCache.getVersion(fileName); + var version = this.host.getScriptVersion(fileName); var sourceFile; if (this.currentFileName !== fileName) { - var scriptSnapshot = this.hostCache.getScriptSnapshot(fileName); - var start = new Date().getTime(); sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, 2, version, true); - this.log("SyntaxTreeCache.Initialize: createSourceFile: " + (new Date().getTime() - start)); } else if (this.currentFileVersion !== version) { - var scriptSnapshot = this.hostCache.getScriptSnapshot(fileName); - var editRange = this.hostCache.getChangeRange(fileName, this.currentFileVersion, this.currentSourceFile.scriptSnapshot); - var start = new Date().getTime(); + var editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot); sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange); - this.log("SyntaxTreeCache.Initialize: updateSourceFile: " + (new Date().getTime() - start)); } if (sourceFile) { this.currentFileVersion = version; this.currentFileName = fileName; + this.currentFileScriptSnapshot = scriptSnapshot; this.currentSourceFile = sourceFile; } - }; - SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { - this.initialize(fileName); return this.currentSourceFile; }; - SyntaxTreeCache.prototype.getCurrentScriptSnapshot = function (fileName) { - return this.getCurrentSourceFile(fileName).scriptSnapshot; - }; return SyntaxTreeCache; })(); function setSourceFileFields(sourceFile, scriptSnapshot, version) { @@ -26189,7 +26879,7 @@ var ts; token = scanner.scan(); if (token === 52) { token = scanner.scan(); - if (token === 116) { + if (token === 118) { token = scanner.scan(); if (token === 16) { token = scanner.scan(); @@ -26220,7 +26910,7 @@ var ts; ts.preProcessFile = preProcessFile; function getTargetLabel(referenceNode, labelName) { while (referenceNode) { - if (referenceNode.kind === 187 && referenceNode.label.text === labelName) { + if (referenceNode.kind === 189 && referenceNode.label.text === labelName) { return referenceNode.label; } referenceNode = referenceNode.parent; @@ -26229,16 +26919,16 @@ var ts; } function isJumpStatementTarget(node) { return node.kind === 64 && - (node.parent.kind === 183 || node.parent.kind === 182) && + (node.parent.kind === 185 || node.parent.kind === 184) && node.parent.label === node; } function isLabelOfLabeledStatement(node) { return node.kind === 64 && - node.parent.kind === 187 && + node.parent.kind === 189 && node.parent.label === node; } function isLabeledBy(node, labelName) { - for (var owner = node.parent; owner.kind === 187; owner = owner.parent) { + for (var owner = node.parent; owner.kind === 189; owner = owner.parent) { if (owner.label.text === labelName) { return true; } @@ -26249,25 +26939,25 @@ var ts; return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); } function isRightSideOfQualifiedName(node) { - return node.parent.kind === 123 && node.parent.right === node; + return node.parent.kind === 125 && node.parent.right === node; } function isRightSideOfPropertyAccess(node) { - return node && node.parent && node.parent.kind === 151 && node.parent.name === node; + return node && node.parent && node.parent.kind === 153 && node.parent.name === node; } function isCallExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 153 && node.parent.expression === node; + return node && node.parent && node.parent.kind === 155 && node.parent.expression === node; } function isNewExpressionTarget(node) { if (isRightSideOfPropertyAccess(node)) { node = node.parent; } - return node && node.parent && node.parent.kind === 154 && node.parent.expression === node; + return node && node.parent && node.parent.kind === 156 && node.parent.expression === node; } function isNameOfModuleDeclaration(node) { - return node.parent.kind === 198 && node.parent.name === node; + return node.parent.kind === 200 && node.parent.name === node; } function isNameOfFunctionDeclaration(node) { return node.kind === 64 && @@ -26275,22 +26965,22 @@ var ts; } function isNameOfPropertyAssignment(node) { return (node.kind === 64 || node.kind === 8 || node.kind === 7) && - (node.parent.kind === 207 || node.parent.kind === 208) && node.parent.name === node; + (node.parent.kind === 217 || node.parent.kind === 218) && node.parent.name === node; } function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { if (node.kind === 8 || node.kind === 7) { switch (node.parent.kind) { - case 128: - case 127: - case 207: - case 209: case 130: case 129: + case 217: + case 219: case 132: - case 133: - case 198: + case 131: + case 134: + case 135: + case 200: return node.parent.name === node; - case 152: + case 154: return node.parent.argumentExpression === node; } } @@ -26299,7 +26989,7 @@ var ts; function isNameOfExternalModuleImportOrDeclaration(node) { if (node.kind === 8) { return isNameOfModuleDeclaration(node) || - (ts.isExternalModuleImportDeclaration(node.parent.parent) && ts.getExternalModuleImportDeclarationExpression(node.parent.parent) === node); + (ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node); } return false; } @@ -26343,7 +27033,7 @@ var ts; BreakContinueSearchType[BreakContinueSearchType["All"] = 3] = "All"; })(BreakContinueSearchType || (BreakContinueSearchType = {})); var keywordCompletions = []; - for (var i = 65; i <= 122; i++) { + for (var i = 65; i <= 124; i++) { keywordCompletions.push({ name: ts.tokenToString(i), kind: ScriptElementKind.keyword, @@ -26357,17 +27047,17 @@ var ts; return undefined; } switch (node.kind) { - case 210: - case 130: - case 129: - case 193: - case 158: + case 220: case 132: - case 133: - case 194: + case 131: case 195: + case 160: + case 134: + case 135: + case 196: case 197: - case 198: + case 199: + case 200: return node; } } @@ -26375,29 +27065,29 @@ var ts; ts.getContainerNode = getContainerNode; function getNodeKind(node) { switch (node.kind) { - case 198: return ScriptElementKind.moduleElement; - case 194: return ScriptElementKind.classElement; - case 195: return ScriptElementKind.interfaceElement; - case 196: return ScriptElementKind.typeElement; - case 197: return ScriptElementKind.enumElement; - case 191: + case 200: return ScriptElementKind.moduleElement; + case 196: return ScriptElementKind.classElement; + case 197: return ScriptElementKind.interfaceElement; + case 198: return ScriptElementKind.typeElement; + case 199: return ScriptElementKind.enumElement; + case 193: return ts.isConst(node) ? ScriptElementKind.constElement : ts.isLet(node) ? ScriptElementKind.letElement : ScriptElementKind.variableElement; - case 193: return ScriptElementKind.functionElement; - case 132: return ScriptElementKind.memberGetAccessorElement; - case 133: return ScriptElementKind.memberSetAccessorElement; + case 195: return ScriptElementKind.functionElement; + case 134: return ScriptElementKind.memberGetAccessorElement; + case 135: return ScriptElementKind.memberSetAccessorElement; + case 132: + case 131: + return ScriptElementKind.memberFunctionElement; case 130: case 129: - return ScriptElementKind.memberFunctionElement; - case 128: - case 127: return ScriptElementKind.memberVariableElement; - case 136: return ScriptElementKind.indexSignatureElement; - case 135: return ScriptElementKind.constructSignatureElement; - case 134: return ScriptElementKind.callSignatureElement; - case 131: return ScriptElementKind.constructorImplementationElement; - case 125: return ScriptElementKind.typeParameterElement; - case 209: return ScriptElementKind.variableElement; - case 126: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; + case 138: return ScriptElementKind.indexSignatureElement; + case 137: return ScriptElementKind.constructSignatureElement; + case 136: return ScriptElementKind.callSignatureElement; + case 133: return ScriptElementKind.constructorImplementationElement; + case 127: return ScriptElementKind.typeParameterElement; + case 219: return ScriptElementKind.variableElement; + case 128: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement; } return ScriptElementKind.unknown; } @@ -26423,6 +27113,7 @@ var ts; return useCaseSensitivefileNames ? fileName : fileName.toLowerCase(); } function getValidSourceFile(fileName) { + fileName = ts.normalizeSlashes(fileName); var sourceFile = program.getSourceFile(getCanonicalFileName(fileName)); if (!sourceFile) { throw new Error("Could not find file: '" + fileName + "'."); @@ -26477,7 +27168,7 @@ var ts; if (sourceFileUpToDate(oldSourceFile)) { return oldSourceFile; } - var textChangeRange = hostCache.getChangeRange(fileName, oldSourceFile.version, oldSourceFile.scriptSnapshot); + var textChangeRange = hostFileInformation.scriptSnapshot.getChangeRange(oldSourceFile.scriptSnapshot); return documentRegistry.updateDocument(oldSourceFile, fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version, textChangeRange); } } @@ -26518,12 +27209,10 @@ var ts; } function getSyntacticDiagnostics(fileName) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); return program.getSyntacticDiagnostics(getValidSourceFile(fileName)); } function getSemanticDiagnostics(fileName) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var targetSourceFile = getValidSourceFile(fileName); var semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile); if (!program.getCompilerOptions().declaration) { @@ -26570,7 +27259,6 @@ var ts; } function getCompletionsAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var syntacticStart = new Date().getTime(); var sourceFile = getValidSourceFile(fileName); var start = new Date().getTime(); @@ -26597,11 +27285,11 @@ var ts; } var node; var isRightOfDot; - if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 151) { + if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 153) { node = previousToken.parent.expression; isRightOfDot = true; } - else if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 123) { + else if (previousToken && previousToken.kind === 20 && previousToken.parent.kind === 125) { node = previousToken.parent.left; isRightOfDot = true; } @@ -26623,7 +27311,7 @@ var ts; var symbols = []; var isMemberCompletion = true; var isNewIdentifierLocation = false; - if (node.kind === 64 || node.kind === 123 || node.kind === 151) { + if (node.kind === 64 || node.kind === 125 || node.kind === 153) { var symbol = typeInfoResolver.getSymbolAtLocation(node); if (symbol && symbol.flags & 8388608) { symbol = typeInfoResolver.getAliasedSymbol(symbol); @@ -26706,27 +27394,27 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23: - return containingNodeKind === 153 || containingNodeKind === 131 || containingNodeKind === 154 || containingNodeKind === 149 || containingNodeKind === 165; + return containingNodeKind === 155 || containingNodeKind === 133 || containingNodeKind === 156 || containingNodeKind === 151 || containingNodeKind === 167; case 16: - return containingNodeKind === 153 || containingNodeKind === 131 || containingNodeKind === 154 || containingNodeKind === 157; + return containingNodeKind === 155 || containingNodeKind === 133 || containingNodeKind === 156 || containingNodeKind === 159; case 18: - return containingNodeKind === 149; - case 115: + return containingNodeKind === 151; + case 117: return true; case 20: - return containingNodeKind === 198; + return containingNodeKind === 200; case 14: - return containingNodeKind === 194; + return containingNodeKind === 196; case 52: - return containingNodeKind === 191 || containingNodeKind === 165; + return containingNodeKind === 193 || containingNodeKind === 167; case 11: - return containingNodeKind === 167; + return containingNodeKind === 169; case 12: - return containingNodeKind === 171; + return containingNodeKind === 173; + case 109: case 107: - case 105: - case 106: - return containingNodeKind === 128; + case 108: + return containingNodeKind === 130; } switch (previousToken.getText()) { case "public": @@ -26756,7 +27444,7 @@ var ts; switch (previousToken.kind) { case 14: case 23: - if (parent && parent.kind === 150) { + if (parent && parent.kind === 152) { return parent; } break; @@ -26766,16 +27454,16 @@ var ts; } function isFunction(kind) { switch (kind) { - case 158: - case 159: - case 193: - case 130: - case 129: + case 160: + case 161: + case 195: case 132: - case 133: + case 131: case 134: case 135: case 136: + case 137: + case 138: return true; } return false; @@ -26785,58 +27473,58 @@ var ts; var containingNodeKind = previousToken.parent.kind; switch (previousToken.kind) { case 23: - return containingNodeKind === 191 || - containingNodeKind === 192 || - containingNodeKind === 173 || - containingNodeKind === 197 || - isFunction(containingNodeKind) || + return containingNodeKind === 193 || containingNodeKind === 194 || - containingNodeKind === 193 || + containingNodeKind === 175 || + containingNodeKind === 199 || + isFunction(containingNodeKind) || + containingNodeKind === 196 || containingNodeKind === 195 || - containingNodeKind === 147 || - containingNodeKind === 146; + containingNodeKind === 197 || + containingNodeKind === 149 || + containingNodeKind === 148; case 20: - return containingNodeKind === 147; + return containingNodeKind === 149; case 18: - return containingNodeKind === 147; + return containingNodeKind === 149; case 16: - return containingNodeKind === 206 || + return containingNodeKind === 216 || isFunction(containingNodeKind); case 14: - return containingNodeKind === 197 || - containingNodeKind === 195 || - containingNodeKind === 141 || - containingNodeKind === 146; + return containingNodeKind === 199 || + containingNodeKind === 197 || + containingNodeKind === 143 || + containingNodeKind === 148; case 22: - return containingNodeKind === 127 && - (previousToken.parent.parent.kind === 195 || - previousToken.parent.parent.kind === 141); + return containingNodeKind === 129 && + (previousToken.parent.parent.kind === 197 || + previousToken.parent.parent.kind === 143); case 24: - return containingNodeKind === 194 || - containingNodeKind === 193 || + return containingNodeKind === 196 || containingNodeKind === 195 || + containingNodeKind === 197 || isFunction(containingNodeKind); + case 110: + return containingNodeKind === 130; + case 21: + return containingNodeKind === 128 || + containingNodeKind === 133 || + (previousToken.parent.parent.kind === 149); + case 109: + case 107: case 108: return containingNodeKind === 128; - case 21: - return containingNodeKind === 126 || - containingNodeKind === 131 || - (previousToken.parent.parent.kind === 147); - case 107: - case 105: - case 106: - return containingNodeKind === 126; case 68: case 76: - case 102: + case 104: case 82: case 97: - case 114: - case 118: + case 116: + case 120: case 84: - case 103: + case 105: case 69: - case 109: + case 111: return true; } switch (previousToken.getText()) { @@ -26867,7 +27555,7 @@ var ts; } var existingMemberNames = {}; ts.forEach(existingMembers, function (m) { - if (m.kind !== 207 && m.kind !== 208) { + if (m.kind !== 217 && m.kind !== 218) { return; } if (m.getStart() <= position && position <= m.getEnd()) { @@ -26885,7 +27573,6 @@ var ts; } } function getCompletionEntryDetails(fileName, position, entryName) { - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var session = activeCompletionSession; if (!session || session.fileName !== fileName || session.position !== position) { @@ -27023,14 +27710,14 @@ var ts; } var type = typeResolver.getTypeOfSymbolAtLocation(symbol, location); if (type) { - if (location.parent && location.parent.kind === 151) { + if (location.parent && location.parent.kind === 153) { var right = location.parent.name; if (right === location || (right && right.getFullWidth() === 0)) { location = location.parent; } } var callExpression; - if (location.kind === 153 || location.kind === 154) { + if (location.kind === 155 || location.kind === 156) { callExpression = location; } else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) { @@ -27042,7 +27729,7 @@ var ts; if (!signature && candidateSignatures.length) { signature = candidateSignatures[0]; } - var useConstructSignatures = callExpression.kind === 154 || callExpression.expression.kind === 90; + var useConstructSignatures = callExpression.kind === 156 || callExpression.expression.kind === 90; var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); if (!ts.contains(allSignatures, signature.target || signature)) { signature = allSignatures.length ? allSignatures[0] : undefined; @@ -27092,22 +27779,22 @@ var ts; } } else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & 98304)) || - (location.kind === 112 && location.parent.kind === 131)) { + (location.kind === 114 && location.parent.kind === 133)) { var signature; var functionDeclaration = location.parent; - var allSignatures = functionDeclaration.kind === 131 ? type.getConstructSignatures() : type.getCallSignatures(); + var allSignatures = functionDeclaration.kind === 133 ? type.getConstructSignatures() : type.getCallSignatures(); if (!typeResolver.isImplementationOfOverload(functionDeclaration)) { signature = typeResolver.getSignatureFromDeclaration(functionDeclaration); } else { signature = allSignatures[0]; } - if (functionDeclaration.kind === 131) { + if (functionDeclaration.kind === 133) { symbolKind = ScriptElementKind.constructorImplementationElement; addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); } else { - addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 134 && + addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 136 && !(type.symbol.flags & 2048 || type.symbol.flags & 4096) ? type.symbol : symbol, symbolKind); } addSignatureDisplayParts(signature, allSignatures); @@ -27123,14 +27810,14 @@ var ts; } if ((symbolFlags & 64) && (semanticMeaning & 2)) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(102)); + displayParts.push(ts.keywordPart(104)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); writeTypeParametersOfSymbol(symbol, sourceFile); } if (symbolFlags & 524288) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(121)); + displayParts.push(ts.keywordPart(123)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); displayParts.push(ts.spacePart()); @@ -27150,7 +27837,7 @@ var ts; } if (symbolFlags & 1536) { addNewLineIfDisplayPartsExist(); - displayParts.push(ts.keywordPart(115)); + displayParts.push(ts.keywordPart(117)); displayParts.push(ts.spacePart()); addFullSymbolName(symbol); } @@ -27169,13 +27856,13 @@ var ts; writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration); } else { - var signatureDeclaration = ts.getDeclarationOfKind(symbol, 125).parent; + var signatureDeclaration = ts.getDeclarationOfKind(symbol, 127).parent; var signature = typeResolver.getSignatureFromDeclaration(signatureDeclaration); - if (signatureDeclaration.kind === 135) { + if (signatureDeclaration.kind === 137) { displayParts.push(ts.keywordPart(87)); displayParts.push(ts.spacePart()); } - else if (signatureDeclaration.kind !== 134 && signatureDeclaration.name) { + else if (signatureDeclaration.kind !== 136 && signatureDeclaration.name) { addFullSymbolName(signatureDeclaration.symbol); } displayParts.push.apply(displayParts, ts.signatureToDisplayParts(typeResolver, signature, sourceFile, 32)); @@ -27184,7 +27871,7 @@ var ts; if (symbolFlags & 8) { addPrefixForAnyFunctionOrVar(symbol, "enum member"); var declaration = symbol.declarations[0]; - if (declaration.kind === 209) { + if (declaration.kind === 219) { var constantValue = typeResolver.getConstantValue(declaration); if (constantValue !== undefined) { displayParts.push(ts.spacePart()); @@ -27200,19 +27887,19 @@ var ts; displayParts.push(ts.spacePart()); addFullSymbolName(symbol); ts.forEach(symbol.declarations, function (declaration) { - if (declaration.kind === 200) { - var importDeclaration = declaration; - if (ts.isExternalModuleImportDeclaration(importDeclaration)) { + if (declaration.kind === 202) { + var importEqualsDeclaration = declaration; + if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(52)); displayParts.push(ts.spacePart()); - displayParts.push(ts.keywordPart(116)); + displayParts.push(ts.keywordPart(118)); displayParts.push(ts.punctuationPart(16)); - displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportDeclarationExpression(importDeclaration)), 8)); + displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), 8)); displayParts.push(ts.punctuationPart(17)); } else { - var internalAliasSymbol = typeResolver.getSymbolAtLocation(importDeclaration.moduleReference); + var internalAliasSymbol = typeResolver.getSymbolAtLocation(importEqualsDeclaration.moduleReference); if (internalAliasSymbol) { displayParts.push(ts.spacePart()); displayParts.push(ts.operatorPart(52)); @@ -27303,7 +27990,6 @@ var ts; } function getQuickInfoAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingPropertyName(sourceFile, position); if (!node) { @@ -27313,8 +27999,8 @@ var ts; if (!symbol) { switch (node.kind) { case 64: - case 151: - case 123: + case 153: + case 125: case 92: case 90: var type = typeInfoResolver.getTypeAtLocation(node); @@ -27341,7 +28027,6 @@ var ts; } function getDefinitionAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingPropertyName(sourceFile, position); if (!node) { @@ -27372,7 +28057,7 @@ var ts; return undefined; } var result = []; - if (node.parent.kind === 208) { + if (node.parent.kind === 218) { var shorthandSymbol = typeInfoResolver.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); var shorthandDeclarations = shorthandSymbol.getDeclarations(); var shorthandSymbolKind = getSymbolKind(shorthandSymbol, typeInfoResolver, node); @@ -27409,8 +28094,8 @@ var ts; var declarations = []; var definition; ts.forEach(signatureDeclarations, function (d) { - if ((selectConstructors && d.kind === 131) || - (!selectConstructors && (d.kind === 193 || d.kind === 130 || d.kind === 129))) { + if ((selectConstructors && d.kind === 133) || + (!selectConstructors && (d.kind === 195 || d.kind === 132 || d.kind === 131))) { declarations.push(d); if (d.body) definition = d; @@ -27427,10 +28112,10 @@ var ts; return false; } function tryAddConstructSignature(symbol, location, symbolKind, symbolName, containerName, result) { - if (isNewExpressionTarget(location) || location.kind === 112) { + if (isNewExpressionTarget(location) || location.kind === 114) { if (symbol.flags & 32) { var classDeclaration = symbol.getDeclarations()[0]; - ts.Debug.assert(classDeclaration && classDeclaration.kind === 194); + ts.Debug.assert(classDeclaration && classDeclaration.kind === 196); return tryAddSignature(classDeclaration.members, true, symbolKind, symbolName, containerName, result); } } @@ -27445,7 +28130,6 @@ var ts; } function getOccurrencesAtPosition(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingWord(sourceFile, position); if (!node) { @@ -27458,81 +28142,81 @@ var ts; switch (node.kind) { case 83: case 75: - if (hasKind(node.parent, 176)) { + if (hasKind(node.parent, 178)) { return getIfElseOccurrences(node.parent); } break; case 89: - if (hasKind(node.parent, 184)) { + if (hasKind(node.parent, 186)) { return getReturnOccurrences(node.parent); } break; case 93: - if (hasKind(node.parent, 188)) { + if (hasKind(node.parent, 190)) { return getThrowOccurrences(node.parent); } break; case 67: - if (hasKind(parent(parent(node)), 189)) { + if (hasKind(parent(parent(node)), 191)) { return getTryCatchFinallyOccurrences(node.parent.parent); } break; case 95: case 80: - if (hasKind(parent(node), 189)) { + if (hasKind(parent(node), 191)) { return getTryCatchFinallyOccurrences(node.parent); } break; case 91: - if (hasKind(node.parent, 186)) { + if (hasKind(node.parent, 188)) { return getSwitchCaseDefaultOccurrences(node.parent); } break; case 66: case 72: - if (hasKind(parent(parent(node)), 186)) { + if (hasKind(parent(parent(node)), 188)) { return getSwitchCaseDefaultOccurrences(node.parent.parent); } break; case 65: case 70: - if (hasKind(node.parent, 183) || hasKind(node.parent, 182)) { + if (hasKind(node.parent, 185) || hasKind(node.parent, 184)) { return getBreakOrContinueStatementOccurences(node.parent); } break; case 81: - if (hasKind(node.parent, 179) || - hasKind(node.parent, 180) || - hasKind(node.parent, 181)) { + if (hasKind(node.parent, 181) || + hasKind(node.parent, 182) || + hasKind(node.parent, 183)) { return getLoopBreakContinueOccurrences(node.parent); } break; case 99: case 74: - if (hasKind(node.parent, 178) || hasKind(node.parent, 177)) { + if (hasKind(node.parent, 180) || hasKind(node.parent, 179)) { return getLoopBreakContinueOccurrences(node.parent); } break; - case 112: - if (hasKind(node.parent, 131)) { + case 114: + if (hasKind(node.parent, 133)) { return getConstructorOccurrences(node.parent); } break; - case 114: - case 118: - if (hasKind(node.parent, 132) || hasKind(node.parent, 133)) { + case 116: + case 120: + if (hasKind(node.parent, 134) || hasKind(node.parent, 135)) { return getGetAndSetOccurrences(node.parent); } default: if (ts.isModifier(node.kind) && node.parent && - (ts.isDeclaration(node.parent) || node.parent.kind === 173)) { + (ts.isDeclaration(node.parent) || node.parent.kind === 175)) { return getModifierOccurrences(node.kind, node.parent); } } return undefined; function getIfElseOccurrences(ifStatement) { var keywords = []; - while (hasKind(ifStatement.parent, 176) && ifStatement.parent.elseStatement === ifStatement) { + while (hasKind(ifStatement.parent, 178) && ifStatement.parent.elseStatement === ifStatement) { ifStatement = ifStatement.parent; } while (ifStatement) { @@ -27543,7 +28227,7 @@ var ts; break; } } - if (!hasKind(ifStatement.elseStatement, 176)) { + if (!hasKind(ifStatement.elseStatement, 178)) { break; } ifStatement = ifStatement.elseStatement; @@ -27576,7 +28260,7 @@ var ts; } function getReturnOccurrences(returnStatement) { var func = ts.getContainingFunction(returnStatement); - if (!(func && hasKind(func.body, 172))) { + if (!(func && hasKind(func.body, 174))) { return undefined; } var keywords = []; @@ -27609,10 +28293,10 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 188) { + if (node.kind === 190) { statementAccumulator.push(node); } - else if (node.kind === 189) { + else if (node.kind === 191) { var tryStatement = node; if (tryStatement.catchClause) { aggregate(tryStatement.catchClause); @@ -27634,10 +28318,10 @@ var ts; var child = throwStatement; while (child.parent) { var parent = child.parent; - if (ts.isFunctionBlock(parent) || parent.kind === 210) { + if (ts.isFunctionBlock(parent) || parent.kind === 220) { return parent; } - if (parent.kind === 189) { + if (parent.kind === 191) { var tryStatement = parent; if (tryStatement.tryBlock === child && tryStatement.catchClause) { return child; @@ -27662,7 +28346,7 @@ var ts; function getLoopBreakContinueOccurrences(loopNode) { var keywords = []; if (pushKeywordIf(keywords, loopNode.getFirstToken(), 81, 99, 74)) { - if (loopNode.kind === 177) { + if (loopNode.kind === 179) { var loopTokens = loopNode.getChildren(); for (var i = loopTokens.length - 1; i >= 0; i--) { if (pushKeywordIf(keywords, loopTokens[i], 99)) { @@ -27697,13 +28381,13 @@ var ts; var owner = getBreakOrContinueOwner(breakOrContinueStatement); if (owner) { switch (owner.kind) { + case 181: + case 182: + case 183: case 179: case 180: - case 181: - case 177: - case 178: return getLoopBreakContinueOccurrences(owner); - case 186: + case 188: return getSwitchCaseDefaultOccurrences(owner); } } @@ -27714,7 +28398,7 @@ var ts; aggregate(node); return statementAccumulator; function aggregate(node) { - if (node.kind === 183 || node.kind === 182) { + if (node.kind === 185 || node.kind === 184) { statementAccumulator.push(node); } else if (!ts.isAnyFunction(node)) { @@ -27730,15 +28414,15 @@ var ts; function getBreakOrContinueOwner(statement) { for (var node = statement.parent; node; node = node.parent) { switch (node.kind) { - case 186: - if (statement.kind === 182) { + case 188: + if (statement.kind === 184) { continue; } - case 179: - case 180: case 181: - case 178: - case 177: + case 182: + case 183: + case 180: + case 179: if (!statement.label || isLabeledBy(node, statement.label.text)) { return node; } @@ -27757,38 +28441,38 @@ var ts; var keywords = []; ts.forEach(declarations, function (declaration) { ts.forEach(declaration.getChildren(), function (token) { - return pushKeywordIf(keywords, token, 112); + return pushKeywordIf(keywords, token, 114); }); }); return ts.map(keywords, getReferenceEntryFromNode); } function getGetAndSetOccurrences(accessorDeclaration) { var keywords = []; - tryPushAccessorKeyword(accessorDeclaration.symbol, 132); - tryPushAccessorKeyword(accessorDeclaration.symbol, 133); + tryPushAccessorKeyword(accessorDeclaration.symbol, 134); + tryPushAccessorKeyword(accessorDeclaration.symbol, 135); return ts.map(keywords, getReferenceEntryFromNode); function tryPushAccessorKeyword(accessorSymbol, accessorKind) { var accessor = ts.getDeclarationOfKind(accessorSymbol, accessorKind); if (accessor) { - ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 114, 118); }); + ts.forEach(accessor.getChildren(), function (child) { return pushKeywordIf(keywords, child, 116, 120); }); } } } function getModifierOccurrences(modifier, declaration) { var container = declaration.parent; if (declaration.flags & 112) { - if (!(container.kind === 194 || - (declaration.kind === 126 && hasKind(container, 131)))) { + if (!(container.kind === 196 || + (declaration.kind === 128 && hasKind(container, 133)))) { return undefined; } } else if (declaration.flags & 128) { - if (container.kind !== 194) { + if (container.kind !== 196) { return undefined; } } else if (declaration.flags & (1 | 2)) { - if (!(container.kind === 199 || container.kind === 210)) { + if (!(container.kind === 201 || container.kind === 220)) { return undefined; } } @@ -27799,18 +28483,18 @@ var ts; var modifierFlag = getFlagFromModifier(modifier); var nodes; switch (container.kind) { - case 199: - case 210: + case 201: + case 220: nodes = container.statements; break; - case 131: + case 133: nodes = container.parameters.concat(container.parent.members); break; - case 194: + case 196: nodes = container.members; if (modifierFlag & 112) { var constructor = ts.forEach(container.members, function (member) { - return member.kind === 131 && member; + return member.kind === 133 && member; }); if (constructor) { nodes = nodes.concat(constructor.parameters); @@ -27828,17 +28512,17 @@ var ts; return ts.map(keywords, getReferenceEntryFromNode); function getFlagFromModifier(modifier) { switch (modifier) { - case 107: + case 109: return 16; - case 105: + case 107: return 32; - case 106: - return 64; case 108: + return 64; + case 110: return 128; case 77: return 1; - case 113: + case 115: return 2; default: ts.Debug.fail(); @@ -27871,7 +28555,6 @@ var ts; } function findReferences(fileName, position, findInStrings, findInComments) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingPropertyName(sourceFile, position); if (!node) { @@ -27962,7 +28645,7 @@ var ts; return stripQuotes(name); } function getInternedName(symbol, declarations) { - var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 158 ? d : undefined; }); + var functionExpression = ts.forEach(declarations, function (d) { return d.kind === 160 ? d : undefined; }); if (functionExpression && functionExpression.name) { var name = functionExpression.name.text; } @@ -27983,7 +28666,7 @@ var ts; if (symbol.getFlags() && (4 | 8192)) { var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32) ? d : undefined; }); if (privateDeclaration) { - return ts.getAncestor(privateDeclaration, 194); + return ts.getAncestor(privateDeclaration, 196); } } if (symbol.parent || (symbol.getFlags() & 268435456)) { @@ -28000,7 +28683,7 @@ var ts; if (scope && scope !== container) { return undefined; } - if (container.kind === 210 && !ts.isExternalModule(container)) { + if (container.kind === 220 && !ts.isExternalModule(container)) { return undefined; } scope = container; @@ -28131,13 +28814,13 @@ var ts; } var staticFlag = 128; switch (searchSpaceNode.kind) { - case 128: - case 127: case 130: case 129: - case 131: case 132: + case 131: case 133: + case 134: + case 135: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; break; @@ -28164,31 +28847,31 @@ var ts; var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, false); var staticFlag = 128; switch (searchSpaceNode.kind) { - case 130: - case 129: + case 132: + case 131: if (ts.isObjectLiteralMethod(searchSpaceNode)) { break; } - case 128: - case 127: - case 131: - case 132: + case 130: + case 129: case 133: + case 134: + case 135: staticFlag &= searchSpaceNode.flags; searchSpaceNode = searchSpaceNode.parent; break; - case 210: + case 220: if (ts.isExternalModule(searchSpaceNode)) { return undefined; } - case 193: - case 158: + case 195: + case 160: break; default: return undefined; } var result = []; - if (searchSpaceNode.kind === 210) { + if (searchSpaceNode.kind === 220) { ts.forEach(sourceFiles, function (sourceFile) { var possiblePositions = getPossibleSymbolReferencePositions(sourceFile, "this", sourceFile.getStart(), sourceFile.getEnd()); getThisReferencesInFile(sourceFile, sourceFile, possiblePositions, result); @@ -28209,25 +28892,25 @@ var ts; } var container = ts.getThisContainer(node, false); switch (searchSpaceNode.kind) { - case 158: - case 193: + case 160: + case 195: if (searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 130: - case 129: + case 132: + case 131: if (ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol) { result.push(getReferenceEntryFromNode(node)); } break; - case 194: + case 196: if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128) === staticFlag) { result.push(getReferenceEntryFromNode(node)); } break; - case 210: - if (container.kind === 210 && !ts.isExternalModule(container)) { + case 220: + if (container.kind === 220 && !ts.isExternalModule(container)) { result.push(getReferenceEntryFromNode(node)); } break; @@ -28259,11 +28942,11 @@ var ts; function getPropertySymbolsFromBaseTypes(symbol, propertyName, result) { if (symbol && symbol.flags & (32 | 64)) { ts.forEach(symbol.getDeclarations(), function (declaration) { - if (declaration.kind === 194) { + if (declaration.kind === 196) { getPropertySymbolFromTypeReference(ts.getClassBaseTypeNode(declaration)); ts.forEach(ts.getClassImplementedTypeNodes(declaration), getPropertySymbolFromTypeReference); } - else if (declaration.kind === 195) { + else if (declaration.kind === 197) { ts.forEach(ts.getInterfaceBaseTypeNodes(declaration), getPropertySymbolFromTypeReference); } }); @@ -28369,10 +29052,10 @@ var ts; } var parent = node.parent; if (parent) { - if (parent.kind === 164 || parent.kind === 163) { + if (parent.kind === 166 || parent.kind === 165) { return true; } - else if (parent.kind === 165 && parent.left === node) { + else if (parent.kind === 167 && parent.left === node) { var operator = parent.operatorToken.kind; return 52 <= operator && operator <= 63; } @@ -28388,7 +29071,6 @@ var ts; } function getEmitOutput(fileName) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var outputFiles = []; function writeFile(fileName, data, writeByteOrderMark) { @@ -28406,33 +29088,33 @@ var ts; } function getMeaningFromDeclaration(node) { switch (node.kind) { - case 126: - case 191: - case 148: case 128: - case 127: - case 207: - case 208: - case 209: + case 193: + case 150: case 130: case 129: - case 131: + case 217: + case 218: + case 219: case 132: + case 131: case 133: - case 193: - case 158: - case 159: - case 206: - return 1; - case 125: + case 134: + case 135: case 195: - case 196: - case 141: - return 2; - case 194: + case 160: + case 161: + case 216: + return 1; + case 127: case 197: - return 1 | 2; case 198: + case 143: + return 2; + case 196: + case 199: + return 1 | 2; + case 200: if (node.name.kind === 8) { return 4 | 1; } @@ -28442,9 +29124,9 @@ var ts; else { return 4; } - case 200: + case 202: return 1 | 2 | 4; - case 210: + case 220: return 4 | 1; } ts.Debug.fail("Unknown declaration type"); @@ -28453,39 +29135,39 @@ var ts; if (isRightSideOfQualifiedName(node)) { node = node.parent; } - return node.parent.kind === 137; + return node.parent.kind === 139; } function isNamespaceReference(node) { var root = node; var isLastClause = true; - if (root.parent.kind === 123) { - while (root.parent && root.parent.kind === 123) + if (root.parent.kind === 125) { + while (root.parent && root.parent.kind === 125) root = root.parent; isLastClause = root.right === node; } - return root.parent.kind === 137 && !isLastClause; + return root.parent.kind === 139 && !isLastClause; } function isInRightSideOfImport(node) { - while (node.parent.kind === 123) { + while (node.parent.kind === 125) { node = node.parent; } - return ts.isInternalModuleImportDeclaration(node.parent) && node.parent.moduleReference === node; + return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; } - function getMeaningFromRightHandSideOfImport(node) { + function getMeaningFromRightHandSideOfImportEquals(node) { ts.Debug.assert(node.kind === 64); - if (node.parent.kind === 123 && + if (node.parent.kind === 125 && node.parent.right === node && - node.parent.parent.kind === 200) { + node.parent.parent.kind === 202) { return 1 | 2 | 4; } return 4; } function getMeaningFromLocation(node) { - if (node.parent.kind === 201) { + if (node.parent.kind === 208) { return 1 | 2 | 4; } else if (isInRightSideOfImport(node)) { - return getMeaningFromRightHandSideOfImport(node); + return getMeaningFromRightHandSideOfImportEquals(node); } else if (ts.isDeclarationOrFunctionExpressionOrCatchVariableName(node)) { return getMeaningFromDeclaration(node.parent); @@ -28502,24 +29184,21 @@ var ts; } function getSignatureHelpItems(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); return ts.SignatureHelp.getSignatureHelpItems(sourceFile, position, typeInfoResolver, cancellationToken); } - function getCurrentSourceFile(fileName) { - fileName = ts.normalizeSlashes(fileName); - var currentSourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return currentSourceFile; + function getSourceFile(fileName) { + return syntaxTreeCache.getCurrentSourceFile(fileName); } function getNameOrDottedNameSpan(fileName, startPos, endPos) { - fileName = ts.normalizeSlashes(fileName); - var node = ts.getTouchingPropertyName(getCurrentSourceFile(fileName), startPos); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, startPos); if (!node) { return; } switch (node.kind) { - case 151: - case 123: + case 153: + case 125: case 8: case 79: case 94: @@ -28537,7 +29216,7 @@ var ts; nodeForStartPos = nodeForStartPos.parent; } else if (isNameOfModuleDeclaration(nodeForStartPos)) { - if (nodeForStartPos.parent.parent.kind === 198 && + if (nodeForStartPos.parent.parent.kind === 200 && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { nodeForStartPos = nodeForStartPos.parent.parent.name; } @@ -28552,16 +29231,15 @@ var ts; return ts.createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd()); } function getBreakpointStatementAtPosition(fileName, position) { - fileName = ts.normalizeSlashes(fileName); - return ts.BreakpointResolver.spanInSourceFileAtLocation(getCurrentSourceFile(fileName), position); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position); } function getNavigationBarItems(fileName) { - fileName = ts.normalizeSlashes(fileName); - return ts.NavigationBar.getNavigationBarItems(getCurrentSourceFile(fileName)); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.NavigationBar.getNavigationBarItems(sourceFile); } function getSemanticClassifications(fileName, span) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var result = []; processNode(sourceFile); @@ -28594,7 +29272,7 @@ var ts; return undefined; function hasValueSideModule(symbol) { return ts.forEach(symbol.declarations, function (declaration) { - return declaration.kind === 198 && ts.getModuleInstanceState(declaration) == 1; + return declaration.kind === 200 && ts.getModuleInstanceState(declaration) == 1; }); } } @@ -28617,8 +29295,7 @@ var ts; } } function getSyntacticClassifications(fileName, span) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); var triviaScanner = ts.createScanner(2, false, sourceFile.text); var mergeConflictScanner = ts.createScanner(2, false, sourceFile.text); var result = []; @@ -28713,16 +29390,16 @@ var ts; if (ts.isPunctuation(tokenKind)) { if (token) { if (tokenKind === 52) { - if (token.parent.kind === 191 || - token.parent.kind === 128 || - token.parent.kind === 126) { + if (token.parent.kind === 193 || + token.parent.kind === 130 || + token.parent.kind === 128) { return ClassificationTypeNames.operator; } } - if (token.parent.kind === 165 || - token.parent.kind === 163 || - token.parent.kind === 164 || - token.parent.kind === 166) { + if (token.parent.kind === 167 || + token.parent.kind === 165 || + token.parent.kind === 166 || + token.parent.kind === 168) { return ClassificationTypeNames.operator; } } @@ -28743,27 +29420,27 @@ var ts; else if (tokenKind === 64) { if (token) { switch (token.parent.kind) { - case 194: + case 196: if (token.parent.name === token) { return ClassificationTypeNames.className; } return; - case 125: + case 127: if (token.parent.name === token) { return ClassificationTypeNames.typeParameterName; } return; - case 195: + case 197: if (token.parent.name === token) { return ClassificationTypeNames.interfaceName; } return; - case 197: + case 199: if (token.parent.name === token) { return ClassificationTypeNames.enumName; } return; - case 198: + case 200: if (token.parent.name === token) { return ClassificationTypeNames.moduleName; } @@ -28789,12 +29466,11 @@ var ts; } } function getOutliningSpans(fileName) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.OutliningElementsCollector.collectElements(sourceFile); } function getBraceMatchingAtPosition(fileName, position) { - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); var result = []; var token = ts.getTouchingToken(sourceFile, position); if (token.getStart(sourceFile) === position) { @@ -28834,9 +29510,8 @@ var ts; } } function getIndentationAtPosition(fileName, position, editorOptions) { - fileName = ts.normalizeSlashes(fileName); var start = new Date().getTime(); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); log("getIndentationAtPosition: getCurrentSourceFile: " + (new Date().getTime() - start)); var start = new Date().getTime(); var result = ts.formatting.SmartIndenter.getIndentation(position, sourceFile, editorOptions); @@ -28844,18 +29519,15 @@ var ts; return result; } function getFormattingEditsForRange(fileName, start, end, options) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.formatting.formatSelection(start, end, sourceFile, getRuleProvider(options), options); } function getFormattingEditsForDocument(fileName, options) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); return ts.formatting.formatDocument(sourceFile, getRuleProvider(options), options); } function getFormattingEditsAfterKeystroke(fileName, position, key, options) { - fileName = ts.normalizeSlashes(fileName); - var sourceFile = getCurrentSourceFile(fileName); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); if (key === "}") { return ts.formatting.formatOnClosingCurly(position, sourceFile, getRuleProvider(options), options); } @@ -28869,7 +29541,6 @@ var ts; } function getTodoComments(fileName, descriptors) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); cancellationToken.throwIfCancellationRequested(); var fileContents = sourceFile.text; @@ -28929,7 +29600,6 @@ var ts; } function getRenameInfo(fileName, position) { synchronizeHostData(); - fileName = ts.normalizeSlashes(fileName); var sourceFile = getValidSourceFile(fileName); var node = ts.getTouchingWord(sourceFile, position); if (node && node.kind === 64) { @@ -29003,7 +29673,7 @@ var ts; getFormattingEditsForDocument: getFormattingEditsForDocument, getFormattingEditsAfterKeystroke: getFormattingEditsAfterKeystroke, getEmitOutput: getEmitOutput, - getSourceFile: getCurrentSourceFile, + getSourceFile: getSourceFile, getProgram: getProgram }; } @@ -29026,19 +29696,19 @@ var ts; var templateStack = []; function isAccessibilityModifier(kind) { switch (kind) { + case 109: case 107: - case 105: - case 106: + case 108: return true; } return false; } function canFollow(keyword1, keyword2) { if (isAccessibilityModifier(keyword1)) { - if (keyword2 === 114 || - keyword2 === 118 || - keyword2 === 112 || - keyword2 === 108) { + if (keyword2 === 116 || + keyword2 === 120 || + keyword2 === 114 || + keyword2 === 110) { return true; } return false; @@ -29103,11 +29773,11 @@ var ts; else if (token === 25 && angleBracketStack > 0) { angleBracketStack--; } - else if (token === 110 || + else if (token === 112 || + token === 121 || token === 119 || - token === 117 || - token === 111 || - token === 120) { + token === 113 || + token === 122) { if (angleBracketStack > 0 && !syntacticClassifierAbsent) { token = 64; } @@ -29251,7 +29921,7 @@ var ts; } } function isKeyword(token) { - return token >= 65 && token <= 122; + return token >= 65 && token <= 124; } function classFromKind(token) { if (isKeyword(token)) { @@ -29300,7 +29970,7 @@ var ts; getNodeConstructor: function (kind) { function Node() { } - var proto = kind === 210 ? new SourceFileObject() : new NodeObject(); + var proto = kind === 220 ? new SourceFileObject() : new NodeObject(); proto.kind = kind; proto.pos = 0; proto.end = 0; @@ -29354,94 +30024,94 @@ var ts; function spanInNode(node) { if (node) { if (ts.isExpression(node)) { - if (node.parent.kind === 177) { + if (node.parent.kind === 179) { return spanInPreviousNode(node); } - if (node.parent.kind === 179) { + if (node.parent.kind === 181) { return textSpan(node); } - if (node.parent.kind === 165 && node.parent.operatorToken.kind === 23) { + if (node.parent.kind === 167 && node.parent.operatorToken.kind === 23) { return textSpan(node); } - if (node.parent.kind == 159 && node.parent.body == node) { + if (node.parent.kind == 161 && node.parent.body == node) { return textSpan(node); } } switch (node.kind) { - case 173: + case 175: return spanInVariableDeclaration(node.declarationList.declarations[0]); - case 191: - case 128: - case 127: - return spanInVariableDeclaration(node); - case 126: - return spanInParameterDeclaration(node); case 193: case 130: case 129: + return spanInVariableDeclaration(node); + case 128: + return spanInParameterDeclaration(node); + case 195: case 132: - case 133: case 131: - case 158: - case 159: + case 134: + case 135: + case 133: + case 160: + case 161: return spanInFunctionDeclaration(node); - case 172: + case 174: if (ts.isFunctionBlock(node)) { return spanInFunctionBlock(node); } - case 199: + case 201: return spanInBlock(node); - case 206: + case 216: return spanInBlock(node.block); - case 175: + case 177: return textSpan(node.expression); - case 184: + case 186: return textSpan(node.getChildAt(0), node.expression); + case 180: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 179: + return spanInNode(node.statement); + case 192: + return textSpan(node.getChildAt(0)); case 178: return textSpan(node, ts.findNextToken(node.expression, node)); - case 177: - return spanInNode(node.statement); - case 190: - return textSpan(node.getChildAt(0)); - case 176: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 187: - return spanInNode(node.statement); - case 183: - case 182: - return textSpan(node.getChildAt(0), node.label); - case 179: - return spanInForStatement(node); - case 180: - case 181: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 186: - return textSpan(node, ts.findNextToken(node.expression, node)); - case 203: - case 204: - return spanInNode(node.statements[0]); case 189: - return spanInBlock(node.tryBlock); + return spanInNode(node.statement); + case 185: + case 184: + return textSpan(node.getChildAt(0), node.label); + case 181: + return spanInForStatement(node); + case 182: + case 183: + return textSpan(node, ts.findNextToken(node.expression, node)); case 188: + return textSpan(node, ts.findNextToken(node.expression, node)); + case 213: + case 214: + return spanInNode(node.statements[0]); + case 191: + return spanInBlock(node.tryBlock); + case 190: return textSpan(node, node.expression); - case 201: + case 208: return textSpan(node, node.exportName); - case 200: + case 202: return textSpan(node, node.moduleReference); - case 198: + case 200: if (ts.getModuleInstanceState(node) !== 1) { return undefined; } - case 194: - case 197: - case 209: - case 153: - case 154: - return textSpan(node); - case 185: - return spanInNode(node.statement); - case 195: case 196: + case 199: + case 219: + case 155: + case 156: + return textSpan(node); + case 187: + return spanInNode(node.statement); + case 197: + case 198: return undefined; case 22: case 1: @@ -29468,10 +30138,10 @@ var ts; case 80: return spanInNextNode(node); default: - if (node.parent.kind === 207 && node.parent.name === node) { + if (node.parent.kind === 217 && node.parent.name === node) { return spanInNode(node.parent.initializer); } - if (node.parent.kind === 156 && node.parent.type === node) { + if (node.parent.kind === 158 && node.parent.type === node) { return spanInNode(node.parent.expression); } if (ts.isAnyFunction(node.parent) && node.parent.type === node) { @@ -29481,12 +30151,12 @@ var ts; } } function spanInVariableDeclaration(variableDeclaration) { - if (variableDeclaration.parent.parent.kind === 180 || - variableDeclaration.parent.parent.kind === 181) { + if (variableDeclaration.parent.parent.kind === 182 || + variableDeclaration.parent.parent.kind === 183) { return spanInNode(variableDeclaration.parent.parent); } - var isParentVariableStatement = variableDeclaration.parent.parent.kind === 173; - var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 179 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); + var isParentVariableStatement = variableDeclaration.parent.parent.kind === 175; + var isDeclarationOfForStatement = variableDeclaration.parent.parent.kind === 181 && ts.contains(variableDeclaration.parent.parent.initializer.declarations, variableDeclaration); var declarations = isParentVariableStatement ? variableDeclaration.parent.parent.declarationList.declarations : isDeclarationOfForStatement ? variableDeclaration.parent.parent.initializer.declarations : undefined; if (variableDeclaration.initializer || (variableDeclaration.flags & 1)) { if (declarations && declarations[0] === variableDeclaration) { @@ -29528,7 +30198,7 @@ var ts; } function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { return !!(functionDeclaration.flags & 1) || - (functionDeclaration.parent.kind === 194 && functionDeclaration.kind !== 131); + (functionDeclaration.parent.kind === 196 && functionDeclaration.kind !== 133); } function spanInFunctionDeclaration(functionDeclaration) { if (!functionDeclaration.body) { @@ -29548,23 +30218,23 @@ var ts; } function spanInBlock(block) { switch (block.parent.kind) { - case 198: + case 200: if (ts.getModuleInstanceState(block.parent) !== 1) { return undefined; } - case 178: - case 176: case 180: - case 181: + case 178: + case 182: + case 183: return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); - case 179: + case 181: 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 === 192) { + if (forStatement.initializer.kind === 194) { var variableDeclarationList = forStatement.initializer; if (variableDeclarationList.declarations.length > 0) { return spanInNode(variableDeclarationList.declarations[0]); @@ -29583,34 +30253,34 @@ var ts; } function spanInOpenBraceToken(node) { switch (node.parent.kind) { - case 197: + case 199: var enumDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); - case 194: + case 196: var classDeclaration = node.parent; return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); - case 186: + case 188: return spanInNodeIfStartsOnSameLine(node.parent, node.parent.clauses[0]); } return spanInNode(node.parent); } function spanInCloseBraceToken(node) { switch (node.parent.kind) { - case 199: + case 201: if (ts.getModuleInstanceState(node.parent.parent) !== 1) { return undefined; } - case 197: - case 194: + case 199: + case 196: return textSpan(node); - case 172: + case 174: if (ts.isFunctionBlock(node.parent)) { return textSpan(node); } - case 206: + case 216: return spanInNode(node.parent.statements[node.parent.statements.length - 1]); ; - case 186: + case 188: var switchStatement = node.parent; var lastClause = switchStatement.clauses[switchStatement.clauses.length - 1]; if (lastClause) { @@ -29622,24 +30292,24 @@ var ts; } } function spanInOpenParenToken(node) { - if (node.parent.kind === 177) { + if (node.parent.kind === 179) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInCloseParenToken(node) { switch (node.parent.kind) { - case 158: - case 193: - case 159: - case 130: - case 129: + case 160: + case 195: + case 161: case 132: - case 133: case 131: - case 178: - case 177: + case 134: + case 135: + case 133: + case 180: case 179: + case 181: return spanInPreviousNode(node); default: return spanInNode(node.parent); @@ -29647,19 +30317,19 @@ var ts; return spanInNode(node.parent); } function spanInColonToken(node) { - if (ts.isAnyFunction(node.parent) || node.parent.kind === 207) { + if (ts.isAnyFunction(node.parent) || node.parent.kind === 217) { return spanInPreviousNode(node); } return spanInNode(node.parent); } function spanInGreaterThanOrLessThanToken(node) { - if (node.parent.kind === 156) { + if (node.parent.kind === 158) { return spanInNode(node.parent.expression); } return spanInNode(node.parent); } function spanInWhileKeyword(node) { - if (node.parent.kind === 177) { + if (node.parent.kind === 179) { return textSpan(node, ts.findNextToken(node.parent.expression, node.parent)); } return spanInNode(node.parent); @@ -29752,7 +30422,12 @@ var ts; return this.shimHost.getCurrentDirectory(); }; LanguageServiceShimHostAdapter.prototype.getDefaultLibFileName = function (options) { - return this.shimHost.getDefaultLibFileName(JSON.stringify(options)); + try { + return this.shimHost.getDefaultLibFileName(JSON.stringify(options)); + } + catch (e) { + return ""; + } }; return LanguageServiceShimHostAdapter; })(); diff --git a/bin/typescriptServices_internal.d.ts b/bin/typescriptServices_internal.d.ts index 12860e9edc8..16616795233 100644 --- a/bin/typescriptServices_internal.d.ts +++ b/bin/typescriptServices_internal.d.ts @@ -170,6 +170,7 @@ declare module ts { function getTextOfNode(node: Node): string; function escapeIdentifier(identifier: string): string; function unescapeIdentifier(identifier: string): string; + function makeIdentifierFromModuleName(moduleName: string): string; function declarationNameToString(name: DeclarationName): string; function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic; function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain): Diagnostic; @@ -194,9 +195,10 @@ declare module ts { function getInvokedExpression(node: CallLikeExpression): Expression; function isExpression(node: Node): boolean; function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean; - function isExternalModuleImportDeclaration(node: Node): boolean; - function getExternalModuleImportDeclarationExpression(node: Node): Expression; - function isInternalModuleImportDeclaration(node: Node): boolean; + function isExternalModuleImportEqualsDeclaration(node: Node): boolean; + function getExternalModuleImportEqualsDeclarationExpression(node: Node): Expression; + function isInternalModuleImportEqualsDeclaration(node: Node): boolean; + function getExternalModuleName(node: Node): Expression; function hasDotDotDotToken(node: Node): boolean; function hasQuestionToken(node: Node): boolean; function hasRestParameters(s: SignatureDeclaration): boolean; diff --git a/bin/typescript_internal.d.ts b/bin/typescript_internal.d.ts index 3a11b69cb91..aaa72fa2254 100644 --- a/bin/typescript_internal.d.ts +++ b/bin/typescript_internal.d.ts @@ -170,6 +170,7 @@ declare module "typescript" { function getTextOfNode(node: Node): string; function escapeIdentifier(identifier: string): string; function unescapeIdentifier(identifier: string): string; + function makeIdentifierFromModuleName(moduleName: string): string; function declarationNameToString(name: DeclarationName): string; function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic; function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain): Diagnostic; @@ -194,9 +195,10 @@ declare module "typescript" { function getInvokedExpression(node: CallLikeExpression): Expression; function isExpression(node: Node): boolean; function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean; - function isExternalModuleImportDeclaration(node: Node): boolean; - function getExternalModuleImportDeclarationExpression(node: Node): Expression; - function isInternalModuleImportDeclaration(node: Node): boolean; + function isExternalModuleImportEqualsDeclaration(node: Node): boolean; + function getExternalModuleImportEqualsDeclarationExpression(node: Node): Expression; + function isInternalModuleImportEqualsDeclaration(node: Node): boolean; + function getExternalModuleName(node: Node): Expression; function hasDotDotDotToken(node: Node): boolean; function hasQuestionToken(node: Node): boolean; function hasRestParameters(s: SignatureDeclaration): boolean;