mirror of
https://github.com/microsoft/TypeScript.git
synced 2025-11-18 17:21:48 +00:00
Merge branch 'master' into templates
This commit is contained in:
commit
76c0381c3f
38 files changed
+1532
-1994
No files matched your search
+281
-190
@@ -155,17 +155,16 @@ var ts;
|
||||
Global_type_0_must_have_1_type_parameter_s: { code: 2317, category: 1 /* Error */, key: "Global type '{0}' must have {1} type parameter(s)." },
|
||||
Cannot_find_global_type_0: { code: 2318, category: 1 /* Error */, key: "Cannot find global type '{0}'." },
|
||||
Named_properties_0_of_types_1_and_2_are_not_identical: { code: 2319, category: 1 /* Error */, key: "Named properties '{0}' of types '{1}' and '{2}' are not identical." },
|
||||
Interface_0_cannot_simultaneously_extend_types_1_and_2_Colon: { code: 2320, category: 1 /* Error */, key: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':" },
|
||||
Interface_0_cannot_simultaneously_extend_types_1_and_2: { code: 2320, category: 1 /* Error */, key: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'." },
|
||||
Excessive_stack_depth_comparing_types_0_and_1: { code: 2321, category: 1 /* Error */, key: "Excessive stack depth comparing types '{0}' and '{1}'." },
|
||||
Type_0_is_not_assignable_to_type_1_Colon: { code: 2322, category: 1 /* Error */, key: "Type '{0}' is not assignable to type '{1}':" },
|
||||
Type_0_is_not_assignable_to_type_1: { code: 2323, category: 1 /* Error */, key: "Type '{0}' is not assignable to type '{1}'." },
|
||||
Property_0_is_missing_in_type_1: { code: 2324, category: 1 /* Error */, key: "Property '{0}' is missing in type '{1}'." },
|
||||
Property_0_is_private_in_type_1_but_not_in_type_2: { code: 2325, category: 1 /* Error */, key: "Property '{0}' is private in type '{1}' but not in type '{2}'." },
|
||||
Types_of_property_0_are_incompatible_Colon: { code: 2326, category: 1 /* Error */, key: "Types of property '{0}' are incompatible:" },
|
||||
Types_of_property_0_are_incompatible: { code: 2326, category: 1 /* Error */, key: "Types of property '{0}' are incompatible." },
|
||||
Property_0_is_optional_in_type_1_but_required_in_type_2: { code: 2327, category: 1 /* Error */, key: "Property '{0}' is optional in type '{1}' but required in type '{2}'." },
|
||||
Types_of_parameters_0_and_1_are_incompatible_Colon: { code: 2328, category: 1 /* Error */, key: "Types of parameters '{0}' and '{1}' are incompatible:" },
|
||||
Types_of_parameters_0_and_1_are_incompatible: { code: 2328, category: 1 /* Error */, key: "Types of parameters '{0}' and '{1}' are incompatible." },
|
||||
Index_signature_is_missing_in_type_0: { code: 2329, category: 1 /* Error */, key: "Index signature is missing in type '{0}'." },
|
||||
Index_signatures_are_incompatible_Colon: { code: 2330, category: 1 /* Error */, key: "Index signatures are incompatible:" },
|
||||
Index_signatures_are_incompatible: { code: 2330, category: 1 /* Error */, key: "Index signatures are incompatible." },
|
||||
this_cannot_be_referenced_in_a_module_body: { code: 2331, category: 1 /* Error */, key: "'this' cannot be referenced in a module body." },
|
||||
this_cannot_be_referenced_in_current_location: { code: 2332, category: 1 /* Error */, key: "'this' cannot be referenced in current location." },
|
||||
this_cannot_be_referenced_in_constructor_arguments: { code: 2333, category: 1 /* Error */, key: "'this' cannot be referenced in constructor arguments." },
|
||||
@@ -178,7 +177,6 @@ var ts;
|
||||
Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: { code: 2340, category: 1 /* Error */, key: "Only public and protected methods of the base class are accessible via the 'super' keyword" },
|
||||
Property_0_is_private_and_only_accessible_within_class_1: { code: 2341, category: 1 /* Error */, key: "Property '{0}' is private and only accessible within class '{1}'." },
|
||||
An_index_expression_argument_must_be_of_type_string_number_or_any: { code: 2342, category: 1 /* Error */, key: "An index expression argument must be of type 'string', 'number', or 'any'." },
|
||||
Type_0_does_not_satisfy_the_constraint_1_Colon: { code: 2343, category: 1 /* Error */, key: "Type '{0}' does not satisfy the constraint '{1}':" },
|
||||
Type_0_does_not_satisfy_the_constraint_1: { code: 2344, category: 1 /* Error */, 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 /* Error */, 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 /* Error */, key: "Supplied parameters do not match any signature of call target." },
|
||||
@@ -188,7 +186,6 @@ var ts;
|
||||
Only_a_void_function_can_be_called_with_the_new_keyword: { code: 2350, category: 1 /* Error */, 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 /* Error */, 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 /* Error */, key: "Neither type '{0}' nor type '{1}' is assignable to the other." },
|
||||
Neither_type_0_nor_type_1_is_assignable_to_the_other_Colon: { code: 2353, category: 1 /* Error */, key: "Neither type '{0}' nor type '{1}' is assignable to the other:" },
|
||||
No_best_common_type_exists_among_return_expressions: { code: 2354, category: 1 /* Error */, 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 /* Error */, 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 /* Error */, key: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
|
||||
@@ -249,12 +246,9 @@ var ts;
|
||||
Numeric_index_type_0_is_not_assignable_to_string_index_type_1: { code: 2413, category: 1 /* Error */, key: "Numeric index type '{0}' is not assignable to string index type '{1}'." },
|
||||
Class_name_cannot_be_0: { code: 2414, category: 1 /* Error */, key: "Class name cannot be '{0}'" },
|
||||
Class_0_incorrectly_extends_base_class_1: { code: 2415, category: 1 /* Error */, key: "Class '{0}' incorrectly extends base class '{1}'." },
|
||||
Class_0_incorrectly_extends_base_class_1_Colon: { code: 2416, category: 1 /* Error */, key: "Class '{0}' incorrectly extends base class '{1}':" },
|
||||
Class_static_side_0_incorrectly_extends_base_class_static_side_1: { code: 2417, category: 1 /* Error */, key: "Class static side '{0}' incorrectly extends base class static side '{1}'." },
|
||||
Class_static_side_0_incorrectly_extends_base_class_static_side_1_Colon: { code: 2418, category: 1 /* Error */, 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 /* Error */, key: "Type name '{0}' in extends clause does not reference constructor function for '{0}'." },
|
||||
Class_0_incorrectly_implements_interface_1: { code: 2420, category: 1 /* Error */, key: "Class '{0}' incorrectly implements interface '{1}'." },
|
||||
Class_0_incorrectly_implements_interface_1_Colon: { code: 2421, category: 1 /* Error */, key: "Class '{0}' incorrectly implements interface '{1}':" },
|
||||
A_class_may_only_implement_another_class_or_interface: { code: 2422, category: 1 /* Error */, 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 /* Error */, 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 /* Error */, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property." },
|
||||
@@ -262,7 +256,6 @@ var ts;
|
||||
Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2426, category: 1 /* Error */, 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 /* Error */, key: "Interface name cannot be '{0}'" },
|
||||
All_declarations_of_an_interface_must_have_identical_type_parameters: { code: 2428, category: 1 /* Error */, key: "All declarations of an interface must have identical type parameters." },
|
||||
Interface_0_incorrectly_extends_interface_1_Colon: { code: 2429, category: 1 /* Error */, key: "Interface '{0}' incorrectly extends interface '{1}':" },
|
||||
Interface_0_incorrectly_extends_interface_1: { code: 2430, category: 1 /* Error */, key: "Interface '{0}' incorrectly extends interface '{1}'." },
|
||||
Enum_name_cannot_be_0: { code: 2431, category: 1 /* Error */, 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 /* Error */, key: "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element." },
|
||||
@@ -286,7 +279,9 @@ var ts;
|
||||
Left_hand_side_of_assignment_expression_cannot_be_a_constant: { code: 2450, category: 1 /* Error */, key: "Left-hand side of assignment expression cannot be a constant.", isEarly: true },
|
||||
Cannot_redeclare_block_scoped_variable_0: { code: 2451, category: 1 /* Error */, key: "Cannot redeclare block-scoped variable '{0}'.", isEarly: true },
|
||||
An_enum_member_cannot_have_a_numeric_name: { code: 2452, category: 1 /* Error */, key: "An enum member cannot have a numeric name." },
|
||||
Type_alias_0_circularly_references_itself: { code: 2453, category: 1 /* Error */, key: "Type alias '{0}' circularly references itself." },
|
||||
The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: { code: 2453, category: 1 /* Error */, 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 /* Error */, 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 /* Error */, key: "Type alias '{0}' circularly references itself." },
|
||||
Import_declaration_0_is_using_private_name_1: { code: 4000, category: 1 /* Error */, key: "Import declaration '{0}' is using private name '{1}'." },
|
||||
Type_parameter_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4001, category: 1 /* Error */, key: "Type parameter '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
|
||||
Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: 1 /* Error */, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
|
||||
@@ -2130,6 +2125,12 @@ var ts;
|
||||
};
|
||||
}
|
||||
ts.chainDiagnosticMessages = chainDiagnosticMessages;
|
||||
function concatenateDiagnosticMessageChains(headChain, tailChain) {
|
||||
Debug.assert(!headChain.next);
|
||||
headChain.next = tailChain;
|
||||
return headChain;
|
||||
}
|
||||
ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains;
|
||||
function flattenDiagnosticChain(file, start, length, diagnosticChain, newLine) {
|
||||
Debug.assert(start >= 0, "start must be non-negative, is " + start);
|
||||
Debug.assert(length >= 0, "length must be non-negative, is " + length);
|
||||
@@ -9344,6 +9345,7 @@ var ts;
|
||||
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 = {};
|
||||
@@ -9517,21 +9519,100 @@ var ts;
|
||||
}
|
||||
}
|
||||
function resolveName(location, name, meaning, nameNotFoundMessage, nameArg) {
|
||||
var errorLocation = location;
|
||||
var result;
|
||||
var lastLocation;
|
||||
var memberWithInitializerThatReferencesIdentifierFromConstructor;
|
||||
function returnResolvedSymbol(s) {
|
||||
if (s && memberWithInitializerThatReferencesIdentifierFromConstructor) {
|
||||
var propertyName = memberWithInitializerThatReferencesIdentifierFromConstructor.name;
|
||||
error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.identifierToString(propertyName), nameArg);
|
||||
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 186 /* SourceFile */:
|
||||
if (!ts.isExternalModule(location))
|
||||
break;
|
||||
case 181 /* ModuleDeclaration */:
|
||||
if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & ts.SymbolFlags.ModuleMember)) {
|
||||
break loop;
|
||||
}
|
||||
break;
|
||||
case 180 /* EnumDeclaration */:
|
||||
if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) {
|
||||
break loop;
|
||||
}
|
||||
break;
|
||||
case 120 /* Property */:
|
||||
if (location.parent.kind === 177 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) {
|
||||
var ctor = findConstructorDeclaration(location.parent);
|
||||
if (ctor && ctor.locals) {
|
||||
if (getSymbol(ctor.locals, name, meaning & ts.SymbolFlags.Value)) {
|
||||
propertyWithInvalidInitializer = location;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 177 /* ClassDeclaration */:
|
||||
case 178 /* InterfaceDeclaration */:
|
||||
if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & ts.SymbolFlags.Type)) {
|
||||
if (lastLocation && lastLocation.flags & 128 /* Static */) {
|
||||
error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
|
||||
return undefined;
|
||||
}
|
||||
break loop;
|
||||
}
|
||||
break;
|
||||
case 121 /* Method */:
|
||||
case 122 /* Constructor */:
|
||||
case 123 /* GetAccessor */:
|
||||
case 124 /* SetAccessor */:
|
||||
case 175 /* FunctionDeclaration */:
|
||||
case 145 /* ArrowFunction */:
|
||||
if (name === "arguments") {
|
||||
result = argumentsSymbol;
|
||||
break loop;
|
||||
}
|
||||
break;
|
||||
case 144 /* FunctionExpression */:
|
||||
if (name === "arguments") {
|
||||
result = argumentsSymbol;
|
||||
break loop;
|
||||
}
|
||||
var id = location.name;
|
||||
if (id && name === id.text) {
|
||||
result = location.symbol;
|
||||
break loop;
|
||||
}
|
||||
break;
|
||||
case 171 /* CatchBlock */:
|
||||
var id = location.variable;
|
||||
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.identifierToString(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.identifierToString(propertyName), typeof nameArg === "string" ? nameArg : ts.identifierToString(nameArg));
|
||||
return undefined;
|
||||
}
|
||||
if (!s && nameNotFoundMessage) {
|
||||
error(errorLocation, nameNotFoundMessage, nameArg);
|
||||
}
|
||||
if (s && s.flags & 2 /* BlockScopedVariable */) {
|
||||
var declaration = ts.forEach(s.declarations, function (d) { return d.flags & ts.NodeFlags.BlockScoped ? d : undefined; });
|
||||
if (result.flags & 2 /* BlockScopedVariable */) {
|
||||
var declaration = ts.forEach(result.declarations, function (d) { return d.flags & ts.NodeFlags.BlockScoped ? d : undefined; });
|
||||
ts.Debug.assert(declaration, "Block-scoped variable declaration is undefined");
|
||||
var declarationSourceFile = ts.getSourceFileOfNode(declaration);
|
||||
var referenceSourceFile = ts.getSourceFileOfNode(errorLocation);
|
||||
@@ -9547,83 +9628,8 @@ var ts;
|
||||
}
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
while (location) {
|
||||
if (location.locals && !isGlobalSourceFile(location)) {
|
||||
if (result = getSymbol(location.locals, name, meaning)) {
|
||||
return returnResolvedSymbol(result);
|
||||
}
|
||||
}
|
||||
switch (location.kind) {
|
||||
case 186 /* SourceFile */:
|
||||
if (!ts.isExternalModule(location))
|
||||
break;
|
||||
case 181 /* ModuleDeclaration */:
|
||||
if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & ts.SymbolFlags.ModuleMember)) {
|
||||
return returnResolvedSymbol(result);
|
||||
}
|
||||
break;
|
||||
case 180 /* EnumDeclaration */:
|
||||
if (result = getSymbol(getSymbolOfNode(location).exports, name, meaning & 8 /* EnumMember */)) {
|
||||
return returnResolvedSymbol(result);
|
||||
}
|
||||
break;
|
||||
case 120 /* Property */:
|
||||
if (location.parent.kind === 177 /* ClassDeclaration */ && !(location.flags & 128 /* Static */)) {
|
||||
var ctor = findConstructorDeclaration(location.parent);
|
||||
if (ctor && ctor.locals) {
|
||||
if (getSymbol(ctor.locals, name, meaning & ts.SymbolFlags.Value)) {
|
||||
memberWithInitializerThatReferencesIdentifierFromConstructor = location;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 177 /* ClassDeclaration */:
|
||||
case 178 /* InterfaceDeclaration */:
|
||||
if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & ts.SymbolFlags.Type)) {
|
||||
if (lastLocation && lastLocation.flags & 128 /* Static */) {
|
||||
error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
|
||||
return undefined;
|
||||
}
|
||||
else {
|
||||
return returnResolvedSymbol(result);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 121 /* Method */:
|
||||
case 122 /* Constructor */:
|
||||
case 123 /* GetAccessor */:
|
||||
case 124 /* SetAccessor */:
|
||||
case 175 /* FunctionDeclaration */:
|
||||
case 145 /* ArrowFunction */:
|
||||
if (name === "arguments") {
|
||||
return returnResolvedSymbol(argumentsSymbol);
|
||||
}
|
||||
break;
|
||||
case 144 /* FunctionExpression */:
|
||||
if (name === "arguments") {
|
||||
return returnResolvedSymbol(argumentsSymbol);
|
||||
}
|
||||
var id = location.name;
|
||||
if (id && name === id.text) {
|
||||
return returnResolvedSymbol(location.symbol);
|
||||
}
|
||||
break;
|
||||
case 171 /* CatchBlock */:
|
||||
var id = location.variable;
|
||||
if (name === id.text) {
|
||||
return returnResolvedSymbol(location.symbol);
|
||||
}
|
||||
break;
|
||||
}
|
||||
lastLocation = location;
|
||||
location = location.parent;
|
||||
}
|
||||
if (result = getSymbol(globals, name, meaning)) {
|
||||
return returnResolvedSymbol(result);
|
||||
}
|
||||
return returnResolvedSymbol(undefined);
|
||||
return result;
|
||||
}
|
||||
function resolveImport(symbol) {
|
||||
ts.Debug.assert((symbol.flags & 16777216 /* Import */) !== 0, "Should only get Imports here.");
|
||||
@@ -9665,7 +9671,7 @@ var ts;
|
||||
}
|
||||
function resolveEntityName(location, name, meaning) {
|
||||
if (name.kind === 59 /* Identifier */) {
|
||||
var symbol = resolveName(location, name.text, meaning, ts.Diagnostics.Cannot_find_name_0, ts.identifierToString(name));
|
||||
var symbol = resolveName(location, name.text, meaning, ts.Diagnostics.Cannot_find_name_0, name);
|
||||
if (!symbol) {
|
||||
return;
|
||||
}
|
||||
@@ -9751,7 +9757,7 @@ var ts;
|
||||
}
|
||||
if (node.exportName.text) {
|
||||
var meaning = ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Namespace;
|
||||
var exportSymbol = resolveName(node, node.exportName.text, meaning, ts.Diagnostics.Cannot_find_name_0, ts.identifierToString(node.exportName));
|
||||
var exportSymbol = resolveName(node, node.exportName.text, meaning, ts.Diagnostics.Cannot_find_name_0, node.exportName);
|
||||
}
|
||||
}
|
||||
symbolLinks.exportAssignSymbol = exportSymbol || unknownSymbol;
|
||||
@@ -10022,10 +10028,9 @@ var ts;
|
||||
}
|
||||
function isImportDeclarationEntityNameReferenceDeclarationVisibile(entityName) {
|
||||
var firstIdentifier = getFirstIdentifier(entityName);
|
||||
var firstIdentifierName = ts.identifierToString(firstIdentifier);
|
||||
var symbolOfNameSpace = resolveName(entityName.parent, firstIdentifier.text, ts.SymbolFlags.Namespace, ts.Diagnostics.Cannot_find_name_0, firstIdentifierName);
|
||||
var symbolOfNameSpace = resolveName(entityName.parent, firstIdentifier.text, ts.SymbolFlags.Namespace, ts.Diagnostics.Cannot_find_name_0, firstIdentifier);
|
||||
var hasNamespaceDeclarationsVisibile = hasVisibleDeclarations(symbolOfNameSpace);
|
||||
return hasNamespaceDeclarationsVisibile ? { accessibility: 0 /* Accessible */, aliasesToMakeVisible: hasNamespaceDeclarationsVisibile.aliasesToMakeVisible } : { accessibility: 1 /* NotAccessible */, errorSymbolName: firstIdentifierName };
|
||||
return hasNamespaceDeclarationsVisibile ? { accessibility: 0 /* Accessible */, aliasesToMakeVisible: hasNamespaceDeclarationsVisibile.aliasesToMakeVisible } : { accessibility: 1 /* NotAccessible */, errorSymbolName: ts.identifierToString(firstIdentifier) };
|
||||
}
|
||||
function releaseStringWriter(writer) {
|
||||
writer.clear();
|
||||
@@ -11925,27 +11930,27 @@ var ts;
|
||||
var assignableRelation = {};
|
||||
var identityRelation = {};
|
||||
function isTypeIdenticalTo(source, target) {
|
||||
return checkTypeRelatedTo(source, target, identityRelation, undefined, undefined, undefined);
|
||||
return checkTypeRelatedTo(source, target, identityRelation, undefined);
|
||||
}
|
||||
function isTypeSubtypeOf(source, target) {
|
||||
return checkTypeSubtypeOf(source, target, undefined, undefined, undefined);
|
||||
return checkTypeSubtypeOf(source, target, undefined);
|
||||
}
|
||||
function checkTypeSubtypeOf(source, target, errorNode, chainedMessage, terminalMessage) {
|
||||
return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, chainedMessage, terminalMessage);
|
||||
function checkTypeSubtypeOf(source, target, errorNode, headMessage, containingMessageChain) {
|
||||
return checkTypeRelatedTo(source, target, subtypeRelation, errorNode, headMessage, containingMessageChain);
|
||||
}
|
||||
function isTypeAssignableTo(source, target) {
|
||||
return checkTypeAssignableTo(source, target, undefined, undefined, undefined);
|
||||
return checkTypeAssignableTo(source, target, undefined);
|
||||
}
|
||||
function checkTypeAssignableTo(source, target, errorNode, chainedMessage, terminalMessage) {
|
||||
return checkTypeRelatedTo(source, target, assignableRelation, errorNode, chainedMessage, terminalMessage);
|
||||
function checkTypeAssignableTo(source, target, errorNode, headMessage) {
|
||||
return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage);
|
||||
}
|
||||
function isTypeRelatedTo(source, target, relation) {
|
||||
return checkTypeRelatedTo(source, target, relation, undefined, undefined, undefined);
|
||||
return checkTypeRelatedTo(source, target, relation, undefined);
|
||||
}
|
||||
function isSignatureAssignableTo(source, target) {
|
||||
var sourceType = getOrCreateTypeFromSignature(source);
|
||||
var targetType = getOrCreateTypeFromSignature(target);
|
||||
return checkTypeRelatedTo(sourceType, targetType, assignableRelation, undefined, undefined, undefined);
|
||||
return checkTypeRelatedTo(sourceType, targetType, assignableRelation, undefined);
|
||||
}
|
||||
function isPropertyIdenticalTo(sourceProp, targetProp) {
|
||||
return isPropertyIdenticalToRecursive(sourceProp, targetProp, false, function (s, t, _reportErrors) { return isTypeIdenticalTo(s, t); });
|
||||
@@ -11975,7 +11980,7 @@ var ts;
|
||||
var typeName1 = typeToString(existing.containingType);
|
||||
var typeName2 = typeToString(base);
|
||||
var errorInfo = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Named_properties_0_of_types_1_and_2_are_not_identical, prop.name, typeName1, typeName2);
|
||||
errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2_Colon, typeToString(type), typeName1, typeName2);
|
||||
errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
|
||||
addDiagnostic(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo, program.getCompilerHost().getNewLine()));
|
||||
}
|
||||
}
|
||||
@@ -11999,7 +12004,7 @@ var ts;
|
||||
return isOptionalProperty(sourceProp) === isOptionalProperty(targetProp) && relate(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
|
||||
}
|
||||
}
|
||||
function checkTypeRelatedTo(source, target, relation, errorNode, chainedMessage, terminalMessage) {
|
||||
function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain) {
|
||||
var errorInfo;
|
||||
var sourceStack;
|
||||
var targetStack;
|
||||
@@ -12007,11 +12012,14 @@ var ts;
|
||||
var depth = 0;
|
||||
var overflow = false;
|
||||
ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
|
||||
var result = isRelatedToWithCustomErrors(source, target, errorNode !== undefined, chainedMessage, terminalMessage);
|
||||
var result = isRelatedToWithCustomErrors(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 (containingMessageChain) {
|
||||
errorInfo = ts.concatenateDiagnosticMessageChains(containingMessageChain, errorInfo);
|
||||
}
|
||||
addDiagnostic(ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, program.getCompilerHost().getNewLine()));
|
||||
}
|
||||
return result;
|
||||
@@ -12019,9 +12027,9 @@ var ts;
|
||||
errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
|
||||
}
|
||||
function isRelatedTo(source, target, reportErrors) {
|
||||
return isRelatedToWithCustomErrors(source, target, reportErrors, undefined, undefined);
|
||||
return isRelatedToWithCustomErrors(source, target, reportErrors, undefined);
|
||||
}
|
||||
function isRelatedToWithCustomErrors(source, target, reportErrors, chainedMessage, terminalMessage) {
|
||||
function isRelatedToWithCustomErrors(source, target, reportErrors, headMessage) {
|
||||
if (relation === identityRelation) {
|
||||
if (source === target)
|
||||
return true;
|
||||
@@ -12076,11 +12084,9 @@ var ts;
|
||||
}
|
||||
}
|
||||
if (reportErrors) {
|
||||
chainedMessage = chainedMessage || ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Colon;
|
||||
terminalMessage = terminalMessage || ts.Diagnostics.Type_0_is_not_assignable_to_type_1;
|
||||
var diagnosticKey = errorInfo ? chainedMessage : terminalMessage;
|
||||
ts.Debug.assert(diagnosticKey);
|
||||
reportError(diagnosticKey, typeToString(source), typeToString(target));
|
||||
headMessage = headMessage || ts.Diagnostics.Type_0_is_not_assignable_to_type_1;
|
||||
ts.Debug.assert(headMessage);
|
||||
reportError(headMessage, typeToString(source), typeToString(target));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -12239,7 +12245,7 @@ var ts;
|
||||
}
|
||||
if (!isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors)) {
|
||||
if (reportErrors) {
|
||||
reportError(ts.Diagnostics.Types_of_property_0_are_incompatible_Colon, symbolToString(targetProp));
|
||||
reportError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -12332,7 +12338,7 @@ var ts;
|
||||
if (!isRelatedTo(s, t, reportErrors)) {
|
||||
if (!isRelatedTo(t, s, false)) {
|
||||
if (reportErrors) {
|
||||
reportError(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible_Colon, source.parameters[i < sourceMax ? i : sourceMax].name, target.parameters[i < targetMax ? i : targetMax].name);
|
||||
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 false;
|
||||
}
|
||||
@@ -12373,7 +12379,7 @@ var ts;
|
||||
}
|
||||
if (!isRelatedTo(sourceType, targetType, reportErrors)) {
|
||||
if (reportErrors) {
|
||||
reportError(ts.Diagnostics.Index_signatures_are_incompatible_Colon);
|
||||
reportError(ts.Diagnostics.Index_signatures_are_incompatible);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -12402,7 +12408,7 @@ var ts;
|
||||
}
|
||||
if (!compatible) {
|
||||
if (reportErrors) {
|
||||
reportError(ts.Diagnostics.Index_signatures_are_incompatible_Colon);
|
||||
reportError(ts.Diagnostics.Index_signatures_are_incompatible);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -12456,6 +12462,32 @@ var ts;
|
||||
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 isTypeOfObjectLiteral(type) {
|
||||
return (type.flags & 32768 /* Anonymous */) && type.symbol && (type.symbol.flags & 2048 /* ObjectLiteral */) ? true : false;
|
||||
}
|
||||
@@ -12694,27 +12726,28 @@ var ts;
|
||||
}
|
||||
}
|
||||
function getInferredType(context, index) {
|
||||
var result = context.inferredTypes[index];
|
||||
if (!result) {
|
||||
var inferredType = context.inferredTypes[index];
|
||||
if (!inferredType) {
|
||||
var inferences = context.inferences[index];
|
||||
if (inferences.length) {
|
||||
var unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
|
||||
var inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : undefinedType;
|
||||
inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : inferenceFailureType;
|
||||
}
|
||||
else {
|
||||
inferredType = emptyObjectType;
|
||||
}
|
||||
var constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
|
||||
var result = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType;
|
||||
context.inferredTypes[index] = result;
|
||||
if (inferredType !== inferenceFailureType) {
|
||||
var constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
|
||||
inferredType = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType;
|
||||
}
|
||||
context.inferredTypes[index] = inferredType;
|
||||
}
|
||||
return result;
|
||||
return inferredType;
|
||||
}
|
||||
function getInferredTypes(context) {
|
||||
for (var i = 0; i < context.inferredTypes.length; i++) {
|
||||
getInferredType(context, i);
|
||||
}
|
||||
context.inferences = undefined;
|
||||
return context.inferredTypes;
|
||||
}
|
||||
function hasAncestor(node, kind) {
|
||||
@@ -12723,7 +12756,7 @@ var ts;
|
||||
function getResolvedSymbol(node) {
|
||||
var links = getNodeLinks(node);
|
||||
if (!links.resolvedSymbol) {
|
||||
links.resolvedSymbol = resolveName(node, node.text, ts.SymbolFlags.Value | 2097152 /* ExportValue */, ts.Diagnostics.Cannot_find_name_0, ts.identifierToString(node)) || unknownSymbol;
|
||||
links.resolvedSymbol = resolveName(node, node.text, ts.SymbolFlags.Value | 2097152 /* ExportValue */, ts.Diagnostics.Cannot_find_name_0, node) || unknownSymbol;
|
||||
}
|
||||
return links.resolvedSymbol;
|
||||
}
|
||||
@@ -13531,21 +13564,29 @@ var ts;
|
||||
}
|
||||
}
|
||||
var inferredTypes = getInferredTypes(context);
|
||||
return ts.contains(inferredTypes, undefinedType) ? undefined : inferredTypes;
|
||||
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) {
|
||||
function checkTypeArguments(signature, typeArguments, typeArgumentResultTypes, reportErrors) {
|
||||
var typeParameters = signature.typeParameters;
|
||||
var result = [];
|
||||
var typeArgumentsAreAssignable = true;
|
||||
for (var i = 0; i < typeParameters.length; i++) {
|
||||
var typeArgNode = typeArguments[i];
|
||||
var typeArgument = getTypeFromTypeNode(typeArgNode);
|
||||
var constraint = getConstraintOfTypeParameter(typeParameters[i]);
|
||||
if (constraint && fullTypeCheck) {
|
||||
checkTypeAssignableTo(typeArgument, constraint, typeArgNode, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1_Colon, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
|
||||
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);
|
||||
}
|
||||
}
|
||||
result.push(typeArgument);
|
||||
}
|
||||
return result;
|
||||
return typeArgumentsAreAssignable;
|
||||
}
|
||||
function checkApplicableSignature(node, signature, relation, excludeArgument, reportErrors) {
|
||||
if (node.arguments) {
|
||||
@@ -13556,7 +13597,7 @@ var ts;
|
||||
}
|
||||
var paramType = getTypeAtPosition(signature, i);
|
||||
var argType = arg.kind === 7 /* StringLiteral */ && !reportErrors ? getStringLiteralType(arg) : checkExpressionWithContextualType(arg, paramType, excludeArgument && excludeArgument[i] ? identityMapper : undefined);
|
||||
var isValidArgument = checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1);
|
||||
var isValidArgument = checkTypeRelatedTo(argType, paramType, relation, reportErrors ? arg : undefined, ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1);
|
||||
if (!isValidArgument) {
|
||||
return false;
|
||||
}
|
||||
@@ -13581,40 +13622,36 @@ var ts;
|
||||
excludeArgument[i] = true;
|
||||
}
|
||||
}
|
||||
var relation = candidates.length === 1 ? assignableRelation : subtypeRelation;
|
||||
var lastCandidate;
|
||||
while (true) {
|
||||
for (var i = 0; i < candidates.length; i++) {
|
||||
if (!signatureHasCorrectArity(node, candidates[i])) {
|
||||
continue;
|
||||
}
|
||||
while (true) {
|
||||
var candidate = candidates[i];
|
||||
if (candidate.typeParameters) {
|
||||
var typeArguments = node.typeArguments ? checkTypeArguments(candidate, node.typeArguments) : inferTypeArguments(candidate, args, excludeArgument);
|
||||
if (!typeArguments) {
|
||||
break;
|
||||
}
|
||||
candidate = getSignatureInstantiation(candidate, typeArguments);
|
||||
}
|
||||
lastCandidate = candidate;
|
||||
if (!checkApplicableSignature(node, candidate, relation, excludeArgument, false)) {
|
||||
break;
|
||||
}
|
||||
var index = excludeArgument ? ts.indexOf(excludeArgument, true) : -1;
|
||||
if (index < 0) {
|
||||
return candidate;
|
||||
}
|
||||
excludeArgument[index] = false;
|
||||
}
|
||||
}
|
||||
if (relation === assignableRelation) {
|
||||
break;
|
||||
}
|
||||
relation = assignableRelation;
|
||||
var candidateForArgumentError;
|
||||
var candidateForTypeArgumentError;
|
||||
var resultOfFailedInference;
|
||||
var result;
|
||||
if (candidates.length > 1) {
|
||||
result = chooseOverload(candidates, subtypeRelation, excludeArgument);
|
||||
}
|
||||
if (lastCandidate) {
|
||||
checkApplicableSignature(node, lastCandidate, relation, undefined, true);
|
||||
if (!result) {
|
||||
candidateForArgumentError = undefined;
|
||||
candidateForTypeArgumentError = undefined;
|
||||
resultOfFailedInference = undefined;
|
||||
result = chooseOverload(candidates, assignableRelation, excludeArgument);
|
||||
}
|
||||
if (result) {
|
||||
return result;
|
||||
}
|
||||
if (candidateForArgumentError) {
|
||||
checkApplicableSignature(node, candidateForArgumentError, assignableRelation, undefined, true);
|
||||
}
|
||||
else if (candidateForTypeArgumentError) {
|
||||
if (node.typeArguments) {
|
||||
checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, [], true);
|
||||
}
|
||||
else {
|
||||
ts.Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0);
|
||||
var failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex];
|
||||
var inferenceCandidates = resultOfFailedInference.inferences[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.func, diagnosticChainHead);
|
||||
}
|
||||
}
|
||||
else {
|
||||
error(node, ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
|
||||
@@ -13627,6 +13664,60 @@ var ts;
|
||||
}
|
||||
}
|
||||
return resolveErrorCall(node);
|
||||
function chooseOverload(candidates, relation, excludeArgument) {
|
||||
for (var i = 0; i < candidates.length; i++) {
|
||||
if (!signatureHasCorrectArity(node, candidates[i])) {
|
||||
continue;
|
||||
}
|
||||
var originalCandidate = candidates[i];
|
||||
var inferenceResult;
|
||||
while (true) {
|
||||
var candidate = originalCandidate;
|
||||
if (candidate.typeParameters) {
|
||||
var typeArgumentTypes;
|
||||
var typeArgumentsAreValid;
|
||||
if (node.typeArguments) {
|
||||
typeArgumentTypes = new Array(candidate.typeParameters.length);
|
||||
typeArgumentsAreValid = checkTypeArguments(candidate, node.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, 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 (!node.typeArguments) {
|
||||
resultOfFailedInference = inferenceResult;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
ts.Debug.assert(originalCandidate === candidate);
|
||||
candidateForArgumentError = originalCandidate;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
function collectCandidates() {
|
||||
var result = candidates;
|
||||
var lastParent;
|
||||
@@ -13750,7 +13841,7 @@ var ts;
|
||||
if (fullTypeCheck && targetType !== unknownType) {
|
||||
var widenedType = getWidenedType(exprType, true);
|
||||
if (!(isTypeAssignableTo(targetType, widenedType))) {
|
||||
checkTypeAssignableTo(exprType, targetType, node, ts.Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other_Colon, ts.Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other);
|
||||
checkTypeAssignableTo(exprType, targetType, node, ts.Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other);
|
||||
}
|
||||
}
|
||||
return targetType;
|
||||
@@ -13880,7 +13971,7 @@ var ts;
|
||||
else {
|
||||
var exprType = checkExpression(node.body);
|
||||
if (node.type) {
|
||||
checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined, undefined);
|
||||
checkTypeAssignableTo(exprType, getTypeFromTypeNode(node.type), node.body, undefined);
|
||||
}
|
||||
checkFunctionExpressionBodies(node.body);
|
||||
}
|
||||
@@ -14110,7 +14201,7 @@ var ts;
|
||||
if (fullTypeCheck && operator >= ts.SyntaxKind.FirstAssignment && operator <= ts.SyntaxKind.LastAssignment) {
|
||||
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, undefined);
|
||||
checkTypeAssignableTo(valueType, leftType, node.left, undefined);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -14414,7 +14505,7 @@ var ts;
|
||||
var constraint = getConstraintOfTypeParameter(type.target.typeParameters[i]);
|
||||
if (fullTypeCheck && constraint) {
|
||||
var typeArgument = type.typeArguments[i];
|
||||
checkTypeAssignableTo(typeArgument, constraint, node, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1_Colon, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
|
||||
checkTypeAssignableTo(typeArgument, constraint, node, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -14852,7 +14943,7 @@ var ts;
|
||||
}
|
||||
if (node.initializer) {
|
||||
if (!(getNodeLinks(node.initializer).flags & 1 /* TypeChecked */)) {
|
||||
checkTypeAssignableTo(checkAndMarkExpression(node.initializer), type, node, undefined, undefined);
|
||||
checkTypeAssignableTo(checkAndMarkExpression(node.initializer), type, node, undefined);
|
||||
}
|
||||
checkCollisionWithConstDeclarations(node);
|
||||
}
|
||||
@@ -14933,7 +15024,7 @@ var ts;
|
||||
var returnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
|
||||
var checkAssignability = func.type || (func.kind === 123 /* GetAccessor */ && getSetAccessorTypeAnnotationNode(getDeclarationOfKind(func.symbol, 124 /* SetAccessor */)));
|
||||
if (checkAssignability) {
|
||||
checkTypeAssignableTo(checkExpression(node.expression), returnType, node.expression, undefined, undefined);
|
||||
checkTypeAssignableTo(checkExpression(node.expression), returnType, node.expression, undefined);
|
||||
}
|
||||
else if (func.kind == 122 /* Constructor */) {
|
||||
if (!isTypeAssignableTo(checkExpression(node.expression), returnType)) {
|
||||
@@ -14954,7 +15045,7 @@ var ts;
|
||||
if (fullTypeCheck && clause.expression) {
|
||||
var caseType = checkExpression(clause.expression);
|
||||
if (!isTypeAssignableTo(expressionType, caseType)) {
|
||||
checkTypeAssignableTo(caseType, expressionType, clause.expression, undefined, undefined);
|
||||
checkTypeAssignableTo(caseType, expressionType, clause.expression, undefined);
|
||||
}
|
||||
}
|
||||
checkBlock(clause);
|
||||
@@ -15061,9 +15152,9 @@ var ts;
|
||||
if (type.baseTypes.length) {
|
||||
if (fullTypeCheck) {
|
||||
var baseType = type.baseTypes[0];
|
||||
checkTypeAssignableTo(type, baseType, node.name, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1_Colon, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1);
|
||||
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_Colon, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
|
||||
checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
|
||||
if (baseType.symbol !== resolveEntityName(node, node.baseType.typeName, ts.SymbolFlags.Value)) {
|
||||
error(node.baseType, ts.Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType));
|
||||
}
|
||||
@@ -15079,7 +15170,7 @@ var ts;
|
||||
if (t !== unknownType) {
|
||||
var declaredType = (t.flags & 4096 /* Reference */) ? t.target : t;
|
||||
if (declaredType.flags & (1024 /* Class */ | 2048 /* Interface */)) {
|
||||
checkTypeAssignableTo(type, t, node.name, ts.Diagnostics.Class_0_incorrectly_implements_interface_1_Colon, ts.Diagnostics.Class_0_incorrectly_implements_interface_1);
|
||||
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);
|
||||
@@ -15184,7 +15275,7 @@ var ts;
|
||||
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_Colon, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1);
|
||||
checkTypeAssignableTo(type, baseType, node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1);
|
||||
});
|
||||
checkIndexConstraints(type);
|
||||
}
|
||||
@@ -15229,7 +15320,7 @@ var ts;
|
||||
if (initializer) {
|
||||
autoValue = getConstantValueForExpression(initializer);
|
||||
if (autoValue === undefined && !ambient) {
|
||||
checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, undefined, undefined);
|
||||
checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, undefined);
|
||||
}
|
||||
}
|
||||
else if (ambient) {
|
||||
|
||||
+514
-401
File diff suppressed because it is too large.
Load diff
+18
-20
@@ -5468,31 +5468,29 @@ module ts {
|
||||
Debug.assert(!result.length);
|
||||
for (var i = 0; i < signatures.length; i++) {
|
||||
var signature = signatures[i];
|
||||
if (true) {
|
||||
var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
|
||||
var parent = signature.declaration && signature.declaration.parent;
|
||||
if (!lastSymbol || symbol === lastSymbol) {
|
||||
if (lastParent && parent === lastParent) {
|
||||
pos++;
|
||||
}
|
||||
else {
|
||||
lastParent = parent;
|
||||
pos = cutoffPos;
|
||||
}
|
||||
var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
|
||||
var parent = signature.declaration && signature.declaration.parent;
|
||||
if (!lastSymbol || symbol === lastSymbol) {
|
||||
if (lastParent && parent === lastParent) {
|
||||
pos++;
|
||||
}
|
||||
else {
|
||||
// current declaration belongs to a different symbol
|
||||
// set cutoffPos so re-orderings in the future won't change result set from 0 to cutoffPos
|
||||
pos = cutoffPos = result.length;
|
||||
lastParent = parent;
|
||||
pos = cutoffPos;
|
||||
}
|
||||
lastSymbol = symbol;
|
||||
|
||||
for (var j = result.length; j > pos; j--) {
|
||||
result[j] = result[j - 1];
|
||||
}
|
||||
result[pos] = signature;
|
||||
}
|
||||
else {
|
||||
// current declaration belongs to a different symbol
|
||||
// set cutoffPos so re-orderings in the future won't change result set from 0 to cutoffPos
|
||||
pos = cutoffPos = result.length;
|
||||
lastParent = parent;
|
||||
}
|
||||
lastSymbol = symbol;
|
||||
|
||||
for (var j = result.length; j > pos; j--) {
|
||||
result[j] = result[j - 1];
|
||||
}
|
||||
result[pos] = signature;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -70,75 +70,6 @@ module TypeScript.ASTHelpers {
|
||||
return true;
|
||||
}
|
||||
|
||||
///
|
||||
/// Return the ISyntaxElement containing "position"
|
||||
///
|
||||
export function getAstAtPosition(script: ISyntaxElement, pos: number, useTrailingTriviaAsLimChar: boolean = true, forceInclusive: boolean = false): ISyntaxElement {
|
||||
var top: ISyntaxElement = null;
|
||||
|
||||
var pre = function (cur: ISyntaxElement, walker: IAstWalker) {
|
||||
if (!isShared(cur) && isValidAstNode(cur)) {
|
||||
var isInvalid1 = cur.kind() === SyntaxKind.ExpressionStatement && width(cur) === 0;
|
||||
|
||||
if (isInvalid1) {
|
||||
walker.options.goChildren = false;
|
||||
}
|
||||
else {
|
||||
// Add "cur" to the stack if it contains our position
|
||||
// For "identifier" nodes, we need a special case: A position equal to "limChar" is
|
||||
// valid, since the position corresponds to a caret position (in between characters)
|
||||
// For example:
|
||||
// bar
|
||||
// 0123
|
||||
// If "position === 3", the caret is at the "right" of the "r" character, which should be considered valid
|
||||
var inclusive =
|
||||
forceInclusive ||
|
||||
cur.kind() === SyntaxKind.IdentifierName ||
|
||||
cur.kind() === SyntaxKind.MemberAccessExpression ||
|
||||
cur.kind() === SyntaxKind.QualifiedName ||
|
||||
//cur.kind() === SyntaxKind.TypeRef ||
|
||||
cur.kind() === SyntaxKind.VariableDeclaration ||
|
||||
cur.kind() === SyntaxKind.VariableDeclarator ||
|
||||
cur.kind() === SyntaxKind.InvocationExpression ||
|
||||
pos === end(script) + lastToken(script).trailingTriviaWidth(); // Special "EOF" case
|
||||
|
||||
var minChar = start(cur);
|
||||
var limChar = end(cur) + (useTrailingTriviaAsLimChar ? trailingTriviaWidth(cur) : 0) + (inclusive ? 1 : 0);
|
||||
if (pos >= minChar && pos < limChar) {
|
||||
|
||||
// Ignore empty lists
|
||||
if ((cur.kind() !== SyntaxKind.List && cur.kind() !== SyntaxKind.SeparatedList) || end(cur) > start(cur)) {
|
||||
// TODO: Since ISyntaxElement is sometimes not correct wrt to position, only add "cur" if it's better
|
||||
// than top of the stack.
|
||||
if (top === null) {
|
||||
top = cur;
|
||||
}
|
||||
else if (start(cur) >= start(top) &&
|
||||
(end(cur) + (useTrailingTriviaAsLimChar ? trailingTriviaWidth(cur) : 0)) <= (end(top) + (useTrailingTriviaAsLimChar ? trailingTriviaWidth(top) : 0))) {
|
||||
// this new node appears to be better than the one we're
|
||||
// storing. Make this the new node.
|
||||
|
||||
// However, If the current top is a missing identifier, we
|
||||
// don't want to replace it with another missing identifier.
|
||||
// We want to return the first missing identifier found in a
|
||||
// depth first walk of the tree.
|
||||
if (width(top) !== 0 || width(cur) !== 0) {
|
||||
top = cur;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Don't go further down the tree if pos is outside of [minChar, limChar]
|
||||
walker.options.goChildren = (minChar <= pos && pos <= limChar);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
getAstWalkerFactory().walk(script, pre);
|
||||
return top;
|
||||
}
|
||||
|
||||
export function getExtendsHeritageClause(clauses: HeritageClauseSyntax[]): HeritageClauseSyntax {
|
||||
return getHeritageClause(clauses, SyntaxKind.ExtendsHeritageClause);
|
||||
}
|
||||
|
||||
@@ -1,721 +0,0 @@
|
||||
//
|
||||
// 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
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
///<reference path='references.ts' />
|
||||
|
||||
module TypeScript {
|
||||
function walkListChildren(preAst: ISyntaxNodeOrToken[], walker: AstWalker): void {
|
||||
for (var i = 0, n = preAst.length; i < n; i++) {
|
||||
walker.walk(preAst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
function walkThrowStatementChildren(preAst: ThrowStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkPrefixUnaryExpressionChildren(preAst: PrefixUnaryExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.operand);
|
||||
}
|
||||
|
||||
function walkPostfixUnaryExpressionChildren(preAst: PostfixUnaryExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.operand);
|
||||
}
|
||||
|
||||
function walkDeleteExpressionChildren(preAst: DeleteExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkTypeArgumentListChildren(preAst: TypeArgumentListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeArguments);
|
||||
}
|
||||
|
||||
function walkTupleTypeChildren(preAst: TupleTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.types);
|
||||
}
|
||||
|
||||
function walkTypeOfExpressionChildren(preAst: TypeOfExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkVoidExpressionChildren(preAst: VoidExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkArgumentListChildren(preAst: ArgumentListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeArgumentList);
|
||||
walker.walk(preAst.arguments);
|
||||
}
|
||||
|
||||
function walkArrayLiteralExpressionChildren(preAst: ArrayLiteralExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expressions);
|
||||
}
|
||||
|
||||
function walkSimplePropertyAssignmentChildren(preAst: SimplePropertyAssignmentSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkFunctionPropertyAssignmentChildren(preAst: FunctionPropertyAssignmentSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkGetAccessorChildren(preAst: GetAccessorSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkSeparatedListChildren(preAst: ISyntaxNodeOrToken[], walker: AstWalker): void {
|
||||
for (var i = 0, n = preAst.length; i < n; i++) {
|
||||
walker.walk(preAst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
function walkSetAccessorChildren(preAst: SetAccessorSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkObjectLiteralExpressionChildren(preAst: ObjectLiteralExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyAssignments);
|
||||
}
|
||||
|
||||
function walkCastExpressionChildren(preAst: CastExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.type);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkParenthesizedExpressionChildren(preAst: ParenthesizedExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkElementAccessExpressionChildren(preAst: ElementAccessExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.argumentExpression);
|
||||
}
|
||||
|
||||
function walkMemberAccessExpressionChildren(preAst: MemberAccessExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.name);
|
||||
}
|
||||
|
||||
function walkQualifiedNameChildren(preAst: QualifiedNameSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.left);
|
||||
walker.walk(preAst.right);
|
||||
}
|
||||
|
||||
function walkBinaryExpressionChildren(preAst: BinaryExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.left);
|
||||
walker.walk(preAst.right);
|
||||
}
|
||||
|
||||
function walkEqualsValueClauseChildren(preAst: EqualsValueClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.value);
|
||||
}
|
||||
|
||||
function walkTypeParameterChildren(preAst: TypeParameterSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.constraint);
|
||||
}
|
||||
|
||||
function walkTypeParameterListChildren(preAst: TypeParameterListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameters);
|
||||
}
|
||||
|
||||
function walkGenericTypeChildren(preAst: GenericTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.name);
|
||||
walker.walk(preAst.typeArgumentList);
|
||||
}
|
||||
|
||||
function walkTypeAnnotationChildren(preAst: TypeAnnotationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkTypeQueryChildren(preAst: TypeQuerySyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.name);
|
||||
}
|
||||
|
||||
function walkInvocationExpressionChildren(preAst: InvocationExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.argumentList);
|
||||
}
|
||||
|
||||
function walkObjectCreationExpressionChildren(preAst: ObjectCreationExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.argumentList);
|
||||
}
|
||||
|
||||
function walkTrinaryExpressionChildren(preAst: ConditionalExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.whenTrue);
|
||||
walker.walk(preAst.whenFalse);
|
||||
}
|
||||
|
||||
function walkFunctionExpressionChildren(preAst: FunctionExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkFunctionTypeChildren(preAst: FunctionTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.parameterList);
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkParenthesizedArrowFunctionExpressionChildren(preAst: ParenthesizedArrowFunctionExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkSimpleArrowFunctionExpressionChildren(preAst: SimpleArrowFunctionExpressionSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.parameter);
|
||||
walker.walk(preAst.block);
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkMemberFunctionDeclarationChildren(preAst: MemberFunctionDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkFuncDeclChildren(preAst: FunctionDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkIndexMemberDeclarationChildren(preAst: IndexMemberDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.indexSignature);
|
||||
}
|
||||
|
||||
function walkIndexSignatureChildren(preAst: IndexSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.parameters);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
}
|
||||
|
||||
function walkCallSignatureChildren(preAst: CallSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.parameterList);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
}
|
||||
|
||||
function walkConstraintChildren(preAst: ConstraintSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeOrExpression);
|
||||
}
|
||||
|
||||
function walkConstructorDeclarationChildren(preAst: ConstructorDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.callSignature);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkConstructorTypeChildren(preAst: FunctionTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.parameterList);
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkConstructSignatureChildren(preAst: ConstructSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.callSignature);
|
||||
}
|
||||
|
||||
function walkParameterChildren(preAst: ParameterSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
walker.walk(preAst.equalsValueClause);
|
||||
}
|
||||
|
||||
function walkParameterListChildren(preAst: ParameterListSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.parameters);
|
||||
}
|
||||
|
||||
function walkPropertySignatureChildren(preAst: PropertySignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
}
|
||||
|
||||
function walkVariableDeclaratorChildren(preAst: VariableDeclaratorSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
walker.walk(preAst.equalsValueClause);
|
||||
}
|
||||
|
||||
function walkMemberVariableDeclarationChildren(preAst: MemberVariableDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclarator);
|
||||
}
|
||||
|
||||
function walkMethodSignatureChildren(preAst: MethodSignatureSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.callSignature);
|
||||
}
|
||||
|
||||
function walkReturnStatementChildren(preAst: ReturnStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkForStatementChildren(preAst: ForStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclaration);
|
||||
walker.walk(preAst.initializer);
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.incrementor);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkForInStatementChildren(preAst: ForInStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclaration);
|
||||
walker.walk(preAst.left);
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkIfStatementChildren(preAst: IfStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
walker.walk(preAst.elseClause);
|
||||
}
|
||||
|
||||
function walkElseClauseChildren(preAst: ElseClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkWhileStatementChildren(preAst: WhileStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkDoStatementChildren(preAst: DoStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkBlockChildren(preAst: BlockSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.statements);
|
||||
}
|
||||
|
||||
function walkVariableDeclarationChildren(preAst: VariableDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclarators);
|
||||
}
|
||||
|
||||
function walkCaseSwitchClauseChildren(preAst: CaseSwitchClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.statements);
|
||||
}
|
||||
|
||||
function walkDefaultSwitchClauseChildren(preAst: DefaultSwitchClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.statements);
|
||||
}
|
||||
|
||||
function walkSwitchStatementChildren(preAst: SwitchStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
walker.walk(preAst.switchClauses);
|
||||
}
|
||||
|
||||
function walkTryStatementChildren(preAst: TryStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.block);
|
||||
walker.walk(preAst.catchClause);
|
||||
walker.walk(preAst.finallyClause);
|
||||
}
|
||||
|
||||
function walkCatchClauseChildren(preAst: CatchClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeAnnotation);
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkExternalModuleReferenceChildren(preAst: ExternalModuleReferenceSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.stringLiteral);
|
||||
}
|
||||
|
||||
function walkFinallyClauseChildren(preAst: FinallyClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.block);
|
||||
}
|
||||
|
||||
function walkClassDeclChildren(preAst: ClassDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.heritageClauses);
|
||||
walker.walk(preAst.classElements);
|
||||
}
|
||||
|
||||
function walkScriptChildren(preAst: SourceUnitSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.moduleElements);
|
||||
}
|
||||
|
||||
function walkHeritageClauseChildren(preAst: HeritageClauseSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeNames);
|
||||
}
|
||||
|
||||
function walkInterfaceDeclerationChildren(preAst: InterfaceDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.typeParameterList);
|
||||
walker.walk(preAst.heritageClauses);
|
||||
walker.walk(preAst.body);
|
||||
}
|
||||
|
||||
function walkObjectTypeChildren(preAst: ObjectTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.typeMembers);
|
||||
}
|
||||
|
||||
function walkArrayTypeChildren(preAst: ArrayTypeSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.type);
|
||||
}
|
||||
|
||||
function walkModuleDeclarationChildren(preAst: ModuleDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.name);
|
||||
walker.walk(preAst.stringLiteral);
|
||||
walker.walk(preAst.moduleElements);
|
||||
}
|
||||
|
||||
function walkModuleNameModuleReferenceChildren(preAst: ModuleNameModuleReferenceSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.moduleName);
|
||||
}
|
||||
|
||||
function walkEnumDeclarationChildren(preAst: EnumDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.enumElements);
|
||||
}
|
||||
|
||||
function walkEnumElementChildren(preAst: EnumElementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.propertyName);
|
||||
walker.walk(preAst.equalsValueClause);
|
||||
}
|
||||
|
||||
function walkImportDeclarationChildren(preAst: ImportDeclarationSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.moduleReference);
|
||||
}
|
||||
|
||||
function walkExportAssignmentChildren(preAst: ExportAssignmentSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
}
|
||||
|
||||
function walkWithStatementChildren(preAst: WithStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.condition);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkExpressionStatementChildren(preAst: ExpressionStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.expression);
|
||||
}
|
||||
|
||||
function walkLabeledStatementChildren(preAst: LabeledStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.identifier);
|
||||
walker.walk(preAst.statement);
|
||||
}
|
||||
|
||||
function walkVariableStatementChildren(preAst: VariableStatementSyntax, walker: AstWalker): void {
|
||||
walker.walk(preAst.variableDeclaration);
|
||||
}
|
||||
|
||||
var childrenWalkers: IAstWalkChildren[] = new Array<IAstWalkChildren>(SyntaxKind.LastNode + 1);
|
||||
|
||||
// Tokens/trivia can't ever be walked into.
|
||||
for (var i = SyntaxKind.FirstToken, n = SyntaxKind.LastToken; i <= n; i++) {
|
||||
childrenWalkers[i] = null;
|
||||
}
|
||||
for (var i = SyntaxKind.FirstTrivia, n = SyntaxKind.LastTrivia; i <= n; i++) {
|
||||
childrenWalkers[i] = null;
|
||||
}
|
||||
|
||||
childrenWalkers[SyntaxKind.AddAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AddExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AndAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AnyKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.ArgumentList] = walkArgumentListChildren;
|
||||
childrenWalkers[SyntaxKind.ArrayLiteralExpression] = walkArrayLiteralExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ArrayType] = walkArrayTypeChildren;
|
||||
childrenWalkers[SyntaxKind.SimpleArrowFunctionExpression] = walkSimpleArrowFunctionExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ParenthesizedArrowFunctionExpression] = walkParenthesizedArrowFunctionExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.AssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseAndExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseExclusiveOrExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseNotExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.BitwiseOrExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.Block] = walkBlockChildren;
|
||||
childrenWalkers[SyntaxKind.BooleanKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.BreakStatement] = null;
|
||||
childrenWalkers[SyntaxKind.CallSignature] = walkCallSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.CaseSwitchClause] = walkCaseSwitchClauseChildren;
|
||||
childrenWalkers[SyntaxKind.CastExpression] = walkCastExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.CatchClause] = walkCatchClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ClassDeclaration] = walkClassDeclChildren;
|
||||
childrenWalkers[SyntaxKind.CommaExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ConditionalExpression] = walkTrinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.Constraint] = walkConstraintChildren;
|
||||
childrenWalkers[SyntaxKind.ConstructorDeclaration] = walkConstructorDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.ConstructSignature] = walkConstructSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.ContinueStatement] = null;
|
||||
childrenWalkers[SyntaxKind.ConstructorType] = walkConstructorTypeChildren;
|
||||
childrenWalkers[SyntaxKind.DebuggerStatement] = null;
|
||||
childrenWalkers[SyntaxKind.DefaultSwitchClause] = walkDefaultSwitchClauseChildren;
|
||||
childrenWalkers[SyntaxKind.DeleteExpression] = walkDeleteExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.DivideAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.DivideExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.DoStatement] = walkDoStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ElementAccessExpression] = walkElementAccessExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ElseClause] = walkElseClauseChildren;
|
||||
childrenWalkers[SyntaxKind.EmptyStatement] = null;
|
||||
childrenWalkers[SyntaxKind.EnumDeclaration] = walkEnumDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.EnumElement] = walkEnumElementChildren;
|
||||
childrenWalkers[SyntaxKind.EqualsExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.EqualsValueClause] = walkEqualsValueClauseChildren;
|
||||
childrenWalkers[SyntaxKind.EqualsWithTypeConversionExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ExclusiveOrAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ExportAssignment] = walkExportAssignmentChildren;
|
||||
childrenWalkers[SyntaxKind.ExpressionStatement] = walkExpressionStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ExtendsHeritageClause] = walkHeritageClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ExternalModuleReference] = walkExternalModuleReferenceChildren;
|
||||
childrenWalkers[SyntaxKind.FalseKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.FinallyClause] = walkFinallyClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ForInStatement] = walkForInStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ForStatement] = walkForStatementChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionDeclaration] = walkFuncDeclChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionExpression] = walkFunctionExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionPropertyAssignment] = walkFunctionPropertyAssignmentChildren;
|
||||
childrenWalkers[SyntaxKind.FunctionType] = walkFunctionTypeChildren;
|
||||
childrenWalkers[SyntaxKind.GenericType] = walkGenericTypeChildren;
|
||||
childrenWalkers[SyntaxKind.GetAccessor] = walkGetAccessorChildren;
|
||||
childrenWalkers[SyntaxKind.GreaterThanExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.GreaterThanOrEqualExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.IfStatement] = walkIfStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ImplementsHeritageClause] = walkHeritageClauseChildren;
|
||||
childrenWalkers[SyntaxKind.ImportDeclaration] = walkImportDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.IndexMemberDeclaration] = walkIndexMemberDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.IndexSignature] = walkIndexSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.InExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.InstanceOfExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.InterfaceDeclaration] = walkInterfaceDeclerationChildren;
|
||||
childrenWalkers[SyntaxKind.InvocationExpression] = walkInvocationExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LabeledStatement] = walkLabeledStatementChildren;
|
||||
childrenWalkers[SyntaxKind.LeftShiftAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LeftShiftExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LessThanExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LessThanOrEqualExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.List] = walkListChildren;
|
||||
childrenWalkers[SyntaxKind.LogicalAndExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LogicalNotExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.LogicalOrExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MemberAccessExpression] = walkMemberAccessExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MemberFunctionDeclaration] = walkMemberFunctionDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.MemberVariableDeclaration] = walkMemberVariableDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.MethodSignature] = walkMethodSignatureChildren;
|
||||
childrenWalkers[SyntaxKind.ModuleDeclaration] = walkModuleDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.ModuleNameModuleReference] = walkModuleNameModuleReferenceChildren;
|
||||
childrenWalkers[SyntaxKind.ModuloAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ModuloExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MultiplyAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.MultiplyExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.IdentifierName] = null;
|
||||
childrenWalkers[SyntaxKind.NegateExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.None] = null;
|
||||
childrenWalkers[SyntaxKind.NotEqualsExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.NotEqualsWithTypeConversionExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.NullKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.NumberKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.NumericLiteral] = null;
|
||||
childrenWalkers[SyntaxKind.ObjectCreationExpression] = walkObjectCreationExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ObjectLiteralExpression] = walkObjectLiteralExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.ObjectType] = walkObjectTypeChildren;
|
||||
childrenWalkers[SyntaxKind.OmittedExpression] = null;
|
||||
childrenWalkers[SyntaxKind.OrAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.Parameter] = walkParameterChildren;
|
||||
childrenWalkers[SyntaxKind.ParameterList] = walkParameterListChildren;
|
||||
childrenWalkers[SyntaxKind.ParenthesizedExpression] = walkParenthesizedExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PlusExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PostDecrementExpression] = walkPostfixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PostIncrementExpression] = walkPostfixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PreDecrementExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PreIncrementExpression] = walkPrefixUnaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.PropertySignature] = walkPropertySignatureChildren;
|
||||
childrenWalkers[SyntaxKind.QualifiedName] = walkQualifiedNameChildren;
|
||||
childrenWalkers[SyntaxKind.RegularExpressionLiteral] = null;
|
||||
childrenWalkers[SyntaxKind.ReturnStatement] = walkReturnStatementChildren;
|
||||
childrenWalkers[SyntaxKind.SourceUnit] = walkScriptChildren;
|
||||
childrenWalkers[SyntaxKind.SeparatedList] = walkSeparatedListChildren;
|
||||
childrenWalkers[SyntaxKind.SetAccessor] = walkSetAccessorChildren;
|
||||
childrenWalkers[SyntaxKind.SignedRightShiftAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SignedRightShiftExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SimplePropertyAssignment] = walkSimplePropertyAssignmentChildren;
|
||||
childrenWalkers[SyntaxKind.StringLiteral] = null;
|
||||
childrenWalkers[SyntaxKind.StringKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.SubtractAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SubtractExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.SuperKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.SwitchStatement] = walkSwitchStatementChildren;
|
||||
childrenWalkers[SyntaxKind.ThisKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.ThrowStatement] = walkThrowStatementChildren;
|
||||
childrenWalkers[SyntaxKind.TriviaList] = null;
|
||||
childrenWalkers[SyntaxKind.TrueKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.TryStatement] = walkTryStatementChildren;
|
||||
childrenWalkers[SyntaxKind.TupleType] = walkTupleTypeChildren;
|
||||
childrenWalkers[SyntaxKind.TypeAnnotation] = walkTypeAnnotationChildren;
|
||||
childrenWalkers[SyntaxKind.TypeArgumentList] = walkTypeArgumentListChildren;
|
||||
childrenWalkers[SyntaxKind.TypeOfExpression] = walkTypeOfExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.TypeParameter] = walkTypeParameterChildren;
|
||||
childrenWalkers[SyntaxKind.TypeParameterList] = walkTypeParameterListChildren;
|
||||
childrenWalkers[SyntaxKind.TypeQuery] = walkTypeQueryChildren;
|
||||
childrenWalkers[SyntaxKind.UnsignedRightShiftAssignmentExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.UnsignedRightShiftExpression] = walkBinaryExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.VariableDeclaration] = walkVariableDeclarationChildren;
|
||||
childrenWalkers[SyntaxKind.VariableDeclarator] = walkVariableDeclaratorChildren;
|
||||
childrenWalkers[SyntaxKind.VariableStatement] = walkVariableStatementChildren;
|
||||
childrenWalkers[SyntaxKind.VoidExpression] = walkVoidExpressionChildren;
|
||||
childrenWalkers[SyntaxKind.VoidKeyword] = null;
|
||||
childrenWalkers[SyntaxKind.WhileStatement] = walkWhileStatementChildren;
|
||||
childrenWalkers[SyntaxKind.WithStatement] = walkWithStatementChildren;
|
||||
|
||||
// Verify the code is up to date with the enum
|
||||
for (var e in SyntaxKind) {
|
||||
if (SyntaxKind.hasOwnProperty(e) && StringUtilities.isString(SyntaxKind[e])) {
|
||||
TypeScript.Debug.assert(childrenWalkers[e] !== undefined, "Fix initWalkers: " + SyntaxKind[e]);
|
||||
}
|
||||
}
|
||||
|
||||
export class AstWalkOptions {
|
||||
public goChildren = true;
|
||||
public stopWalking = false;
|
||||
}
|
||||
|
||||
interface IAstWalkChildren {
|
||||
(preAst: ISyntaxElement, walker: AstWalker): void;
|
||||
}
|
||||
|
||||
export interface IAstWalker {
|
||||
options: AstWalkOptions;
|
||||
state: any
|
||||
}
|
||||
|
||||
interface AstWalker {
|
||||
walk(ast: ISyntaxElement): void;
|
||||
}
|
||||
|
||||
class SimplePreAstWalker implements AstWalker {
|
||||
public options: AstWalkOptions = new AstWalkOptions();
|
||||
|
||||
constructor(
|
||||
private pre: (ast: ISyntaxElement, state: any) => void,
|
||||
public state: any) {
|
||||
}
|
||||
|
||||
public walk(ast: ISyntaxElement): void {
|
||||
if (!ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.pre(ast, this.state);
|
||||
|
||||
var walker = childrenWalkers[ast.kind()];
|
||||
if (walker) {
|
||||
walker(ast, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class SimplePrePostAstWalker implements AstWalker {
|
||||
public options: AstWalkOptions = new AstWalkOptions();
|
||||
|
||||
constructor(
|
||||
private pre: (ast: ISyntaxElement, state: any) => void,
|
||||
private post: (ast: ISyntaxElement, state: any) => void,
|
||||
public state: any) {
|
||||
}
|
||||
|
||||
public walk(ast: ISyntaxElement): void {
|
||||
if (!ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.pre(ast, this.state);
|
||||
|
||||
var walker = childrenWalkers[ast.kind()];
|
||||
if (walker) {
|
||||
walker(ast, this);
|
||||
}
|
||||
|
||||
this.post(ast, this.state);
|
||||
}
|
||||
}
|
||||
|
||||
class NormalAstWalker implements AstWalker {
|
||||
public options: AstWalkOptions = new AstWalkOptions();
|
||||
|
||||
constructor(
|
||||
private pre: (ast: ISyntaxElement, walker: IAstWalker) => void,
|
||||
private post: (ast: ISyntaxElement, walker: IAstWalker) => void,
|
||||
public state: any) {
|
||||
}
|
||||
|
||||
public walk(ast: ISyntaxElement): void {
|
||||
if (!ast) {
|
||||
return;
|
||||
}
|
||||
|
||||
// If we're stopping, then bail out immediately.
|
||||
if (this.options.stopWalking) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.pre(ast, this);
|
||||
|
||||
// If we were asked to stop, then stop.
|
||||
if (this.options.stopWalking) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.options.goChildren) {
|
||||
// Call the "walkChildren" function corresponding to "nodeType".
|
||||
var walker = childrenWalkers[ast.kind()];
|
||||
if (walker) {
|
||||
walker(ast, this);
|
||||
}
|
||||
}
|
||||
else {
|
||||
// no go only applies to children of node issuing it
|
||||
this.options.goChildren = true;
|
||||
}
|
||||
|
||||
if (this.post) {
|
||||
this.post(ast, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export class AstWalkerFactory {
|
||||
public walk(ast: ISyntaxElement, pre: (ast: ISyntaxElement, walker: IAstWalker) => void, post?: (ast: ISyntaxElement, walker: IAstWalker) => void, state?: any): void {
|
||||
new NormalAstWalker(pre, post, state).walk(ast);
|
||||
}
|
||||
|
||||
public simpleWalk(ast: ISyntaxElement, pre: (ast: ISyntaxElement, state: any) => void, post?: (ast: ISyntaxElement, state: any) => void, state?: any): void {
|
||||
if (post) {
|
||||
new SimplePrePostAstWalker(pre, post, state).walk(ast);
|
||||
}
|
||||
else {
|
||||
new SimplePreAstWalker(pre, state).walk(ast);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var globalAstWalkerFactory = new AstWalkerFactory();
|
||||
|
||||
export function getAstWalkerFactory(): AstWalkerFactory {
|
||||
return globalAstWalkerFactory;
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,7 @@ module TypeScript {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (array1 === null || array2 === null) {
|
||||
if (!array1 || !array2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -71,7 +71,7 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
public static firstOrDefault<T>(array: T[], func: (v: T, index: number) => boolean): T {
|
||||
@@ -82,7 +82,7 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
public static first<T>(array: T[], func?: (v: T, index: number) => boolean): T {
|
||||
|
||||
@@ -14,13 +14,14 @@ module TypeScript {
|
||||
return this.currentAssertionLevel >= level;
|
||||
}
|
||||
|
||||
public static assert(expression: any, message: string = "", verboseDebugInfo: () => string = null): void {
|
||||
public static assert(expression: any, message?: string, verboseDebugInfo?: () => string): void {
|
||||
if (!expression) {
|
||||
var verboseDebugString = "";
|
||||
if (verboseDebugInfo) {
|
||||
verboseDebugString = "\r\nVerbose Debug Information:" + verboseDebugInfo();
|
||||
}
|
||||
|
||||
message = message || "";
|
||||
throw new Error("Debug Failure. False expression: " + message + verboseDebugString);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -50,11 +50,11 @@ module TypeScript {
|
||||
private _arguments: any[];
|
||||
private _additionalLocations: Location[];
|
||||
|
||||
constructor(fileName: string, lineMap: LineMap, start: number, length: number, diagnosticKey: string, _arguments: any[]= null, additionalLocations: Location[] = null) {
|
||||
constructor(fileName: string, lineMap: LineMap, start: number, length: number, diagnosticKey: string, _arguments?: any[], additionalLocations?: Location[]) {
|
||||
super(fileName, lineMap, start, length);
|
||||
this._diagnosticKey = diagnosticKey;
|
||||
this._arguments = (_arguments && _arguments.length > 0) ? _arguments : null;
|
||||
this._additionalLocations = (additionalLocations && additionalLocations.length > 0) ? additionalLocations : null;
|
||||
this._arguments = (_arguments && _arguments.length > 0) ? _arguments : undefined;
|
||||
this._additionalLocations = (additionalLocations && additionalLocations.length > 0) ? additionalLocations : undefined;
|
||||
}
|
||||
|
||||
public toJSON(key: any): any {
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
module TypeScript {
|
||||
export class LineMap {
|
||||
public static empty = new LineMap(() => [0], 0);
|
||||
private _lineStarts: number[] = null;
|
||||
private _lineStarts: number[] = undefined;
|
||||
|
||||
constructor(private _computeLineStarts: () => number[], private length: number) {
|
||||
}
|
||||
@@ -18,7 +18,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
public lineStarts(): number[] {
|
||||
if (this._lineStarts === null) {
|
||||
if (!this._lineStarts) {
|
||||
this._lineStarts = this._computeLineStarts();
|
||||
}
|
||||
|
||||
|
||||
@@ -52,7 +52,7 @@ module TypeScript.Services.Formatting {
|
||||
rulesProvider: RulesProvider,
|
||||
formattingRequestKind: FormattingRequestKind): TextEditInfo[] {
|
||||
var walker = new Formatter(textSpan, sourceUnit, indentFirstToken, options, snapshot, rulesProvider, formattingRequestKind);
|
||||
visitNodeOrToken(walker, sourceUnit);
|
||||
walker.walk(sourceUnit);
|
||||
return walker.edits();
|
||||
}
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@
|
||||
///<reference path='formatting.ts' />
|
||||
|
||||
module TypeScript.Services.Formatting {
|
||||
export class IndentationTrackingWalker extends SyntaxWalker {
|
||||
export class IndentationTrackingWalker {
|
||||
private _position: number = 0;
|
||||
private _parent: IndentationNodeContext = null;
|
||||
private _textSpan: TextSpan;
|
||||
@@ -26,8 +26,6 @@ module TypeScript.Services.Formatting {
|
||||
private _text: ISimpleText;
|
||||
|
||||
constructor(textSpan: TextSpan, sourceUnit: SourceUnitSyntax, snapshot: ITextSnapshot, indentFirstToken: boolean, public options: FormattingOptions) {
|
||||
super();
|
||||
|
||||
// Create a pool object to manage context nodes while walking the tree
|
||||
this._indentationNodeContextPool = new IndentationNodeContextPool();
|
||||
|
||||
@@ -100,7 +98,23 @@ module TypeScript.Services.Formatting {
|
||||
this._position += token.fullWidth();
|
||||
}
|
||||
|
||||
public visitNode(node: ISyntaxNode): void {
|
||||
public walk(element: ISyntaxElement) {
|
||||
if (element && !isShared(element)) {
|
||||
if (isToken(element)) {
|
||||
this.visitToken(<ISyntaxToken>element);
|
||||
}
|
||||
else if (element.kind() === SyntaxKind.List || element.kind() === SyntaxKind.SeparatedList) {
|
||||
for (var i = 0, n = childCount(element); i < n; i++) {
|
||||
this.walk(childAt(element, i));
|
||||
}
|
||||
}
|
||||
else {
|
||||
this.visitNode(<ISyntaxNode>element);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private visitNode(node: ISyntaxNode): void {
|
||||
var nodeSpan = new TextSpan(this._position, fullWidth(node));
|
||||
|
||||
if (nodeSpan.intersectsWithTextSpan(this._textSpan)) {
|
||||
@@ -112,7 +126,9 @@ module TypeScript.Services.Formatting {
|
||||
this._parent = this._indentationNodeContextPool.getNode(currentParent, node, this._position, indentation.indentationAmount, indentation.indentationAmountDelta);
|
||||
|
||||
// Visit node
|
||||
visitNodeOrToken(this, node);
|
||||
for (var i = 0, n = childCount(node); i < n; i++) {
|
||||
this.walk(childAt(node, i));
|
||||
}
|
||||
|
||||
// Reset state
|
||||
this._indentationNodeContextPool.releaseNode(this._parent);
|
||||
|
||||
+29
-47
@@ -71,8 +71,6 @@ module ts {
|
||||
}
|
||||
|
||||
export interface SourceFile {
|
||||
getSourceUnit(): TypeScript.SourceUnitSyntax;
|
||||
getSyntaxTree(): TypeScript.SyntaxTree;
|
||||
getScriptSnapshot(): TypeScript.IScriptSnapshot;
|
||||
getNamedDeclarations(): Declaration[];
|
||||
update(scriptSnapshot: TypeScript.IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TypeScript.TextChangeRange): SourceFile;
|
||||
@@ -660,23 +658,13 @@ module ts {
|
||||
public languageVersion: ScriptTarget;
|
||||
public identifiers: Map<string>;
|
||||
|
||||
private syntaxTree: TypeScript.SyntaxTree;
|
||||
private scriptSnapshot: TypeScript.IScriptSnapshot;
|
||||
private namedDeclarations: Declaration[];
|
||||
|
||||
public getSourceUnit(): TypeScript.SourceUnitSyntax {
|
||||
// If we don't have a script, create one from our parse tree.
|
||||
return this.getSyntaxTree().sourceUnit();
|
||||
}
|
||||
|
||||
public getScriptSnapshot(): TypeScript.IScriptSnapshot {
|
||||
return this.scriptSnapshot;
|
||||
}
|
||||
|
||||
public getLineMap(): TypeScript.LineMap {
|
||||
return this.getSyntaxTree().lineMap();
|
||||
}
|
||||
|
||||
public getNamedDeclarations() {
|
||||
if (!this.namedDeclarations) {
|
||||
var sourceFile = this;
|
||||
@@ -749,32 +737,11 @@ module ts {
|
||||
return this.namedDeclarations;
|
||||
}
|
||||
|
||||
public getSyntaxTree(): TypeScript.SyntaxTree {
|
||||
if (!this.syntaxTree) {
|
||||
var start = new Date().getTime();
|
||||
|
||||
this.syntaxTree = TypeScript.Parser.parse(
|
||||
this.filename, TypeScript.SimpleText.fromScriptSnapshot(this.scriptSnapshot), this.languageVersion, this.isDeclareFile());
|
||||
|
||||
var time = new Date().getTime() - start;
|
||||
|
||||
//TypeScript.syntaxTreeParseTime += time;
|
||||
}
|
||||
|
||||
return this.syntaxTree;
|
||||
}
|
||||
|
||||
private isDeclareFile(): boolean {
|
||||
return TypeScript.isDTSFile(this.filename);
|
||||
}
|
||||
|
||||
public update(scriptSnapshot: TypeScript.IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TypeScript.TextChangeRange): SourceFile {
|
||||
// See if we are currently holding onto a syntax tree. We may not be because we're
|
||||
// either a closed file, or we've just been lazy and haven't had to create the syntax
|
||||
// tree yet. Access the field instead of the method so we don't accidentally realize
|
||||
// the old syntax tree.
|
||||
var oldSyntaxTree = this.syntaxTree;
|
||||
|
||||
if (textChangeRange && Debug.shouldAssert(AssertionLevel.Normal)) {
|
||||
var oldText = this.scriptSnapshot;
|
||||
var newText = scriptSnapshot;
|
||||
@@ -792,21 +759,12 @@ module ts {
|
||||
}
|
||||
}
|
||||
|
||||
var text = TypeScript.SimpleText.fromScriptSnapshot(scriptSnapshot);
|
||||
|
||||
// If we don't have a text change, or we don't have an old syntax tree, then do a full
|
||||
// parse. Otherwise, do an incremental parse.
|
||||
var newSyntaxTree = !textChangeRange || !oldSyntaxTree
|
||||
? TypeScript.Parser.parse(this.filename, text, this.languageVersion, TypeScript.isDTSFile(this.filename))
|
||||
: TypeScript.IncrementalParser.parse(oldSyntaxTree, textChangeRange, text);
|
||||
|
||||
return SourceFileObject.createSourceFileObject(this.filename, scriptSnapshot, this.languageVersion, version, isOpen, newSyntaxTree);
|
||||
return SourceFileObject.createSourceFileObject(this.filename, scriptSnapshot, this.languageVersion, version, isOpen);
|
||||
}
|
||||
|
||||
public static createSourceFileObject(filename: string, scriptSnapshot: TypeScript.IScriptSnapshot, languageVersion: ScriptTarget, version: string, isOpen: boolean, syntaxTree?: TypeScript.SyntaxTree) {
|
||||
public static createSourceFileObject(filename: string, scriptSnapshot: TypeScript.IScriptSnapshot, languageVersion: ScriptTarget, version: string, isOpen: boolean) {
|
||||
var newSourceFile = <SourceFileObject><any>createSourceFile(filename, scriptSnapshot.getText(0, scriptSnapshot.getLength()), languageVersion, version, isOpen);
|
||||
newSourceFile.scriptSnapshot = scriptSnapshot;
|
||||
newSourceFile.syntaxTree = syntaxTree;
|
||||
return newSourceFile;
|
||||
}
|
||||
}
|
||||
@@ -1328,7 +1286,7 @@ module ts {
|
||||
return "";
|
||||
}
|
||||
|
||||
interface DisplayPartsSymbolWriter extends SymbolWriter {
|
||||
export interface DisplayPartsSymbolWriter extends SymbolWriter {
|
||||
displayParts(): SymbolDisplayPart[];
|
||||
}
|
||||
|
||||
@@ -1637,7 +1595,9 @@ module ts {
|
||||
private initialize(filename: string) {
|
||||
// ensure that both source file and syntax tree are either initialized or not initialized
|
||||
Debug.assert(!!this.currentFileSyntaxTree === !!this.currentSourceFile);
|
||||
var start = new Date().getTime();
|
||||
this.hostCache = new HostCache(this.host);
|
||||
this.host.log("SyntaxTreeCache.Initialize: new HostCache: " + (new Date().getTime() - start));
|
||||
|
||||
var version = this.hostCache.getVersion(filename);
|
||||
var syntaxTree: TypeScript.SyntaxTree = null;
|
||||
@@ -1645,22 +1605,37 @@ module ts {
|
||||
|
||||
if (this.currentFileSyntaxTree === null || this.currentFilename !== filename) {
|
||||
var scriptSnapshot = this.hostCache.getScriptSnapshot(filename);
|
||||
var start = new Date().getTime();
|
||||
syntaxTree = this.createSyntaxTree(filename, scriptSnapshot);
|
||||
sourceFile = createSourceFileFromScriptSnapshot(filename, scriptSnapshot, getDefaultCompilerOptions(), version, /*isOpen*/ true);
|
||||
this.host.log("SyntaxTreeCache.Initialize: createSyntaxTree: " + (new Date().getTime() - start));
|
||||
|
||||
var start = new Date().getTime();
|
||||
sourceFile = createSourceFileFromScriptSnapshot(filename, scriptSnapshot, getDefaultCompilerOptions(), version, /*isOpen*/ true);
|
||||
this.host.log("SyntaxTreeCache.Initialize: createSourceFile: " + (new Date().getTime() - start));
|
||||
|
||||
var start = new Date().getTime();
|
||||
fixupParentReferences(sourceFile);
|
||||
this.host.log("SyntaxTreeCache.Initialize: fixupParentRefs : " + (new Date().getTime() - start));
|
||||
}
|
||||
else if (this.currentFileVersion !== version) {
|
||||
var scriptSnapshot = this.hostCache.getScriptSnapshot(filename);
|
||||
|
||||
var start = new Date().getTime();
|
||||
syntaxTree = this.updateSyntaxTree(filename, scriptSnapshot,
|
||||
this.currentSourceFile.getScriptSnapshot(), this.currentFileSyntaxTree, this.currentFileVersion);
|
||||
this.host.log("SyntaxTreeCache.Initialize: updateSyntaxTree: " + (new Date().getTime() - start));
|
||||
|
||||
var editRange = this.hostCache.getChangeRange(filename, this.currentFileVersion, this.currentSourceFile.getScriptSnapshot());
|
||||
|
||||
var start = new Date().getTime();
|
||||
sourceFile = !editRange
|
||||
? createSourceFileFromScriptSnapshot(filename, scriptSnapshot, getDefaultCompilerOptions(), version, /*isOpen*/ true)
|
||||
: this.currentSourceFile.update(scriptSnapshot, version, /*isOpen*/ true, editRange);
|
||||
this.host.log("SyntaxTreeCache.Initialize: updateSourceFile: " + (new Date().getTime() - start));
|
||||
|
||||
var start = new Date().getTime();
|
||||
fixupParentReferences(sourceFile);
|
||||
this.host.log("SyntaxTreeCache.Initialize: fixupParentRefs : " + (new Date().getTime() - start));
|
||||
}
|
||||
|
||||
if (syntaxTree !== null) {
|
||||
@@ -5093,10 +5068,17 @@ module ts {
|
||||
function getIndentationAtPosition(filename: string, position: number, editorOptions: EditorOptions) {
|
||||
filename = TypeScript.switchToForwardSlashes(filename);
|
||||
|
||||
var start = new Date().getTime();
|
||||
var sourceFile = getCurrentSourceFile(filename);
|
||||
host.log("getIndentationAtPosition: getCurrentSourceFile: " + (new Date().getTime() - start));
|
||||
|
||||
var start = new Date().getTime();
|
||||
var options = new TypeScript.FormattingOptions(!editorOptions.ConvertTabsToSpaces, editorOptions.TabSize, editorOptions.IndentSize, editorOptions.NewLineCharacter)
|
||||
|
||||
return formatting.SmartIndenter.getIndentation(position, sourceFile, options);
|
||||
var result = formatting.SmartIndenter.getIndentation(position, sourceFile, options);
|
||||
host.log("getIndentationAtPosition: computeIndentation : " + (new Date().getTime() - start));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function getFormattingManager(filename: string, options: FormatCodeOptions) {
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
module TypeScript {
|
||||
export class SyntaxVisitor implements ISyntaxVisitor {
|
||||
public defaultVisit(node: ISyntaxNodeOrToken): any {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
public visitToken(token: ISyntaxToken): any {
|
||||
@@ -46,6 +46,14 @@ module TypeScript {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
public visitUnionType(node: UnionTypeSyntax): any {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
public visitParenthesizedType(node: ParenthesizedTypeSyntax): any {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
public visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): any {
|
||||
return this.defaultVisit(node);
|
||||
}
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
///<reference path='references.ts' />
|
||||
|
||||
module TypeScript {
|
||||
export class DepthLimitedWalker extends SyntaxWalker {
|
||||
private _depth: number = 0;
|
||||
private _maximumDepth: number = 0;
|
||||
|
||||
constructor(maximumDepth: number) {
|
||||
super();
|
||||
this._maximumDepth = maximumDepth;
|
||||
}
|
||||
|
||||
public visitNode(node: ISyntaxNode): void {
|
||||
if (this._depth < this._maximumDepth) {
|
||||
this._depth++;
|
||||
super.visitNode(node);
|
||||
this._depth--;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -88,8 +88,8 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
function release() {
|
||||
_scannerParserSource.release();
|
||||
_scannerParserSource = null;
|
||||
_oldSourceUnitCursor = null;
|
||||
_scannerParserSource = undefined;
|
||||
_oldSourceUnitCursor = undefined;
|
||||
_outstandingRewindPointCount = 0;
|
||||
}
|
||||
|
||||
@@ -177,13 +177,13 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
// Null out the cursor that the rewind point points to. This way we don't try
|
||||
// to return it in 'releaseRewindPoint'.
|
||||
rewindPoint.oldSourceUnitCursor = null;
|
||||
rewindPoint.oldSourceUnitCursor = undefined;
|
||||
|
||||
_scannerParserSource.rewind(rewindPoint);
|
||||
}
|
||||
|
||||
function releaseRewindPoint(rewindPoint: IParserRewindPoint): void {
|
||||
if (rewindPoint.oldSourceUnitCursor !== null) {
|
||||
if (rewindPoint.oldSourceUnitCursor) {
|
||||
returnSyntaxCursor(rewindPoint.oldSourceUnitCursor);
|
||||
}
|
||||
|
||||
@@ -220,7 +220,7 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
// If our current absolute position is in the middle of the changed range in the new text
|
||||
// then we definitely can't read from the old source unit right now.
|
||||
if (_changeRange !== null && _changeRangeNewSpan.intersectsWithPosition(absolutePosition())) {
|
||||
if (_changeRange && _changeRangeNewSpan.intersectsWithPosition(absolutePosition())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -258,7 +258,7 @@ module TypeScript.IncrementalParser {
|
||||
// Try to read a node. If we can't then our caller will call back in and just try
|
||||
// to get a token.
|
||||
var node = tryGetNodeFromOldSourceUnit();
|
||||
if (node !== null) {
|
||||
if (node) {
|
||||
// Make sure the positions for the tokens in this node are correct.
|
||||
updateTokens(node);
|
||||
return node;
|
||||
@@ -266,13 +266,13 @@ module TypeScript.IncrementalParser {
|
||||
}
|
||||
|
||||
// Either we were ahead of the old text, or we were pinned. No node can be read here.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function currentToken(): ISyntaxToken {
|
||||
if (canReadFromOldSourceUnit()) {
|
||||
var token = tryGetTokenFromOldSourceUnit();
|
||||
if (token !== null) {
|
||||
if (token) {
|
||||
// Make sure the token's position/text is correct.
|
||||
updateTokens(token);
|
||||
return token;
|
||||
@@ -354,9 +354,9 @@ module TypeScript.IncrementalParser {
|
||||
// e) we are still in the same strict or non-strict state that the node was originally parsed in.
|
||||
while (true) {
|
||||
var node = _oldSourceUnitCursor.currentNode();
|
||||
if (node === null) {
|
||||
if (node === undefined) {
|
||||
// Couldn't even read a node, nothing to return.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (!intersectsWithChangeRangeSpanInOriginalText(absolutePosition(), fullWidth(node))) {
|
||||
@@ -395,7 +395,7 @@ module TypeScript.IncrementalParser {
|
||||
// need to make sure that if that the parser asks for a *token* we don't return it.
|
||||
// Converted identifiers can't ever be created by the scanner, and as such, should not
|
||||
// be returned by this source.
|
||||
if (token !== null) {
|
||||
if (token) {
|
||||
if (!intersectsWithChangeRangeSpanInOriginalText(position, token.fullWidth())) {
|
||||
// Didn't intersect with the change range.
|
||||
if (!token.isIncrementallyUnusable() && !Scanner.isContextualToken(token)) {
|
||||
@@ -417,13 +417,13 @@ module TypeScript.IncrementalParser {
|
||||
var token = _oldSourceUnitCursor.currentToken();
|
||||
|
||||
return canReuseTokenFromOldSourceUnit(absolutePosition(), token)
|
||||
? token : null;
|
||||
? token : undefined;
|
||||
}
|
||||
|
||||
function peekToken(n: number): ISyntaxToken {
|
||||
if (canReadFromOldSourceUnit()) {
|
||||
var token = tryPeekTokenFromOldSourceUnit(n);
|
||||
if (token !== null) {
|
||||
if (token) {
|
||||
return token;
|
||||
}
|
||||
}
|
||||
@@ -462,7 +462,7 @@ module TypeScript.IncrementalParser {
|
||||
var interimToken = _oldSourceUnitCursor.currentToken();
|
||||
|
||||
if (!canReuseTokenFromOldSourceUnit(currentPosition, interimToken)) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
currentPosition += interimToken.fullWidth();
|
||||
@@ -471,7 +471,7 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
var token = _oldSourceUnitCursor.currentToken();
|
||||
return canReuseTokenFromOldSourceUnit(currentPosition, token)
|
||||
? token : null;
|
||||
? token : undefined;
|
||||
}
|
||||
|
||||
function consumeNode(node: ISyntaxNode): void {
|
||||
@@ -486,7 +486,7 @@ module TypeScript.IncrementalParser {
|
||||
var _absolutePosition = absolutePosition() + fullWidth(node);
|
||||
_scannerParserSource.resetToPosition(_absolutePosition);
|
||||
|
||||
// Debug.assert(previousToken !== null);
|
||||
// Debug.assert(previousToken !== undefined);
|
||||
// Debug.assert(previousToken.width() > 0);
|
||||
|
||||
//if (!isPastChangeRange()) {
|
||||
@@ -515,7 +515,7 @@ module TypeScript.IncrementalParser {
|
||||
var _absolutePosition = absolutePosition() + currentToken.fullWidth();
|
||||
_scannerParserSource.resetToPosition(_absolutePosition);
|
||||
|
||||
// Debug.assert(previousToken !== null);
|
||||
// Debug.assert(previousToken !== undefined);
|
||||
// Debug.assert(previousToken.width() > 0);
|
||||
|
||||
//if (!isPastChangeRange()) {
|
||||
@@ -543,15 +543,15 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
// Once we're past the change range, we no longer need it. Null it out.
|
||||
// From now on we can check if we're past the change range just by seeing
|
||||
// if this is null.
|
||||
_changeRange = null;
|
||||
// if this is undefined.
|
||||
_changeRange = undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function isPastChangeRange(): boolean {
|
||||
return _changeRange === null;
|
||||
return _changeRange === undefined;
|
||||
}
|
||||
|
||||
return {
|
||||
@@ -605,7 +605,7 @@ module TypeScript.IncrementalParser {
|
||||
if (syntaxCursorPoolCount > 0) {
|
||||
// If we reused an existing cursor, take it out of the pool so no one else uses it.
|
||||
syntaxCursorPoolCount--;
|
||||
syntaxCursorPool[syntaxCursorPoolCount] = null;
|
||||
syntaxCursorPool[syntaxCursorPoolCount] = undefined;
|
||||
}
|
||||
|
||||
return cursor;
|
||||
@@ -652,11 +652,11 @@ module TypeScript.IncrementalParser {
|
||||
for (var i = 0, n = pieces.length; i < n; i++) {
|
||||
var piece = pieces[i];
|
||||
|
||||
if (piece.element === null) {
|
||||
if (piece.element === undefined) {
|
||||
break;
|
||||
}
|
||||
|
||||
piece.element = null;
|
||||
piece.element = undefined;
|
||||
piece.indexInParent = -1;
|
||||
}
|
||||
|
||||
@@ -669,7 +669,7 @@ module TypeScript.IncrementalParser {
|
||||
for (var i = 0, n = other.pieces.length; i < n; i++) {
|
||||
var piece = other.pieces[i];
|
||||
|
||||
if (piece.element === null) {
|
||||
if (piece.element === undefined) {
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -685,13 +685,13 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
function currentNodeOrToken(): ISyntaxNodeOrToken {
|
||||
if (isFinished()) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var result = pieces[currentPieceIndex].element;
|
||||
|
||||
// The current element must always be a node or a token.
|
||||
// Debug.assert(result !== null);
|
||||
// Debug.assert(result !== undefined);
|
||||
// Debug.assert(result.isNode() || result.isToken());
|
||||
|
||||
return <ISyntaxNodeOrToken>result;
|
||||
@@ -699,12 +699,12 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
function currentNode(): ISyntaxNode {
|
||||
var element = currentNodeOrToken();
|
||||
return isNode(element) ? <ISyntaxNode>element : null;
|
||||
return isNode(element) ? <ISyntaxNode>element : undefined;
|
||||
}
|
||||
|
||||
function moveToFirstChild() {
|
||||
var nodeOrToken = currentNodeOrToken();
|
||||
if (nodeOrToken === null) {
|
||||
if (nodeOrToken === undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -721,7 +721,7 @@ module TypeScript.IncrementalParser {
|
||||
// next sibling of the empty node.
|
||||
for (var i = 0, n = childCount(nodeOrToken); i < n; i++) {
|
||||
var child = childAt(nodeOrToken, i);
|
||||
if (child !== null && !isShared(child)) {
|
||||
if (child && !isShared(child)) {
|
||||
// Great, we found a real child. Push that.
|
||||
pushElement(child, /*indexInParent:*/ i);
|
||||
|
||||
@@ -749,7 +749,7 @@ module TypeScript.IncrementalParser {
|
||||
for (var i = currentPiece.indexInParent + 1, n = childCount(parent); i < n; i++) {
|
||||
var sibling = childAt(parent, i);
|
||||
|
||||
if (sibling !== null && !isShared(sibling)) {
|
||||
if (sibling && !isShared(sibling)) {
|
||||
// We found a good sibling that we can move to. Just reuse our existing piece
|
||||
// so we don't have to push/pop.
|
||||
currentPiece.element = sibling;
|
||||
@@ -766,7 +766,7 @@ module TypeScript.IncrementalParser {
|
||||
|
||||
// Clear the data from the old piece. We don't want to keep any elements around
|
||||
// unintentionally.
|
||||
currentPiece.element = null;
|
||||
currentPiece.element = undefined;
|
||||
currentPiece.indexInParent = -1;
|
||||
|
||||
// Point at the parent. if we move past the top of the path, then we're finished.
|
||||
@@ -787,7 +787,7 @@ module TypeScript.IncrementalParser {
|
||||
}
|
||||
|
||||
function pushElement(element: ISyntaxElement, indexInParent: number): void {
|
||||
// Debug.assert(element !== null);
|
||||
// Debug.assert(element !== undefined);
|
||||
// Debug.assert(indexInParent >= 0);
|
||||
currentPieceIndex++;
|
||||
|
||||
@@ -819,8 +819,8 @@ module TypeScript.IncrementalParser {
|
||||
moveToFirstToken();
|
||||
|
||||
var element = currentNodeOrToken();
|
||||
// Debug.assert(element === null || element.isToken());
|
||||
return element === null ? null : <ISyntaxToken>element;
|
||||
// Debug.assert(element === undefined || element.isToken());
|
||||
return <ISyntaxToken>element;
|
||||
}
|
||||
|
||||
return {
|
||||
|
||||
+235
-147
@@ -130,7 +130,7 @@ module TypeScript.Parser {
|
||||
|
||||
arrayPoolCount--;
|
||||
var result = arrayPool[arrayPoolCount];
|
||||
arrayPool[arrayPoolCount] = null;
|
||||
arrayPool[arrayPoolCount] = undefined;
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -212,9 +212,10 @@ module TypeScript.Parser {
|
||||
// Now, clear out our state so that our singleton parser doesn't keep things alive.
|
||||
diagnostics = [];
|
||||
parseNodeData = SyntaxConstants.None;
|
||||
fileName = null;
|
||||
fileName = undefined;
|
||||
source.release();
|
||||
source = null; _source = null;
|
||||
source = undefined;
|
||||
_source = undefined;
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -265,8 +266,8 @@ module TypeScript.Parser {
|
||||
// Note: we *can* reuse tokens when the strict mode changes. That's because tokens
|
||||
// are unaffected by strict mode. It's just the parser will decide what to do with it
|
||||
// differently depending on what mode it is in.
|
||||
if (node === null || parsedInStrictMode(node) !== isInStrictMode) {
|
||||
return null;
|
||||
if (!node || parsedInStrictMode(node) !== isInStrictMode) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return node;
|
||||
@@ -314,7 +315,7 @@ module TypeScript.Parser {
|
||||
return consumeToken(_currentToken);
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// An identifier is basically any word, unless it is a reserved keyword. so 'foo' is an
|
||||
@@ -367,7 +368,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function eatOptionalIdentifierToken(): ISyntaxToken {
|
||||
return isIdentifier(currentToken()) ? eatIdentifierToken() : null;
|
||||
return isIdentifier(currentToken()) ? eatIdentifierToken() : undefined;
|
||||
}
|
||||
|
||||
// This method should be called when the grammar calls for an *Identifier* and not an
|
||||
@@ -448,10 +449,10 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
// Check if an automatic semicolon could go here. If so, then there's no problem and
|
||||
// we can proceed without error. Return 'null' as there's no actual token for this
|
||||
// we can proceed without error. Return 'undefined' as there's no actual token for this
|
||||
// position.
|
||||
if (canEatAutomaticSemicolon(allowWithoutNewline)) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// No semicolon could be consumed here at all. Just call the standard eating function
|
||||
@@ -471,7 +472,7 @@ module TypeScript.Parser {
|
||||
function getExpectedTokenDiagnostic(expectedKind: SyntaxKind, actual: ISyntaxToken, diagnosticCode: string): Diagnostic {
|
||||
var token = currentToken();
|
||||
|
||||
var args: any[] = null;
|
||||
var args: any[] = undefined;
|
||||
// If a specialized diagnostic message was provided, just use that.
|
||||
if (!diagnosticCode) {
|
||||
// They wanted something specific, just report that that token was missing.
|
||||
@@ -483,7 +484,7 @@ module TypeScript.Parser {
|
||||
// They wanted an identifier.
|
||||
|
||||
// If the user supplied a keyword, give them a specialized message.
|
||||
if (actual !== null && SyntaxFacts.isAnyKeyword(actual.kind())) {
|
||||
if (actual && SyntaxFacts.isAnyKeyword(actual.kind())) {
|
||||
diagnosticCode = DiagnosticCode.Identifier_expected_0_is_a_keyword;
|
||||
args = [SyntaxFacts.getText(actual.kind())];
|
||||
}
|
||||
@@ -860,7 +861,7 @@ module TypeScript.Parser {
|
||||
function tryParseTypeArgumentList(inExpression: boolean): TypeArgumentListSyntax {
|
||||
var _currentToken = currentToken();
|
||||
if (_currentToken.kind() !== SyntaxKind.LessThanToken) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (!inExpression) {
|
||||
@@ -895,7 +896,7 @@ module TypeScript.Parser {
|
||||
if (greaterThanToken.fullWidth() === 0 || !canFollowTypeArgumentListInExpression(currentToken().kind())) {
|
||||
rewind(rewindPoint);
|
||||
releaseRewindPoint(rewindPoint);
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else {
|
||||
releaseRewindPoint(rewindPoint);
|
||||
@@ -982,7 +983,7 @@ module TypeScript.Parser {
|
||||
var token0 = currentToken();
|
||||
var shouldContinue = isIdentifier(token0);
|
||||
if (!shouldContinue) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Call eatIdentifierName to convert the token to an identifier if it is as keyword.
|
||||
@@ -1018,7 +1019,7 @@ module TypeScript.Parser {
|
||||
|
||||
function isEnumElement(inErrorRecovery: boolean): boolean {
|
||||
var node = currentNode();
|
||||
if (node !== null && node.kind() === SyntaxKind.EnumElement) {
|
||||
if (node && node.kind() === SyntaxKind.EnumElement) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1026,18 +1027,18 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function tryParseEnumElementEqualsValueClause(): EqualsValueClauseSyntax {
|
||||
return isEqualsValueClause(/*inParameter*/ false) ? parseEqualsValueClause(/*allowIn:*/ true) : null;
|
||||
return isEqualsValueClause(/*inParameter*/ false) ? parseEqualsValueClause(/*allowIn:*/ true) : undefined;
|
||||
}
|
||||
|
||||
function tryParseEnumElement(inErrorRecovery: boolean): EnumElementSyntax {
|
||||
var node = currentNode();
|
||||
if (node !== null && node.kind() === SyntaxKind.EnumElement) {
|
||||
if (node && node.kind() === SyntaxKind.EnumElement) {
|
||||
consumeNode(node);
|
||||
return <EnumElementSyntax>node;
|
||||
}
|
||||
|
||||
if (!isPropertyName(currentToken(), inErrorRecovery)) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return new syntaxFactory.EnumElementSyntax(parseNodeData, eatPropertyName(), tryParseEnumElementEqualsValueClause());
|
||||
@@ -1115,17 +1116,17 @@ module TypeScript.Parser {
|
||||
var heritageClauses = Syntax.emptyList<HeritageClauseSyntax>();
|
||||
|
||||
if (isHeritageClause()) {
|
||||
// NOTE: we can pass "null" for the skipped tokens here as we know we can't get
|
||||
// NOTE: we can pass "undefined" for the skipped tokens here as we know we can't get
|
||||
// any leading skipped tokens. We have an 'extends' or 'implements' keyword, so
|
||||
// any skipped tokeds will get attached to that instead.
|
||||
heritageClauses= parseSyntaxList<HeritageClauseSyntax>(ListParsingState.ClassOrInterfaceDeclaration_HeritageClauses, null);
|
||||
heritageClauses = parseSyntaxList<HeritageClauseSyntax>(ListParsingState.ClassOrInterfaceDeclaration_HeritageClauses, undefined);
|
||||
}
|
||||
|
||||
return heritageClauses;
|
||||
}
|
||||
|
||||
function tryParseHeritageClauseTypeName(): ITypeSyntax {
|
||||
return isHeritageClauseTypeName() ? tryParseNameOrGenericType() : null;
|
||||
return isHeritageClauseTypeName() ? tryParseNameOrGenericType() : undefined;
|
||||
}
|
||||
|
||||
function parseClassDeclaration(): ClassDeclarationSyntax {
|
||||
@@ -1226,7 +1227,7 @@ module TypeScript.Parser {
|
||||
return parseIndexMemberDeclaration();
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1243,8 +1244,8 @@ module TypeScript.Parser {
|
||||
var constructorKeyword = eatToken(SyntaxKind.ConstructorKeyword);
|
||||
var callSignature = parseCallSignature(/*requireCompleteTypeParameterList:*/ false);
|
||||
|
||||
var semicolonToken: ISyntaxToken = null;
|
||||
var block: BlockSyntax = null;
|
||||
var semicolonToken: ISyntaxToken = undefined;
|
||||
var block: BlockSyntax = undefined;
|
||||
|
||||
if (isBlock()) {
|
||||
block = parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ false, /*checkForStrictMode:*/ true);
|
||||
@@ -1269,8 +1270,8 @@ module TypeScript.Parser {
|
||||
// open brace.
|
||||
var parseBlockEvenWithNoOpenBrace = tryAddUnexpectedEqualsGreaterThanToken(callSignature);
|
||||
|
||||
var block: BlockSyntax = null;
|
||||
var semicolon: ISyntaxToken = null;
|
||||
var block: BlockSyntax = undefined;
|
||||
var semicolon: ISyntaxToken = undefined;
|
||||
|
||||
if (parseBlockEvenWithNoOpenBrace || isBlock()) {
|
||||
block = parseBlock(parseBlockEvenWithNoOpenBrace, /*checkForStrictMode:*/ true);
|
||||
@@ -1375,8 +1376,8 @@ module TypeScript.Parser {
|
||||
// open brace.
|
||||
var parseBlockEvenWithNoOpenBrace = tryAddUnexpectedEqualsGreaterThanToken(callSignature);
|
||||
|
||||
var semicolonToken: ISyntaxToken = null;
|
||||
var block: BlockSyntax = null;
|
||||
var semicolonToken: ISyntaxToken = undefined;
|
||||
var block: BlockSyntax = undefined;
|
||||
|
||||
// Parse a block if we're on a bock, or if we saw a '=>'
|
||||
if (parseBlockEvenWithNoOpenBrace || isBlock()) {
|
||||
@@ -1393,8 +1394,8 @@ module TypeScript.Parser {
|
||||
var modifiers = parseModifiers();
|
||||
var moduleKeyword = eatToken(SyntaxKind.ModuleKeyword);
|
||||
|
||||
var moduleName: INameSyntax = null;
|
||||
var stringLiteral: ISyntaxToken = null;
|
||||
var moduleName: INameSyntax = undefined;
|
||||
var stringLiteral: ISyntaxToken = undefined;
|
||||
|
||||
if (currentToken().kind() === SyntaxKind.StringLiteral) {
|
||||
stringLiteral = eatToken(SyntaxKind.StringLiteral);
|
||||
@@ -1485,7 +1486,7 @@ module TypeScript.Parser {
|
||||
return parsePropertySignature();
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1606,7 +1607,7 @@ module TypeScript.Parser {
|
||||
var extendsOrImplementsKeyword = currentToken();
|
||||
var tokenKind = extendsOrImplementsKeyword.kind();
|
||||
if (tokenKind !== SyntaxKind.ExtendsKeyword && tokenKind !== SyntaxKind.ImplementsKeyword) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
consumeToken(extendsOrImplementsKeyword);
|
||||
@@ -1754,7 +1755,7 @@ module TypeScript.Parser {
|
||||
// and we should not parse it out here.
|
||||
if (SyntaxFacts.isIdentifierNameOrAnyKeyword(peekToken(1))) {
|
||||
// Definitely not a statement.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
@@ -1780,7 +1781,7 @@ module TypeScript.Parser {
|
||||
// existing block properly. We don't want to accidently consume these as expression
|
||||
// below.
|
||||
if (isInterfaceEnumClassModuleImportOrExport(modifierCount)) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else if (isVariableStatement(modifierCount)) {
|
||||
return parseVariableStatement();
|
||||
@@ -1798,7 +1799,7 @@ module TypeScript.Parser {
|
||||
return parseExpressionStatement();
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1833,15 +1834,15 @@ module TypeScript.Parser {
|
||||
var block = parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ false, /*checkForStrictMode:*/ false);
|
||||
listParsingState = savedListParsingState;
|
||||
|
||||
var catchClause: CatchClauseSyntax = null;
|
||||
var catchClause: CatchClauseSyntax = undefined;
|
||||
if (currentToken().kind() === SyntaxKind.CatchKeyword) {
|
||||
catchClause = parseCatchClause();
|
||||
}
|
||||
|
||||
// If we don't have a catch clause, then we must have a finally clause. Try to parse
|
||||
// one out no matter what.
|
||||
var finallyClause: FinallyClauseSyntax = null;
|
||||
if (catchClause === null || currentToken().kind() === SyntaxKind.FinallyKeyword) {
|
||||
var finallyClause: FinallyClauseSyntax = undefined;
|
||||
if (!catchClause || currentToken().kind() === SyntaxKind.FinallyKeyword) {
|
||||
finallyClause = parseFinallyClause();
|
||||
}
|
||||
|
||||
@@ -1929,8 +1930,8 @@ module TypeScript.Parser {
|
||||
|
||||
var variableDeclaration = parseVariableDeclaration(/*allowIn:*/ false);
|
||||
return currentToken().kind() === SyntaxKind.InKeyword
|
||||
? parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null)
|
||||
: parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null);
|
||||
? parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, undefined)
|
||||
: parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, undefined);
|
||||
}
|
||||
|
||||
function parseForInStatementWithVariableDeclarationOrInitializer(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax): ForInStatementSyntax {
|
||||
@@ -1949,8 +1950,8 @@ module TypeScript.Parser {
|
||||
|
||||
var initializer = parseExpression(/*allowIn:*/ false);
|
||||
return currentToken().kind() === SyntaxKind.InKeyword
|
||||
? parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer)
|
||||
: parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer);
|
||||
? parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, undefined, initializer)
|
||||
: parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, undefined, initializer);
|
||||
}
|
||||
|
||||
function parseForStatementWithNoVariableDeclarationOrInitializer(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken): ForStatementSyntax {
|
||||
@@ -1958,7 +1959,7 @@ module TypeScript.Parser {
|
||||
// Debug.assert(currentToken().kind() === SyntaxKind.SemicolonToken);
|
||||
// for ( ; Expressionopt ; Expressionopt ) Statement
|
||||
|
||||
return parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, /*variableDeclaration:*/ null, /*initializer:*/ null);
|
||||
return parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, /*variableDeclaration:*/ undefined, /*initializer:*/ undefined);
|
||||
}
|
||||
|
||||
function tryParseForStatementCondition(): IExpressionSyntax {
|
||||
@@ -1969,7 +1970,7 @@ module TypeScript.Parser {
|
||||
return parseExpression(/*allowIn:*/ true);
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function tryParseForStatementIncrementor(): IExpressionSyntax {
|
||||
@@ -1979,7 +1980,7 @@ module TypeScript.Parser {
|
||||
return parseExpression(/*allowIn:*/ true);
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function parseForStatementWithVariableDeclarationOrInitializer(forKeyword: ISyntaxToken, openParenToken: ISyntaxToken, variableDeclaration: VariableDeclarationSyntax, initializer: IExpressionSyntax): ForStatementSyntax {
|
||||
@@ -1997,14 +1998,14 @@ module TypeScript.Parser {
|
||||
function tryEatBreakOrContinueLabel(): ISyntaxToken {
|
||||
// If there is no newline after the break keyword, then we can consume an optional
|
||||
// identifier.
|
||||
var identifier: ISyntaxToken = null;
|
||||
var identifier: ISyntaxToken = undefined;
|
||||
if (!canEatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false)) {
|
||||
if (isIdentifier(currentToken())) {
|
||||
return eatIdentifierToken();
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function parseBreakStatement(breakKeyword: ISyntaxToken): BreakStatementSyntax {
|
||||
@@ -2062,7 +2063,7 @@ module TypeScript.Parser {
|
||||
return parseDefaultSwitchClause(_currentToken);
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2108,7 +2109,7 @@ module TypeScript.Parser {
|
||||
// throw could be terminated with a semicolon. Note: we can't call 'parseExpression'
|
||||
// directly as that might consume an expression on the following line.
|
||||
return canEatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false)
|
||||
? createMissingToken(SyntaxKind.IdentifierName, null)
|
||||
? createMissingToken(SyntaxKind.IdentifierName, undefined)
|
||||
: parseExpression(/*allowIn:*/ true);
|
||||
}
|
||||
|
||||
@@ -2118,7 +2119,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function tryParseReturnStatementExpression(): IExpressionSyntax {
|
||||
return !canEatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false) ? parseExpression(/*allowIn:*/ true) : null;
|
||||
return !canEatExplicitOrAutomaticSemicolon(/*allowWithoutNewline:*/ false) ? parseExpression(/*allowIn:*/ true) : undefined;
|
||||
}
|
||||
|
||||
function parseReturnStatement(returnKeyword: ISyntaxToken): ReturnStatementSyntax {
|
||||
@@ -2225,7 +2226,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function parseOptionalElseClause(): ElseClauseSyntax {
|
||||
return currentToken().kind() === SyntaxKind.ElseKeyword ? parseElseClause() : null;
|
||||
return currentToken().kind() === SyntaxKind.ElseKeyword ? parseElseClause() : undefined;
|
||||
}
|
||||
|
||||
function parseElseClause(): ElseClauseSyntax {
|
||||
@@ -2260,7 +2261,7 @@ module TypeScript.Parser {
|
||||
|
||||
function isVariableDeclarator(): boolean {
|
||||
var node = currentNode();
|
||||
if (node !== null && node.kind() === SyntaxKind.VariableDeclarator) {
|
||||
if (node && node.kind() === SyntaxKind.VariableDeclarator) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -2268,7 +2269,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function canReuseVariableDeclaratorNode(node: ISyntaxNode) {
|
||||
if (node === null || node.kind() !== SyntaxKind.VariableDeclarator) {
|
||||
if (!node || node.kind() !== SyntaxKind.VariableDeclarator) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -2287,7 +2288,7 @@ module TypeScript.Parser {
|
||||
// In order to prevent this, we do not allow a variable declarator to be reused if it
|
||||
// has an initializer.
|
||||
var variableDeclarator = <VariableDeclaratorSyntax>node;
|
||||
return variableDeclarator.equalsValueClause === null;
|
||||
return variableDeclarator.equalsValueClause === undefined;
|
||||
}
|
||||
|
||||
function tryParseVariableDeclarator(allowIn: boolean, allowPropertyName: boolean): VariableDeclaratorSyntax {
|
||||
@@ -2308,12 +2309,12 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
if (!allowPropertyName && !isIdentifier(currentToken())) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var propertyName = allowPropertyName ? eatPropertyName() : eatIdentifierToken();
|
||||
var equalsValueClause: EqualsValueClauseSyntax = null;
|
||||
var typeAnnotation: TypeAnnotationSyntax = null;
|
||||
var equalsValueClause: EqualsValueClauseSyntax = undefined;
|
||||
var typeAnnotation: TypeAnnotationSyntax = undefined;
|
||||
|
||||
if (propertyName.fullWidth() > 0) {
|
||||
typeAnnotation = parseOptionalTypeAnnotation(/*allowStringLiteral:*/ false);
|
||||
@@ -2419,7 +2420,7 @@ module TypeScript.Parser {
|
||||
// with AssignmentExpression if we see one.
|
||||
var _currentToken = currentToken();
|
||||
var arrowFunction = tryParseAnyArrowFunctionExpression(_currentToken);
|
||||
if (arrowFunction !== null) {
|
||||
if (arrowFunction) {
|
||||
return arrowFunction;
|
||||
}
|
||||
|
||||
@@ -2433,8 +2434,8 @@ module TypeScript.Parser {
|
||||
// binary expression here, so we pass in the 'lowest' precedence here so that it matches
|
||||
// and consumes anything.
|
||||
var leftOperand = tryParseBinaryExpressionOrHigher(_currentToken, force, BinaryExpressionPrecedence.Lowest, allowIn);
|
||||
if (leftOperand === null) {
|
||||
return null;
|
||||
if (leftOperand === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (SyntaxUtilities.isLeftHandSizeExpression(leftOperand)) {
|
||||
@@ -2488,8 +2489,8 @@ module TypeScript.Parser {
|
||||
// MultiplicativeExpression: See 11.5
|
||||
// UnaryExpression
|
||||
var leftOperand = tryParseUnaryExpressionOrHigher(_currentToken, force);
|
||||
if (leftOperand === null) {
|
||||
return null;
|
||||
if (leftOperand === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// We then pop up the stack consuming the other side of the binary exprssion if it exists.
|
||||
@@ -2622,8 +2623,8 @@ module TypeScript.Parser {
|
||||
// Because CallExpression and MemberExpression are left recursive, we need to bottom out
|
||||
// of the recursion immediately. So we parse out a primary expression to start with.
|
||||
var expression: IMemberExpressionSyntax = tryParsePrimaryExpression(_currentToken, force);
|
||||
if (expression === null) {
|
||||
return null;
|
||||
if (expression === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return parseMemberExpressionRest(expression, inObjectCreation);
|
||||
@@ -2636,7 +2637,7 @@ module TypeScript.Parser {
|
||||
|
||||
switch (currentTokenKind) {
|
||||
case SyntaxKind.OpenParenToken:
|
||||
expression = new syntaxFactory.InvocationExpressionSyntax(parseNodeData, expression, parseArgumentList(/*typeArgumentList:*/ null));
|
||||
expression = new syntaxFactory.InvocationExpressionSyntax(parseNodeData, expression, parseArgumentList(/*typeArgumentList:*/ undefined));
|
||||
continue;
|
||||
|
||||
case SyntaxKind.LessThanToken:
|
||||
@@ -2645,7 +2646,7 @@ module TypeScript.Parser {
|
||||
// part of an arithmetic expression. Break out so we consume it higher in the
|
||||
// stack.
|
||||
var argumentList = tryParseArgumentList();
|
||||
if (argumentList === null) {
|
||||
if (argumentList === undefined) {
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -2716,14 +2717,14 @@ module TypeScript.Parser {
|
||||
// completes the LeftHandSideExpression, or starts the beginning of the first four
|
||||
// CallExpression productions.
|
||||
|
||||
var expression: ILeftHandSideExpressionSyntax = null;
|
||||
var expression: ILeftHandSideExpressionSyntax = undefined;
|
||||
if (_currentToken.kind() === SyntaxKind.SuperKeyword) {
|
||||
expression = parseSuperExpression(_currentToken);
|
||||
}
|
||||
else {
|
||||
expression = tryParseMemberExpressionOrHigher(_currentToken, force, /*inObjectCreation:*/ false);
|
||||
if (expression === null) {
|
||||
return null;
|
||||
if (expression === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2745,8 +2746,8 @@ module TypeScript.Parser {
|
||||
|
||||
function tryParsePostfixExpressionOrHigher(_currentToken: ISyntaxToken, force: boolean): IPostfixExpressionSyntax {
|
||||
var expression = tryParseLeftHandSideExpressionOrHigher(_currentToken, force);
|
||||
if (expression === null) {
|
||||
return null;
|
||||
if (expression === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var _currentToken = currentToken();
|
||||
@@ -2781,13 +2782,13 @@ module TypeScript.Parser {
|
||||
var isDot = tokenKind === SyntaxKind.DotToken;
|
||||
var isOpenParenOrDot = isOpenParen || isDot;
|
||||
|
||||
var argumentList: ArgumentListSyntax = null;
|
||||
if (typeArgumentList === null || !isOpenParenOrDot) {
|
||||
var argumentList: ArgumentListSyntax = undefined;
|
||||
if (!typeArgumentList || !isOpenParenOrDot) {
|
||||
// Wasn't generic. Rewind to where we started so this can be parsed as an
|
||||
// arithmetic expression.
|
||||
rewind(rewindPoint);
|
||||
releaseRewindPoint(rewindPoint);
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else {
|
||||
releaseRewindPoint(rewindPoint);
|
||||
@@ -2800,7 +2801,7 @@ module TypeScript.Parser {
|
||||
if (isDot) {
|
||||
// A parameter list must follow a generic type argument list.
|
||||
var diagnostic = new Diagnostic(fileName, source.text.lineMap(), start(token0, source.text), width(token0),
|
||||
DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, null);
|
||||
DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, undefined);
|
||||
addDiagnostic(diagnostic);
|
||||
|
||||
return new syntaxFactory.ArgumentListSyntax(parseNodeData, typeArgumentList,
|
||||
@@ -2819,10 +2820,10 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
if (tokenKind === SyntaxKind.OpenParenToken) {
|
||||
return parseArgumentList(null);
|
||||
return parseArgumentList(undefined);
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function parseArgumentList(typeArgumentList: TypeArgumentListSyntax): ArgumentListSyntax {
|
||||
@@ -2859,7 +2860,7 @@ module TypeScript.Parser {
|
||||
var errorStart = start(openBracketToken, source.text);
|
||||
var errorEnd = end(currentToken(), source.text);
|
||||
var diagnostic = new Diagnostic(fileName, source.text.lineMap(), errorStart, errorEnd - errorStart,
|
||||
DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead, null);
|
||||
DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead, undefined);
|
||||
addDiagnostic(diagnostic);
|
||||
|
||||
return Syntax.emptyToken(SyntaxKind.IdentifierName);
|
||||
@@ -2911,7 +2912,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
if (!force) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Nothing else worked, report an error and produce a missing token.
|
||||
@@ -2937,7 +2938,7 @@ module TypeScript.Parser {
|
||||
var tokenKind = currentToken.kind();
|
||||
if (tokenKind === SyntaxKind.SlashToken || tokenKind === SyntaxKind.SlashEqualsToken) {
|
||||
// Still came back as a / or /=. This is not a regular expression literal.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else if (tokenKind === SyntaxKind.RegularExpressionLiteral) {
|
||||
return consumeToken(currentToken);
|
||||
@@ -2995,7 +2996,7 @@ module TypeScript.Parser {
|
||||
function tryParseParenthesizedArrowFunctionExpression(): ParenthesizedArrowFunctionExpressionSyntax {
|
||||
var tokenKind = currentToken().kind();
|
||||
if (tokenKind !== SyntaxKind.OpenParenToken && tokenKind !== SyntaxKind.LessThanToken) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Because arrow functions and parenthesized expressions look similar, we have to check far
|
||||
@@ -3016,14 +3017,14 @@ module TypeScript.Parser {
|
||||
// Now, look for cases where we're sure it's not an arrow function. This will help save us
|
||||
// a costly parse.
|
||||
if (!isPossiblyArrowFunctionExpression()) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Then, try to actually parse it as a arrow function, and only return if we see an =>
|
||||
var rewindPoint = getRewindPoint();
|
||||
|
||||
var arrowFunction = tryParseParenthesizedArrowFunctionExpressionWorker(/*requiresArrow:*/ true);
|
||||
if (arrowFunction === null) {
|
||||
if (arrowFunction === undefined) {
|
||||
rewind(rewindPoint);
|
||||
}
|
||||
|
||||
@@ -3038,14 +3039,14 @@ module TypeScript.Parser {
|
||||
var callSignature = parseCallSignature(/*requireCompleteTypeParameterList:*/ true);
|
||||
|
||||
if (requireArrow && currentToken().kind() !== SyntaxKind.EqualsGreaterThanToken) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var equalsGreaterThanToken = eatToken(SyntaxKind.EqualsGreaterThanToken);
|
||||
|
||||
var block = tryParseArrowFunctionBlock();
|
||||
var expression: IExpressionSyntax = null;
|
||||
if (block === null) {
|
||||
var expression: IExpressionSyntax = undefined;
|
||||
if (block === undefined) {
|
||||
expression = tryParseAssignmentExpressionOrHigher(/*force:*/ true, /*allowIn:*/ true);
|
||||
}
|
||||
|
||||
@@ -3076,7 +3077,7 @@ module TypeScript.Parser {
|
||||
return parseBlock(/*parseStatementsEvenWithNoOpenBrace:*/ true, /*checkForStrictMode:*/ false);
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3100,8 +3101,8 @@ module TypeScript.Parser {
|
||||
var equalsGreaterThanToken = eatToken(SyntaxKind.EqualsGreaterThanToken);
|
||||
|
||||
var block = tryParseArrowFunctionBlock();
|
||||
var expression: IExpressionSyntax = null;
|
||||
if (block === null) {
|
||||
var expression: IExpressionSyntax = undefined;
|
||||
if (block === undefined) {
|
||||
expression = tryParseAssignmentExpressionOrHigher(/*force:*/ true, /*allowIn:*/ true);
|
||||
}
|
||||
|
||||
@@ -3297,7 +3298,7 @@ module TypeScript.Parser {
|
||||
return parseSimplePropertyAssignment();
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3376,7 +3377,7 @@ module TypeScript.Parser {
|
||||
if (parseBlockEvenWithNoOpenBrace || openBraceToken.fullWidth() > 0) {
|
||||
var savedIsInStrictMode = isInStrictMode;
|
||||
|
||||
var processItems = checkForStrictMode ? updateStrictModeState : null;
|
||||
var processItems = checkForStrictMode ? updateStrictModeState : undefined;
|
||||
var skippedTokens: ISyntaxToken[] = getArray();
|
||||
var statements = parseSyntaxList<IStatementSyntax>(ListParsingState.Block_Statements, skippedTokens, processItems);
|
||||
openBraceToken = addSkippedTokensAfterToken(openBraceToken, skippedTokens);
|
||||
@@ -3395,7 +3396,7 @@ module TypeScript.Parser {
|
||||
function tryParseTypeParameterList(requireCompleteTypeParameterList: boolean): TypeParameterListSyntax {
|
||||
var _currentToken = currentToken();
|
||||
if (_currentToken.kind() !== SyntaxKind.LessThanToken) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var rewindPoint = getRewindPoint();
|
||||
@@ -3408,11 +3409,11 @@ module TypeScript.Parser {
|
||||
|
||||
var greaterThanToken = eatToken(SyntaxKind.GreaterThanToken);
|
||||
|
||||
// return null if we were required to have a '>' token and we did not have one.
|
||||
// return undefined if we were required to have a '>' token and we did not have one.
|
||||
if (requireCompleteTypeParameterList && greaterThanToken.fullWidth() === 0) {
|
||||
rewind(rewindPoint);
|
||||
releaseRewindPoint(rewindPoint);
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else {
|
||||
releaseRewindPoint(rewindPoint);
|
||||
@@ -3427,7 +3428,7 @@ module TypeScript.Parser {
|
||||
function tryParseTypeParameter(): TypeParameterSyntax {
|
||||
// Debug.assert(isTypeParameter());
|
||||
if (!isIdentifier(currentToken())) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return new syntaxFactory.TypeParameterSyntax(parseNodeData, eatIdentifierToken(), tryParseConstraint());
|
||||
@@ -3435,7 +3436,7 @@ module TypeScript.Parser {
|
||||
|
||||
function tryParseConstraint(): ConstraintSyntax {
|
||||
if (currentToken().kind() !== SyntaxKind.ExtendsKeyword) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return new syntaxFactory.ConstraintSyntax(parseNodeData, eatToken(SyntaxKind.ExtendsKeyword), parseTypeOrExpression());
|
||||
@@ -3450,7 +3451,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function parseParameterList(): ParameterListSyntax {
|
||||
@@ -3467,7 +3468,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function parseOptionalTypeAnnotation(allowStringLiteral: boolean): TypeAnnotationSyntax {
|
||||
return currentToken().kind() === SyntaxKind.ColonToken ? parseTypeAnnotation(allowStringLiteral) : null;
|
||||
return currentToken().kind() === SyntaxKind.ColonToken ? parseTypeAnnotation(allowStringLiteral) : undefined;
|
||||
}
|
||||
|
||||
function parseTypeAnnotationType(allowStringLiteral: boolean): ITypeSyntax {
|
||||
@@ -3532,6 +3533,38 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function tryParseType(): ITypeSyntax {
|
||||
if (isFunctionType()) {
|
||||
return parseFunctionType();
|
||||
}
|
||||
|
||||
if (currentToken().kind() === SyntaxKind.NewKeyword) {
|
||||
return parseConstructorType();
|
||||
}
|
||||
|
||||
return tryParseUnionTypeOrHigher();
|
||||
}
|
||||
|
||||
function tryParseUnionTypeOrHigher(): ITypeSyntax {
|
||||
var type = tryParsePrimaryType();
|
||||
|
||||
if (type) {
|
||||
var barToken: ISyntaxToken;
|
||||
while ((barToken = currentToken()).kind() === SyntaxKind.BarToken) {
|
||||
consumeToken(barToken);
|
||||
var right = parsePrimaryType();
|
||||
|
||||
type = new syntaxFactory.UnionTypeSyntax(parseNodeData, type, barToken, right);
|
||||
}
|
||||
}
|
||||
|
||||
return type;
|
||||
}
|
||||
|
||||
function parsePrimaryType(): ITypeSyntax {
|
||||
return tryParsePrimaryType() || eatIdentifierToken(DiagnosticCode.Type_expected);
|
||||
}
|
||||
|
||||
function tryParsePrimaryType(): ITypeSyntax {
|
||||
// First consume any underlying element type.
|
||||
var type = tryParseNonArrayType();
|
||||
|
||||
@@ -3572,11 +3605,9 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
return consumeToken(_currentToken);
|
||||
case SyntaxKind.OpenParenToken:
|
||||
case SyntaxKind.LessThanToken: return tryParseFunctionType();
|
||||
case SyntaxKind.VoidKeyword: return consumeToken(_currentToken);
|
||||
case SyntaxKind.OpenParenToken: return parseParenthesizedType(_currentToken);
|
||||
case SyntaxKind.OpenBraceToken: return parseObjectType();
|
||||
case SyntaxKind.NewKeyword: return parseConstructorType();
|
||||
case SyntaxKind.TypeOfKeyword: return parseTypeQuery(_currentToken);
|
||||
case SyntaxKind.OpenBracketToken: return parseTupleType(_currentToken);
|
||||
}
|
||||
@@ -3584,10 +3615,14 @@ module TypeScript.Parser {
|
||||
return tryParseNameOrGenericType();
|
||||
}
|
||||
|
||||
function parseParenthesizedType(openParenToken: ISyntaxToken): ParenthesizedTypeSyntax {
|
||||
return new syntaxFactory.ParenthesizedTypeSyntax(parseNodeData, consumeToken(openParenToken), parseType(), eatToken(SyntaxKind.CloseParenToken));
|
||||
}
|
||||
|
||||
function tryParseNameOrGenericType(): ITypeSyntax {
|
||||
var name = tryParseName(/*allowIdentifierNames*/ false);
|
||||
if (name === null) {
|
||||
return null;
|
||||
if (name === undefined) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// TypeReference:
|
||||
@@ -3599,23 +3634,76 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
var typeArgumentList = tryParseTypeArgumentList(/*inExpression:*/ false);
|
||||
return typeArgumentList === null
|
||||
return !typeArgumentList
|
||||
? name
|
||||
: new syntaxFactory.GenericTypeSyntax(parseNodeData, name, typeArgumentList);
|
||||
}
|
||||
|
||||
function tryParseFunctionType(): FunctionTypeSyntax {
|
||||
var typeParameterList = tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false);
|
||||
var parameterList: ParameterListSyntax = null;
|
||||
if (typeParameterList === null) {
|
||||
parameterList = tryParseParameterList();
|
||||
if (parameterList === null) {
|
||||
return null;
|
||||
function isFunctionType(): boolean {
|
||||
var token0 = currentToken();
|
||||
var token0Kind = token0.kind();
|
||||
|
||||
// If we see a < then we consider ourselves to be definitely in a (generic) function type.
|
||||
if (token0Kind === SyntaxKind.LessThanToken) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// If we don't see a < then we have to see an open paren for this to be a function
|
||||
// type. However, an open paren may also start a parenthesized type. So we need to
|
||||
// do some lookahead to see what we've actually got. If we don't see enough to be
|
||||
// sure that it's a function type, then we go ahead with the assumption that it's a
|
||||
// parenthesized type.
|
||||
if (token0Kind === SyntaxKind.OpenParenToken) {
|
||||
var token1 = peekToken(1);
|
||||
var token1Kind = token1.kind();
|
||||
|
||||
if (token1Kind === SyntaxKind.CloseParenToken || token1Kind === SyntaxKind.DotDotDotToken) {
|
||||
// ()
|
||||
// (...
|
||||
//
|
||||
// Both are definitely function types, and could not be paren types.
|
||||
return true;
|
||||
}
|
||||
|
||||
if (isModifierKind(token1Kind) || isIdentifier(token1)) {
|
||||
// (id
|
||||
// could be a function type or a parenthesized type.
|
||||
|
||||
var token2 = peekToken(2);
|
||||
var token2Kind = token2.kind();
|
||||
|
||||
if (token2Kind === SyntaxKind.ColonToken ||
|
||||
token2Kind === SyntaxKind.CommaToken ||
|
||||
token2Kind === SyntaxKind.QuestionToken ||
|
||||
token2Kind === SyntaxKind.EqualsToken ||
|
||||
isIdentifier(token2) ||
|
||||
isModifierKind(token2Kind)) {
|
||||
// ( id :
|
||||
// ( id ,
|
||||
// ( id ?
|
||||
// ( id =
|
||||
// ( modifier id
|
||||
//
|
||||
// All of these are definitely a function type and not a parenthesized type.
|
||||
return true;
|
||||
}
|
||||
|
||||
if (token2Kind === SyntaxKind.CloseParenToken) {
|
||||
// ( id )
|
||||
//
|
||||
// Only a function type if we see an arrow following it.
|
||||
return peekToken(3).kind() === SyntaxKind.EqualsGreaterThanToken;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
parameterList = parseParameterList();
|
||||
}
|
||||
|
||||
// Anything else is a parenthesized type.
|
||||
return false;
|
||||
}
|
||||
|
||||
function parseFunctionType(): FunctionTypeSyntax {
|
||||
var typeParameterList = tryParseTypeParameterList(/*requireCompleteTypeParameterList:*/ false);
|
||||
var parameterList = parseParameterList();
|
||||
|
||||
return new syntaxFactory.FunctionTypeSyntax(parseNodeData,
|
||||
typeParameterList, parameterList, eatToken(SyntaxKind.EqualsGreaterThanToken), parseType());
|
||||
@@ -3628,7 +3716,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function isParameter(): boolean {
|
||||
if (currentNode() !== null && currentNode().kind() === SyntaxKind.Parameter) {
|
||||
if (currentNode() && currentNode().kind() === SyntaxKind.Parameter) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -3644,13 +3732,13 @@ module TypeScript.Parser {
|
||||
|
||||
function eatSimpleParameter() {
|
||||
return new syntaxFactory.ParameterSyntax(parseNodeData,
|
||||
/*dotDotDotToken:*/ null, /*modifiers:*/ Syntax.emptyList<ISyntaxToken>(), eatIdentifierToken(),
|
||||
/*questionToken:*/ null, /*typeAnnotation:*/ null, /*equalsValueClause:*/ null);
|
||||
/*dotDotDotToken:*/ undefined, /*modifiers:*/ Syntax.emptyList<ISyntaxToken>(), eatIdentifierToken(),
|
||||
/*questionToken:*/ undefined, /*typeAnnotation:*/ undefined, /*equalsValueClause:*/ undefined);
|
||||
}
|
||||
|
||||
function tryParseParameter(): ParameterSyntax {
|
||||
var node = currentNode();
|
||||
if (node !== null && node.kind() === SyntaxKind.Parameter) {
|
||||
if (node && node.kind() === SyntaxKind.Parameter) {
|
||||
consumeNode(node);
|
||||
return <ParameterSyntax>node;
|
||||
}
|
||||
@@ -3661,7 +3749,7 @@ module TypeScript.Parser {
|
||||
// If we're not forcing, and we don't see anything to indicate this is a parameter, then
|
||||
// bail out.
|
||||
var _currentToken = currentToken();
|
||||
if (!isIdentifier(_currentToken) && dotDotDotToken === null && modifiers.length === 0) {
|
||||
if (!isIdentifier(_currentToken) && !dotDotDotToken && modifiers.length === 0) {
|
||||
// ERROR RECOVERY:
|
||||
// If we see a modifier alone in a parameter list, like: foo(static)
|
||||
//
|
||||
@@ -3670,7 +3758,7 @@ module TypeScript.Parser {
|
||||
modifiers = Syntax.list([consumeToken(_currentToken)]);
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3678,7 +3766,7 @@ module TypeScript.Parser {
|
||||
var questionToken = tryEatToken(SyntaxKind.QuestionToken);
|
||||
var typeAnnotation = parseOptionalTypeAnnotation(/*allowStringLiteral:*/ true);
|
||||
|
||||
var equalsValueClause: EqualsValueClauseSyntax = null;
|
||||
var equalsValueClause: EqualsValueClauseSyntax = undefined;
|
||||
if (isEqualsValueClause(/*inParameter*/ true)) {
|
||||
equalsValueClause = parseEqualsValueClause(/*allowIn:*/ true);
|
||||
}
|
||||
@@ -3687,7 +3775,7 @@ module TypeScript.Parser {
|
||||
}
|
||||
|
||||
function parseSyntaxList<T extends ISyntaxNodeOrToken>(
|
||||
currentListType: ListParsingState, skippedTokens: ISyntaxToken[], processItems: (items: any[]) => void = null): T[] {
|
||||
currentListType: ListParsingState, skippedTokens: ISyntaxToken[], processItems?: (items: any[]) => void): T[] {
|
||||
var savedListParsingState = listParsingState;
|
||||
listParsingState |= (1 << currentListType);
|
||||
|
||||
@@ -3769,14 +3857,14 @@ module TypeScript.Parser {
|
||||
currentListType: ListParsingState, inErrorRecovery: boolean, items: ISyntaxElement[], processItems: (items: any[]) => void): boolean {
|
||||
var item = tryParseExpectedListItemWorker(currentListType, inErrorRecovery);
|
||||
|
||||
if (item === null) {
|
||||
if (item === undefined) {
|
||||
return false;
|
||||
}
|
||||
// Debug.assert(item !== null);
|
||||
// Debug.assert(item !== undefined);
|
||||
|
||||
items.push(item);
|
||||
|
||||
if (processItems !== null) {
|
||||
if (processItems) {
|
||||
processItems(items);
|
||||
}
|
||||
|
||||
@@ -3807,7 +3895,7 @@ module TypeScript.Parser {
|
||||
|
||||
// List wasn't complete and we didn't get an item. Figure out if we should bail out
|
||||
// or skip a token and continue.
|
||||
var abort = abortParsingListOrMoveToNextToken(currentListType, items, null, skippedTokens);
|
||||
var abort = abortParsingListOrMoveToNextToken(currentListType, items, /*separators:*/ undefined, skippedTokens);
|
||||
if (abort) {
|
||||
break;
|
||||
}
|
||||
@@ -3846,11 +3934,11 @@ module TypeScript.Parser {
|
||||
// continue parsing.
|
||||
|
||||
// Debug.assert(oldItemsCount % 2 === 0);
|
||||
var succeeded = tryParseExpectedListItem(currentListType, inErrorRecovery, nodes, null);
|
||||
var succeeded = tryParseExpectedListItem(currentListType, inErrorRecovery, nodes, /*processItems:*/ undefined);
|
||||
|
||||
if (!succeeded) {
|
||||
// We weren't able to parse out a list element.
|
||||
// Debug.assert(items === null || items.length % 2 === 0);
|
||||
// Debug.assert(items === undefined || items.length % 2 === 0);
|
||||
|
||||
// That may have been because the list is complete. In that case, break out
|
||||
// and return the items we were able parse.
|
||||
@@ -4267,26 +4355,26 @@ module TypeScript.Parser {
|
||||
|
||||
function getExpectedListElementType(currentListType: ListParsingState): string {
|
||||
switch (currentListType) {
|
||||
case ListParsingState.SourceUnit_ModuleElements: return getLocalizedText(DiagnosticCode.module_class_interface_enum_import_or_statement, null);
|
||||
case ListParsingState.SourceUnit_ModuleElements: return getLocalizedText(DiagnosticCode.module_class_interface_enum_import_or_statement, undefined);
|
||||
case ListParsingState.ClassOrInterfaceDeclaration_HeritageClauses: return '{';
|
||||
case ListParsingState.ClassDeclaration_ClassElements: return getLocalizedText(DiagnosticCode.constructor_function_accessor_or_variable, null);
|
||||
case ListParsingState.ModuleDeclaration_ModuleElements: return getLocalizedText(DiagnosticCode.module_class_interface_enum_import_or_statement, null);
|
||||
case ListParsingState.SwitchStatement_SwitchClauses: return getLocalizedText(DiagnosticCode.case_or_default_clause, null);
|
||||
case ListParsingState.SwitchClause_Statements: return getLocalizedText(DiagnosticCode.statement, null);
|
||||
case ListParsingState.Block_Statements: return getLocalizedText(DiagnosticCode.statement, null);
|
||||
case ListParsingState.VariableDeclaration_VariableDeclarators_AllowIn: return getLocalizedText(DiagnosticCode.identifier, null);
|
||||
case ListParsingState.VariableDeclaration_VariableDeclarators_DisallowIn: return getLocalizedText(DiagnosticCode.identifier, null);
|
||||
case ListParsingState.EnumDeclaration_EnumElements: return getLocalizedText(DiagnosticCode.identifier, null);
|
||||
case ListParsingState.ObjectType_TypeMembers: return getLocalizedText(DiagnosticCode.call_construct_index_property_or_function_signature, null);
|
||||
case ListParsingState.ArgumentList_AssignmentExpressions: return getLocalizedText(DiagnosticCode.expression, null);
|
||||
case ListParsingState.HeritageClause_TypeNameList: return getLocalizedText(DiagnosticCode.type_name, null);
|
||||
case ListParsingState.ObjectLiteralExpression_PropertyAssignments: return getLocalizedText(DiagnosticCode.property_or_accessor, null);
|
||||
case ListParsingState.ParameterList_Parameters: return getLocalizedText(DiagnosticCode.parameter, null);
|
||||
case ListParsingState.IndexSignature_Parameters: return getLocalizedText(DiagnosticCode.parameter, null);
|
||||
case ListParsingState.TypeArgumentList_Types: return getLocalizedText(DiagnosticCode.type, null);
|
||||
case ListParsingState.TypeParameterList_TypeParameters: return getLocalizedText(DiagnosticCode.type_parameter, null);
|
||||
case ListParsingState.TupleType_Types: return getLocalizedText(DiagnosticCode.type, null);
|
||||
case ListParsingState.ArrayLiteralExpression_AssignmentExpressions: return getLocalizedText(DiagnosticCode.expression, null);
|
||||
case ListParsingState.ClassDeclaration_ClassElements: return getLocalizedText(DiagnosticCode.constructor_function_accessor_or_variable, undefined);
|
||||
case ListParsingState.ModuleDeclaration_ModuleElements: return getLocalizedText(DiagnosticCode.module_class_interface_enum_import_or_statement, undefined);
|
||||
case ListParsingState.SwitchStatement_SwitchClauses: return getLocalizedText(DiagnosticCode.case_or_default_clause, undefined);
|
||||
case ListParsingState.SwitchClause_Statements: return getLocalizedText(DiagnosticCode.statement, undefined);
|
||||
case ListParsingState.Block_Statements: return getLocalizedText(DiagnosticCode.statement, undefined);
|
||||
case ListParsingState.VariableDeclaration_VariableDeclarators_AllowIn: return getLocalizedText(DiagnosticCode.identifier, undefined);
|
||||
case ListParsingState.VariableDeclaration_VariableDeclarators_DisallowIn: return getLocalizedText(DiagnosticCode.identifier, undefined);
|
||||
case ListParsingState.EnumDeclaration_EnumElements: return getLocalizedText(DiagnosticCode.identifier, undefined);
|
||||
case ListParsingState.ObjectType_TypeMembers: return getLocalizedText(DiagnosticCode.call_construct_index_property_or_function_signature, undefined);
|
||||
case ListParsingState.ArgumentList_AssignmentExpressions: return getLocalizedText(DiagnosticCode.expression, undefined);
|
||||
case ListParsingState.HeritageClause_TypeNameList: return getLocalizedText(DiagnosticCode.type_name, undefined);
|
||||
case ListParsingState.ObjectLiteralExpression_PropertyAssignments: return getLocalizedText(DiagnosticCode.property_or_accessor, undefined);
|
||||
case ListParsingState.ParameterList_Parameters: return getLocalizedText(DiagnosticCode.parameter, undefined);
|
||||
case ListParsingState.IndexSignature_Parameters: return getLocalizedText(DiagnosticCode.parameter, undefined);
|
||||
case ListParsingState.TypeArgumentList_Types: return getLocalizedText(DiagnosticCode.type, undefined);
|
||||
case ListParsingState.TypeParameterList_TypeParameters: return getLocalizedText(DiagnosticCode.type_parameter, undefined);
|
||||
case ListParsingState.TupleType_Types: return getLocalizedText(DiagnosticCode.type, undefined);
|
||||
case ListParsingState.ArrayLiteralExpression_AssignmentExpressions: return getLocalizedText(DiagnosticCode.expression, undefined);
|
||||
default: throw Errors.invalidOperation();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -16,7 +16,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private newLineCountBetweenModuleElements(element1: IModuleElementSyntax, element2: IModuleElementSyntax): number {
|
||||
if (element1 === null || element2 === null) {
|
||||
if (!element1 || !element2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -28,7 +28,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private newLineCountBetweenClassElements(element1: IClassElementSyntax, element2: IClassElementSyntax): number {
|
||||
if (element1 === null || element2 === null) {
|
||||
if (!element1 || !element2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -36,7 +36,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private newLineCountBetweenStatements(element1: IClassElementSyntax, element2: IClassElementSyntax): number {
|
||||
if (element1 === null || element2 === null) {
|
||||
if (!element1 || !element2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -48,7 +48,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private newLineCountBetweenSwitchClauses(element1: ISwitchClauseSyntax, element2: ISwitchClauseSyntax): number {
|
||||
if (element1 === null || element2 === null) {
|
||||
if (!element1 || !element2) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -120,7 +120,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private appendToken(token: ISyntaxToken): void {
|
||||
if (token !== null && token.fullWidth() > 0) {
|
||||
if (token && token.fullWidth() > 0) {
|
||||
this.appendIndentationIfAfterNewLine();
|
||||
this.appendText(token.text());
|
||||
}
|
||||
@@ -174,7 +174,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private appendModuleElements(list: IModuleElementSyntax[]): void {
|
||||
var lastModuleElement: IModuleElementSyntax = null;
|
||||
var lastModuleElement: IModuleElementSyntax = undefined;
|
||||
for (var i = 0, n = list.length; i < n; i++) {
|
||||
var moduleElement = list[i];
|
||||
var newLineCount = this.newLineCountBetweenModuleElements(lastModuleElement, moduleElement);
|
||||
@@ -236,7 +236,7 @@ module TypeScript.PrettyPrinter {
|
||||
|
||||
this.indentation++;
|
||||
|
||||
var lastClassElement: IClassElementSyntax = null;
|
||||
var lastClassElement: IClassElementSyntax = undefined;
|
||||
for (var i = 0, n = node.classElements.length; i < n; i++) {
|
||||
var classElement = node.classElements[i];
|
||||
var newLineCount = this.newLineCountBetweenClassElements(lastClassElement, classElement);
|
||||
@@ -427,6 +427,20 @@ module TypeScript.PrettyPrinter {
|
||||
this.appendToken(node.closeBracketToken);
|
||||
}
|
||||
|
||||
public visitParenthesizedType(node: ParenthesizedTypeSyntax): void {
|
||||
this.appendToken(node.openParenToken);
|
||||
this.appendElement(node.type);
|
||||
this.appendToken(node.closeParenToken);
|
||||
}
|
||||
|
||||
public visitUnionType(node: UnionTypeSyntax): void {
|
||||
this.appendElement(node.left);
|
||||
this.ensureSpace();
|
||||
this.appendToken(node.barToken);
|
||||
this.ensureSpace();
|
||||
this.appendElement(node.right);
|
||||
}
|
||||
|
||||
public visitConstructorType(node: ConstructorTypeSyntax): void {
|
||||
this.appendToken(node.newKeyword);
|
||||
this.ensureSpace();
|
||||
@@ -472,7 +486,7 @@ module TypeScript.PrettyPrinter {
|
||||
}
|
||||
|
||||
private appendStatements(statements: IStatementSyntax[]): void {
|
||||
var lastStatement: IStatementSyntax = null;
|
||||
var lastStatement: IStatementSyntax = undefined;
|
||||
for (var i = 0, n = statements.length; i < n; i++) {
|
||||
var statement = statements[i];
|
||||
|
||||
@@ -743,7 +757,7 @@ module TypeScript.PrettyPrinter {
|
||||
this.appendToken(node.openBraceToken);
|
||||
this.ensureNewLine();
|
||||
|
||||
var lastSwitchClause: ISwitchClauseSyntax = null;
|
||||
var lastSwitchClause: ISwitchClauseSyntax = undefined;
|
||||
for (var i = 0, n = node.switchClauses.length; i < n; i++) {
|
||||
var switchClause = node.switchClauses[i];
|
||||
|
||||
|
||||
@@ -700,7 +700,7 @@ module TypeScript.Scanner {
|
||||
|
||||
while (true) {
|
||||
if (index === end) {
|
||||
reportDiagnostic(end, 0, DiagnosticCode.AsteriskSlash_expected, null);
|
||||
reportDiagnostic(end, 0, DiagnosticCode.AsteriskSlash_expected, undefined);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -916,7 +916,7 @@ module TypeScript.Scanner {
|
||||
|
||||
if (languageVersion >= ts.ScriptTarget.ES5) {
|
||||
reportDiagnostic(
|
||||
start, index - start, DiagnosticCode.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher, null);
|
||||
start, index - start, DiagnosticCode.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher, undefined);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1223,7 +1223,7 @@ module TypeScript.Scanner {
|
||||
switch (ch) {
|
||||
case CharacterCodes.backslash:
|
||||
// We're now in an escape. Consume the next character we see (unless it's
|
||||
// a newline or null.
|
||||
// a newline or undefined.
|
||||
inEscape = true;
|
||||
continue;
|
||||
|
||||
@@ -1364,7 +1364,7 @@ module TypeScript.Scanner {
|
||||
break;
|
||||
}
|
||||
else if (isNaN(ch) || isNewLineCharacter(ch)) {
|
||||
reportDiagnostic(Math.min(index, end), 1, DiagnosticCode.Missing_close_quote_character, null);
|
||||
reportDiagnostic(Math.min(index, end), 1, DiagnosticCode.Missing_close_quote_character, undefined);
|
||||
break;
|
||||
}
|
||||
else {
|
||||
@@ -1431,7 +1431,7 @@ module TypeScript.Scanner {
|
||||
var ch2 = str.charCodeAt(index);
|
||||
if (!CharacterInfo.isHexDigit(ch2)) {
|
||||
if (report) {
|
||||
reportDiagnostic(start, index - start, DiagnosticCode.Unrecognized_escape_sequence, null)
|
||||
reportDiagnostic(start, index - start, DiagnosticCode.Unrecognized_escape_sequence, undefined)
|
||||
}
|
||||
|
||||
break;
|
||||
@@ -1511,30 +1511,30 @@ module TypeScript.Scanner {
|
||||
var rewindPointPool: IScannerRewindPoint[] = [];
|
||||
var rewindPointPoolCount = 0;
|
||||
|
||||
var lastDiagnostic: Diagnostic = null;
|
||||
var lastDiagnostic: Diagnostic = undefined;
|
||||
var reportDiagnostic = (position: number, fullWidth: number, diagnosticKey: string, args: any[]) => {
|
||||
lastDiagnostic = new Diagnostic(fileName, text.lineMap(), position, fullWidth, diagnosticKey, args);
|
||||
};
|
||||
|
||||
// The sliding window that we store tokens in.
|
||||
var slidingWindow = new SlidingWindow(fetchNextItem, ArrayUtilities.createArray(/*defaultWindowSize:*/ 1024, null), null);
|
||||
var slidingWindow = new SlidingWindow(fetchNextItem, ArrayUtilities.createArray(/*defaultWindowSize:*/ 1024, undefined), undefined);
|
||||
|
||||
// The scanner we're pulling tokens from.
|
||||
var scanner = createScanner(languageVersion, text, reportDiagnostic);
|
||||
|
||||
function release() {
|
||||
slidingWindow = null;
|
||||
scanner = null;
|
||||
slidingWindow = undefined;
|
||||
scanner = undefined;
|
||||
_tokenDiagnostics = [];
|
||||
rewindPointPool = [];
|
||||
lastDiagnostic = null;
|
||||
reportDiagnostic = null;
|
||||
lastDiagnostic = undefined;
|
||||
reportDiagnostic = undefined;
|
||||
}
|
||||
|
||||
function currentNode(): ISyntaxNode {
|
||||
// The normal parser source never returns nodes. They're only returned by the
|
||||
// incremental parser source.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function consumeNode(node: ISyntaxNode): void {
|
||||
@@ -1557,7 +1557,7 @@ module TypeScript.Scanner {
|
||||
|
||||
rewindPointPoolCount--;
|
||||
var result = rewindPointPool[rewindPointPoolCount];
|
||||
rewindPointPool[rewindPointPoolCount] = null;
|
||||
rewindPointPool[rewindPointPoolCount] = undefined;
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -1593,7 +1593,7 @@ module TypeScript.Scanner {
|
||||
// Debug.assert(spaceAvailable > 0);
|
||||
var token = scanner.scan(allowContextualToken);
|
||||
|
||||
if (lastDiagnostic === null) {
|
||||
if (lastDiagnostic === undefined) {
|
||||
return token;
|
||||
}
|
||||
|
||||
@@ -1601,7 +1601,7 @@ module TypeScript.Scanner {
|
||||
// it won't be reused in incremental scenarios.
|
||||
|
||||
_tokenDiagnostics.push(lastDiagnostic);
|
||||
lastDiagnostic = null;
|
||||
lastDiagnostic = undefined;
|
||||
return Syntax.realizeToken(token, text);
|
||||
}
|
||||
|
||||
@@ -1628,13 +1628,12 @@ module TypeScript.Scanner {
|
||||
var diagnostic = _tokenDiagnostics[tokenDiagnosticsLength - 1];
|
||||
if (diagnostic.start() >= position) {
|
||||
tokenDiagnosticsLength--;
|
||||
_tokenDiagnostics.pop();
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
_tokenDiagnostics.length = tokenDiagnosticsLength;
|
||||
}
|
||||
|
||||
function resetToPosition(absolutePosition: number): void {
|
||||
|
||||
@@ -167,7 +167,7 @@ module TypeScript {
|
||||
// Assert disabled because it is actually expensive enugh to affect perf.
|
||||
// Debug.assert(n >= 0);
|
||||
while (this.currentRelativeItemIndex + n >= this.windowCount) {
|
||||
if (!this.addMoreItemsToWindow(/*argument:*/ null)) {
|
||||
if (!this.addMoreItemsToWindow(/*argument:*/ undefined)) {
|
||||
return this.defaultValue;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -63,8 +63,8 @@ module TypeScript.Syntax {
|
||||
export function isEntirelyInsideComment(sourceUnit: SourceUnitSyntax, position: number): boolean {
|
||||
var positionedToken = findToken(sourceUnit, position);
|
||||
var fullStart = positionedToken.fullStart();
|
||||
var triviaList: ISyntaxTriviaList = null;
|
||||
var lastTriviaBeforeToken: ISyntaxTrivia = null;
|
||||
var triviaList: ISyntaxTriviaList = undefined;
|
||||
var lastTriviaBeforeToken: ISyntaxTrivia = undefined;
|
||||
|
||||
if (positionedToken.kind() === SyntaxKind.EndOfFileToken) {
|
||||
// Check if the trivia is leading on the EndOfFile token
|
||||
@@ -133,7 +133,7 @@ module TypeScript.Syntax {
|
||||
}
|
||||
|
||||
function findSkippedTokenOnLeftInTriviaList(positionedToken: ISyntaxToken, position: number, lookInLeadingTriviaList: boolean): ISyntaxToken {
|
||||
var triviaList: TypeScript.ISyntaxTriviaList = null;
|
||||
var triviaList: TypeScript.ISyntaxTriviaList = undefined;
|
||||
var fullEnd: number;
|
||||
|
||||
if (lookInLeadingTriviaList) {
|
||||
@@ -158,7 +158,7 @@ module TypeScript.Syntax {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function findSkippedTokenOnLeft(positionedToken: ISyntaxToken, position: number): ISyntaxToken {
|
||||
@@ -175,11 +175,11 @@ module TypeScript.Syntax {
|
||||
positionedToken = positionedToken.parent;
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function hasAncestorOfKind(positionedToken: ISyntaxElement, kind: SyntaxKind): boolean {
|
||||
return getAncestorOfKind(positionedToken, kind) !== null;
|
||||
return !!getAncestorOfKind(positionedToken, kind);
|
||||
}
|
||||
|
||||
export function isIntegerLiteral(expression: IExpressionSyntax): boolean {
|
||||
@@ -207,7 +207,7 @@ module TypeScript.Syntax {
|
||||
export function containingNode(element: ISyntaxElement): ISyntaxNode {
|
||||
var current = element.parent;
|
||||
|
||||
while (current !== null && !isNode(current)) {
|
||||
while (current && !isNode(current)) {
|
||||
current = current.parent;
|
||||
}
|
||||
|
||||
@@ -234,7 +234,7 @@ module TypeScript.Syntax {
|
||||
// we're in the trivia before the start of the token. Need to return the previous token.
|
||||
if (positionedToken.fullStart() === 0) {
|
||||
// Already on the first token. Nothing before us.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return previousToken(positionedToken, includeSkippedTokens);
|
||||
@@ -274,7 +274,7 @@ module TypeScript.Syntax {
|
||||
|
||||
function isFirstTokenInLine(token: ISyntaxToken, lineMap: LineMap): boolean {
|
||||
var _previousToken = previousToken(token);
|
||||
if (_previousToken === null) {
|
||||
if (_previousToken === undefined) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -54,7 +54,7 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function parsedInStrictMode(node: ISyntaxNode): boolean {
|
||||
@@ -84,7 +84,7 @@ module TypeScript {
|
||||
|
||||
var start = token.fullStart();
|
||||
if (start === 0) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return findToken(syntaxTree(token).sourceUnit(), start - 1, includeSkippedTokens);
|
||||
@@ -105,7 +105,7 @@ module TypeScript {
|
||||
*/
|
||||
export function findToken(element: ISyntaxElement, position: number, includeSkippedTokens: boolean = false): ISyntaxToken {
|
||||
var endOfFileToken = tryGetEndOfFileAt(element, position);
|
||||
if (endOfFileToken !== null) {
|
||||
if (endOfFileToken) {
|
||||
return endOfFileToken;
|
||||
}
|
||||
|
||||
@@ -137,7 +137,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
function findSkippedTokenInTriviaList(positionedToken: ISyntaxToken, position: number, lookInLeadingTriviaList: boolean): ISyntaxToken {
|
||||
var triviaList: TypeScript.ISyntaxTriviaList = null;
|
||||
var triviaList: TypeScript.ISyntaxTriviaList = undefined;
|
||||
var fullStart: number;
|
||||
|
||||
if (lookInLeadingTriviaList) {
|
||||
@@ -162,7 +162,7 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function findTokenWorker(element: ISyntaxElement, position: number): ISyntaxToken {
|
||||
@@ -182,7 +182,7 @@ module TypeScript {
|
||||
for (var i = 0, n = childCount(element); i < n; i++) {
|
||||
var child = childAt(element, i);
|
||||
|
||||
if (child !== null) {
|
||||
if (child) {
|
||||
var childFullWidth = fullWidth(child);
|
||||
if (childFullWidth > 0) {
|
||||
var childFullStart = fullStart(child);
|
||||
@@ -207,12 +207,12 @@ module TypeScript {
|
||||
return sourceUnit.endOfFileToken;
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function nextToken(token: ISyntaxToken, text?: ISimpleText, includeSkippedTokens: boolean = false): ISyntaxToken {
|
||||
if (token.kind() === SyntaxKind.EndOfFileToken) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (includeSkippedTokens) {
|
||||
@@ -231,7 +231,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
export function isNode(element: ISyntaxElement): boolean {
|
||||
if (element !== null) {
|
||||
if (element) {
|
||||
var kind = element.kind();
|
||||
return kind >= SyntaxKind.FirstNode && kind <= SyntaxKind.LastNode;
|
||||
}
|
||||
@@ -244,7 +244,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
export function isToken(element: ISyntaxElement): boolean {
|
||||
if (element !== null) {
|
||||
if (element) {
|
||||
return isTokenKind(element.kind());
|
||||
}
|
||||
|
||||
@@ -252,11 +252,11 @@ module TypeScript {
|
||||
}
|
||||
|
||||
export function isList(element: ISyntaxElement): boolean {
|
||||
return element !== null && element.kind() === SyntaxKind.List;
|
||||
return element && element.kind() === SyntaxKind.List;
|
||||
}
|
||||
|
||||
export function isSeparatedList(element: ISyntaxElement): boolean {
|
||||
return element !== null && element.kind() === SyntaxKind.SeparatedList;
|
||||
return element && element.kind() === SyntaxKind.SeparatedList;
|
||||
}
|
||||
|
||||
export function syntaxID(element: ISyntaxElement): number {
|
||||
@@ -311,7 +311,7 @@ module TypeScript {
|
||||
var kind = element.kind();
|
||||
|
||||
if (isTokenKind(kind)) {
|
||||
return fullWidth(element) > 0 || element.kind() === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : null;
|
||||
return fullWidth(element) > 0 || element.kind() === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : undefined;
|
||||
}
|
||||
|
||||
if (kind === SyntaxKind.List) {
|
||||
@@ -349,12 +349,12 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function lastToken(element: ISyntaxElement): ISyntaxToken {
|
||||
if (isToken(element)) {
|
||||
return fullWidth(element) > 0 || element.kind() === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : null;
|
||||
return fullWidth(element) > 0 || element.kind() === SyntaxKind.EndOfFileToken ? <ISyntaxToken>element : undefined;
|
||||
}
|
||||
|
||||
if (element.kind() === SyntaxKind.SourceUnit) {
|
||||
@@ -363,7 +363,7 @@ module TypeScript {
|
||||
|
||||
for (var i = childCount(element) - 1; i >= 0; i--) {
|
||||
var child = childAt(element, i);
|
||||
if (child !== null) {
|
||||
if (child) {
|
||||
var token = lastToken(child);
|
||||
if (token) {
|
||||
return token;
|
||||
@@ -371,7 +371,7 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
export function fullStart(element: ISyntaxElement): number {
|
||||
@@ -474,7 +474,7 @@ module TypeScript {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (token1 === null || token2 === null) {
|
||||
if (!token1 || !token2) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -134,7 +134,7 @@ module TypeScript.SyntaxFacts {
|
||||
|
||||
export function getText(kind: SyntaxKind): string {
|
||||
var result = kindToText[kind];
|
||||
return result !== undefined ? result : null;
|
||||
return result;// !== undefined ? result : undefined;
|
||||
}
|
||||
|
||||
export function isAnyKeyword(kind: SyntaxKind): boolean {
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
///<reference path='..\core\environment.ts' />
|
||||
///<reference path='syntaxFacts.ts' />
|
||||
///<reference path='syntaxKind.ts' />
|
||||
///<reference path='..\..\..\tests\fidelity\es5compat.ts' />
|
||||
|
||||
// Adds argument checking to the generated nodes. Argument checking appears to slow things down
|
||||
// parsing about 7%. If we want to get that perf back, we can always remove this.
|
||||
@@ -365,6 +366,28 @@ var definitions:ITypeDefinition[] = [
|
||||
],
|
||||
isTypeScriptSpecific: true
|
||||
},
|
||||
<any> {
|
||||
name: 'UnionTypeSyntax',
|
||||
baseType: 'ISyntaxNode',
|
||||
interfaces: ['ITypeSyntax'],
|
||||
children: [
|
||||
<any>{ name: 'left', type: 'ITypeSyntax' },
|
||||
<any>{ name: 'barToken', isToken: true, excludeFromAST: true },
|
||||
<any>{ name: 'right', type: 'ITypeSyntax' }
|
||||
],
|
||||
isTypeScriptSpecific: true
|
||||
},
|
||||
<any> {
|
||||
name: 'ParenthesizedTypeSyntax',
|
||||
baseType: 'ISyntaxNode',
|
||||
interfaces: ['ITypeSyntax'],
|
||||
children: [
|
||||
<any>{ name: 'openParenToken', isToken: true, excludeFromAST: true },
|
||||
<any>{ name: 'type', type: 'ITypeSyntax' },
|
||||
<any>{ name: 'closeParenToken', isToken: true, excludeFromAST: true }
|
||||
],
|
||||
isTypeScriptSpecific: true
|
||||
},
|
||||
<any>{
|
||||
name: 'TypeAnnotationSyntax',
|
||||
baseType: 'ISyntaxNode',
|
||||
@@ -1065,7 +1088,7 @@ function generateProperties(definition: ITypeDefinition): string {
|
||||
var result = "";
|
||||
|
||||
if (definition.name === "SourceUnitSyntax") {
|
||||
result += " public syntaxTree: SyntaxTree = null;\r\n";
|
||||
result += " public syntaxTree: SyntaxTree = undefined;\r\n";
|
||||
}
|
||||
|
||||
var newLine = false;
|
||||
@@ -1097,7 +1120,7 @@ function generateNullChecks(definition: ITypeDefinition): string {
|
||||
var child = definition.children[i];
|
||||
|
||||
if (!child.isOptional && !child.isToken) {
|
||||
result += " if (" + child.name + " === null) { throw Errors.argumentNull('" + child.name + "'); }\r\n";
|
||||
result += " if (!" + child.name + ") { throw Errors.argumentNull('" + child.name + "'); }\r\n";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1211,7 +1234,7 @@ function generateKindCheck(child: IMemberDefinition): string {
|
||||
if (child.isOptional) {
|
||||
indent = " ";
|
||||
|
||||
result += " if (" + child.name + " !== null) {\r\n";
|
||||
result += " if (" + child.name + ") {\r\n";
|
||||
}
|
||||
|
||||
var kinds = tokenKinds(child);
|
||||
@@ -1268,7 +1291,7 @@ function generateConstructor(definition: ITypeDefinition): string {
|
||||
result += " constructor("
|
||||
|
||||
var children = definition.children;
|
||||
var kindChild: IMemberDefinition = null;
|
||||
var kindChild: IMemberDefinition = undefined;
|
||||
for (i = 0; i < children.length; i++) {
|
||||
child = children[i];
|
||||
|
||||
@@ -1385,7 +1408,7 @@ function generateFactory1Method(definition: ITypeDefinition): string {
|
||||
result += "Syntax.emptySeparatedList<" + child.elementType + ">()";
|
||||
}
|
||||
else {
|
||||
result += "null";
|
||||
result += "undefined";
|
||||
}
|
||||
|
||||
result += ", ";
|
||||
@@ -1412,7 +1435,7 @@ function isKeywordOrPunctuation(kind: string): boolean {
|
||||
}
|
||||
|
||||
function isDefaultConstructable(definition: ITypeDefinition): boolean {
|
||||
if (definition === null) {
|
||||
if (!definition) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1489,7 +1512,7 @@ function generateFactory2Method(definition: ITypeDefinition): string {
|
||||
result += "Syntax.emptySeparatedList<" + child.elementType + ">()";
|
||||
}
|
||||
else if (isOptional(child)) {
|
||||
result += "null";
|
||||
result += "undefined";
|
||||
}
|
||||
else if (child.isToken) {
|
||||
result += "Syntax.token(SyntaxKind." + tokenKinds(child)[0] + ")";
|
||||
@@ -1615,7 +1638,7 @@ function generateFirstTokenMethod(definition: ITypeDefinition): string {
|
||||
|
||||
result += "\r\n";
|
||||
result += " public firstToken(): ISyntaxToken {\r\n";
|
||||
result += " var token = null;\r\n";
|
||||
result += " var token: ISyntaxToken = undefined;\r\n";
|
||||
|
||||
for (var i = 0; i < definition.children.length; i++) {
|
||||
var child = definition.children[i];
|
||||
@@ -1631,7 +1654,7 @@ function generateFirstTokenMethod(definition: ITypeDefinition): string {
|
||||
result += " if (";
|
||||
|
||||
if (child.isOptional) {
|
||||
result += getPropertyAccess(child) + " !== null && ";
|
||||
result += getPropertyAccess(child) + " && ";
|
||||
}
|
||||
|
||||
if (child.isToken) {
|
||||
@@ -1639,7 +1662,7 @@ function generateFirstTokenMethod(definition: ITypeDefinition): string {
|
||||
result += ") { return " + getPropertyAccess(child) + "; }\r\n";
|
||||
}
|
||||
else {
|
||||
result += "(token = " + getPropertyAccess(child) + ".firstToken()) !== null";
|
||||
result += "(token = " + getPropertyAccess(child) + ".firstToken())";
|
||||
result += ") { return token; }\r\n";
|
||||
}
|
||||
}
|
||||
@@ -1648,7 +1671,7 @@ function generateFirstTokenMethod(definition: ITypeDefinition): string {
|
||||
result += " return this._endOfFileToken;\r\n";
|
||||
}
|
||||
else {
|
||||
result += " return null;\r\n";
|
||||
result += " return undefined;\r\n";
|
||||
}
|
||||
|
||||
result += " }\r\n";
|
||||
@@ -1668,7 +1691,7 @@ function generateLastTokenMethod(definition: ITypeDefinition): string {
|
||||
result += " return this._endOfFileToken;\r\n";
|
||||
}
|
||||
else {
|
||||
result += " var token = null;\r\n";
|
||||
result += " var token: ISyntaxToken = undefined;\r\n";
|
||||
|
||||
for (var i = definition.children.length - 1; i >= 0; i--) {
|
||||
var child = definition.children[i];
|
||||
@@ -1684,7 +1707,7 @@ function generateLastTokenMethod(definition: ITypeDefinition): string {
|
||||
result += " if (";
|
||||
|
||||
if (child.isOptional) {
|
||||
result += getPropertyAccess(child) + " !== null && ";
|
||||
result += getPropertyAccess(child) + " && ";
|
||||
}
|
||||
|
||||
if (child.isToken) {
|
||||
@@ -1692,12 +1715,12 @@ function generateLastTokenMethod(definition: ITypeDefinition): string {
|
||||
result += ") { return " + getPropertyAccess(child) + "; }\r\n";
|
||||
}
|
||||
else {
|
||||
result += "(token = " + getPropertyAccess(child) + ".lastToken()) !== null";
|
||||
result += "(token = " + getPropertyAccess(child) + ".lastToken())";
|
||||
result += ") { return token; }\r\n";
|
||||
}
|
||||
}
|
||||
|
||||
result += " return null;\r\n";
|
||||
result += " return undefined;\r\n";
|
||||
}
|
||||
|
||||
result += " }\r\n";
|
||||
@@ -1716,7 +1739,7 @@ function memberDefinitionType(child: IMemberDefinition): ITypeDefinition {
|
||||
|
||||
function derivesFrom(def1: ITypeDefinition, def2: ITypeDefinition): boolean {
|
||||
var current = def1;
|
||||
while (current !== null) {
|
||||
while (current) {
|
||||
var base = baseType(current);
|
||||
if (base === def2) {
|
||||
return true;
|
||||
@@ -1909,7 +1932,7 @@ function generateNode(definition: ITypeDefinition, abstract: boolean): string {
|
||||
result += " {\r\n";
|
||||
|
||||
if (definition.name === "SourceUnitSyntax") {
|
||||
result += " public syntaxTree: SyntaxTree = null;\r\n";
|
||||
result += " public syntaxTree: SyntaxTree = undefined;\r\n";
|
||||
}
|
||||
|
||||
for (var i = 0; i < definition.children.length; i++) {
|
||||
@@ -1930,7 +1953,7 @@ function generateNode(definition: ITypeDefinition, abstract: boolean): string {
|
||||
result += " super(data);\r\n";
|
||||
|
||||
if (definition.name === "SourceUnitSyntax") {
|
||||
result += " this.parent = null,\r\n";
|
||||
result += " this.parent = undefined,\r\n";
|
||||
}
|
||||
|
||||
if (definition.children) {
|
||||
@@ -2173,13 +2196,13 @@ function generateRewriter(): string {
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitList<T extends ISyntaxNodeOrToken>(list: T[]): T[] {\r\n" +
|
||||
" var newItems: T[] = null;\r\n" +
|
||||
" var newItems: T[] = undefined;\r\n" +
|
||||
"\r\n" +
|
||||
" for (var i = 0, n = list.length; i < n; i++) {\r\n" +
|
||||
" var item = list[i];\r\n" +
|
||||
" var newItem = <T>this.visitNodeOrToken(item);\r\n" +
|
||||
"\r\n" +
|
||||
" if (item !== newItem && newItems === null) {\r\n" +
|
||||
" if (item !== newItem && !newItems) {\r\n" +
|
||||
" newItems = [];\r\n" +
|
||||
" for (var j = 0; j < i; j++) {\r\n" +
|
||||
" newItems.push(list[j]);\r\n" +
|
||||
@@ -2191,18 +2214,18 @@ function generateRewriter(): string {
|
||||
" }\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" // Debug.assert(newItems === null || newItems.length === childCount(list));\r\n" +
|
||||
" return newItems === null ? list : Syntax.list<T>(newItems);\r\n" +
|
||||
" // Debug.assert(!newItems || newItems.length === childCount(list));\r\n" +
|
||||
" return !newItems ? list : Syntax.list<T>(newItems);\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitSeparatedList<T extends ISyntaxNodeOrToken>(list: T[]): T[] {\r\n" +
|
||||
" var newItems: ISyntaxNodeOrToken[] = null;\r\n" +
|
||||
" var newItems: ISyntaxNodeOrToken[] = undefined;\r\n" +
|
||||
"\r\n" +
|
||||
" for (var i = 0, n = childCount(list); i < n; i++) {\r\n" +
|
||||
" var item = childAt(list, i);\r\n" +
|
||||
" var newItem = isToken(item) ? <ISyntaxNodeOrToken>this.visitToken(<ISyntaxToken>item) : this.visitNode(<ISyntaxNode>item);\r\n" +
|
||||
"\r\n" +
|
||||
" if (item !== newItem && newItems === null) {\r\n" +
|
||||
" if (item !== newItem && !newItems) {\r\n" +
|
||||
" newItems = [];\r\n" +
|
||||
" for (var j = 0; j < i; j++) {\r\n" +
|
||||
" newItems.push(childAt(list, j));\r\n" +
|
||||
@@ -2214,8 +2237,8 @@ function generateRewriter(): string {
|
||||
" }\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" // Debug.assert(newItems === null || newItems.length === childCount(list));\r\n" +
|
||||
" return newItems === null ? list : Syntax.separatedList<T>(newItems);\r\n" +
|
||||
" // Debug.assert(newItems === undefined || newItems.length === childCount(list));\r\n" +
|
||||
" return !newItems ? list : Syntax.separatedList<T>(newItems);\r\n" +
|
||||
" }\r\n";
|
||||
|
||||
for (var i = 0; i < definitions.length; i++) {
|
||||
@@ -2242,7 +2265,7 @@ function generateRewriter(): string {
|
||||
|
||||
result += " ";
|
||||
if (child.isOptional) {
|
||||
result += "node." + child.name + " === null ? null : ";
|
||||
result += "!node." + child.name + " ? undefined : ";
|
||||
}
|
||||
|
||||
if (child.isToken) {
|
||||
@@ -2289,53 +2312,24 @@ function generateWalker(): string {
|
||||
" public visitToken(token: ISyntaxToken): void {\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitNode(node: ISyntaxNode): void {\r\n" +
|
||||
" visitNodeOrToken(this, node);\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {\r\n" +
|
||||
" if (isToken(nodeOrToken)) { \r\n" +
|
||||
" this.visitToken(<ISyntaxToken>nodeOrToken);\r\n" +
|
||||
" }\r\n" +
|
||||
" else {\r\n" +
|
||||
" this.visitNode(<ISyntaxNode>nodeOrToken);\r\n" +
|
||||
" }\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" private visitOptionalToken(token: ISyntaxToken): void {\r\n" +
|
||||
" if (token === null) {\r\n" +
|
||||
" if (token === undefined) {\r\n" +
|
||||
" return;\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" this.visitToken(token);\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitOptionalNode(node: ISyntaxNode): void {\r\n" +
|
||||
" if (node === null) {\r\n" +
|
||||
" return;\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" this.visitNode(node);\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitOptionalNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {\r\n" +
|
||||
" if (nodeOrToken === null) {\r\n" +
|
||||
" return;\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" this.visitNodeOrToken(nodeOrToken);\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitList(list: ISyntaxNodeOrToken[]): void {\r\n" +
|
||||
" for (var i = 0, n = list.length; i < n; i++) {\r\n" +
|
||||
" this.visitNodeOrToken(list[i]);\r\n" +
|
||||
" visitNodeOrToken(this, list[i]);\r\n" +
|
||||
" }\r\n" +
|
||||
" }\r\n" +
|
||||
"\r\n" +
|
||||
" public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {\r\n" +
|
||||
" for (var i = 0, n = childCount(list); i < n; i++) {\r\n" +
|
||||
" var item = childAt(list, i);\r\n" +
|
||||
" this.visitNodeOrToken(item);\r\n" +
|
||||
" visitNodeOrToken(this, item);\r\n" +
|
||||
" }\r\n" +
|
||||
" }\r\n";
|
||||
|
||||
@@ -2363,20 +2357,10 @@ function generateWalker(): string {
|
||||
result += " this.visitSeparatedList(node." + child.name + ");\r\n";
|
||||
}
|
||||
else if (isNodeOrToken(child)) {
|
||||
if (child.isOptional) {
|
||||
result += " this.visitOptionalNodeOrToken(node." + child.name + ");\r\n";
|
||||
}
|
||||
else {
|
||||
result += " this.visitNodeOrToken(node." + child.name + ");\r\n";
|
||||
}
|
||||
result += " visitNodeOrToken(this, node." + child.name + ");\r\n";
|
||||
}
|
||||
else if (child.type !== "SyntaxKind") {
|
||||
if (child.isOptional) {
|
||||
result += " this.visitOptionalNode(node." + child.name + ");\r\n";
|
||||
}
|
||||
else {
|
||||
result += " this.visitNode(node." + child.name + ");\r\n";
|
||||
}
|
||||
result += " visitNodeOrToken(this, node." + child.name + ");\r\n";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2535,7 +2519,7 @@ function generateVisitor(): string {
|
||||
|
||||
result += "module TypeScript {\r\n";
|
||||
result += " export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {\r\n";
|
||||
result += " if (element === null) { return null; }\r\n";
|
||||
result += " if (element === undefined) { return undefined; }\r\n";
|
||||
result += " if (isToken(element)) { return visitor.visitToken(<ISyntaxToken>element); }\r\n";
|
||||
result += " switch (element.kind()) {\r\n";
|
||||
|
||||
@@ -2584,7 +2568,7 @@ function generateDefaultVisitor(): string {
|
||||
if (!forPrettyPrinter) {
|
||||
result += " export class SyntaxVisitor implements ISyntaxVisitor {\r\n";
|
||||
result += " public defaultVisit(node: ISyntaxNodeOrToken): any {\r\n";
|
||||
result += " return null;\r\n";
|
||||
result += " return undefined;\r\n";
|
||||
result += " }\r\n";
|
||||
result += "\r\n";
|
||||
result += " public visitToken(token: ISyntaxToken): any {\r\n";
|
||||
@@ -2738,7 +2722,7 @@ function generateIsTypeScriptSpecific(): string {
|
||||
result += " }\r\n\r\n";
|
||||
|
||||
result += " export function isTypeScriptSpecific(element: ISyntaxElement): boolean {\r\n"
|
||||
result += " if (element === null) { return false; }\r\n";
|
||||
result += " if (!element) { return false; }\r\n";
|
||||
result += " if (isToken(element)) { return false; }\r\n";
|
||||
result += " if (isList(element)) { return isListTypeScriptSpecific(<ISyntaxNodeOrToken[]>element); }\r\n";
|
||||
result += " if (isSeparatedList(element)) { return isSeparatedListTypeScriptSpecific(<ISyntaxNodeOrToken[]>element); }\r\n\r\n";
|
||||
@@ -2855,7 +2839,7 @@ function generateIsTypeScriptSpecificMethod(definition: ITypeDefinition): string
|
||||
result += getPropertyAccess(child, "node") + ".childCount() > 0";
|
||||
}
|
||||
else {
|
||||
result += getPropertyAccess(child, "node") + " !== null";
|
||||
result += "!!" + getPropertyAccess(child, "node");
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
||||
@@ -159,6 +159,8 @@ module TypeScript {
|
||||
GenericType,
|
||||
TypeQuery,
|
||||
TupleType,
|
||||
UnionType,
|
||||
ParenthesizedType,
|
||||
|
||||
// Module elements.
|
||||
InterfaceDeclaration,
|
||||
|
||||
@@ -51,7 +51,7 @@ module TypeScript.Syntax {
|
||||
}
|
||||
|
||||
export function list<T extends ISyntaxNodeOrToken>(nodes: T[]): T[] {
|
||||
if (nodes === undefined || nodes === null || nodes.length === 0) {
|
||||
if (!nodes || nodes.length === 0) {
|
||||
return emptyList<T>();
|
||||
}
|
||||
|
||||
@@ -63,7 +63,7 @@ module TypeScript.Syntax {
|
||||
}
|
||||
|
||||
export function separatedList<T extends ISyntaxNodeOrToken>(nodes: T[], separators: ISyntaxToken[]): T[] {
|
||||
if (nodes === undefined || nodes === null || nodes.length === 0) {
|
||||
if (!nodes || nodes.length === 0) {
|
||||
return emptySeparatedList<T>();
|
||||
}
|
||||
|
||||
|
||||
@@ -6,12 +6,12 @@ module TypeScript.Syntax.Abstract {
|
||||
export var isConcrete: boolean = false;
|
||||
|
||||
export class SourceUnitSyntax extends SyntaxNode {
|
||||
public syntaxTree: SyntaxTree = null;
|
||||
public syntaxTree: SyntaxTree = undefined;
|
||||
public moduleElements: IModuleElementSyntax[];
|
||||
public endOfFileToken: ISyntaxToken;
|
||||
constructor(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken) {
|
||||
super(data);
|
||||
this.parent = null,
|
||||
this.parent = undefined,
|
||||
this.moduleElements = moduleElements,
|
||||
this.endOfFileToken = endOfFileToken,
|
||||
!isShared(moduleElements) && (moduleElements.parent = this),
|
||||
@@ -119,6 +119,30 @@ module TypeScript.Syntax.Abstract {
|
||||
!isShared(types) && (types.parent = this);
|
||||
}
|
||||
}
|
||||
export class UnionTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public left: ITypeSyntax;
|
||||
public barToken: ISyntaxToken;
|
||||
public right: ITypeSyntax;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) {
|
||||
super(data);
|
||||
this.left = left,
|
||||
this.right = right,
|
||||
left.parent = this,
|
||||
right.parent = this;
|
||||
}
|
||||
}
|
||||
export class ParenthesizedTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public openParenToken: ISyntaxToken;
|
||||
public type: ITypeSyntax;
|
||||
public closeParenToken: ISyntaxToken;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) {
|
||||
super(data);
|
||||
this.type = type,
|
||||
type.parent = this;
|
||||
}
|
||||
}
|
||||
export class InterfaceDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
|
||||
public modifiers: ISyntaxToken[];
|
||||
public interfaceKeyword: ISyntaxToken;
|
||||
@@ -1201,5 +1225,5 @@ module TypeScript.Syntax.Abstract {
|
||||
}
|
||||
}
|
||||
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kind = SyntaxKind.VariableDeclaration, (<any>VariableDeclaratorSyntax).prototype.__kind = SyntaxKind.VariableDeclarator, (<any>ArgumentListSyntax)Line truncated
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>UnionTypeSyntax).prototype.__kind = SyntaxKind.UnionType, (<any>ParenthesizedTypeSyntax).prototype.__kind = SyntaxKind.ParenthesizedType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kiLine truncated
|
||||
}
|
||||
@@ -6,12 +6,12 @@ module TypeScript.Syntax.Concrete {
|
||||
export var isConcrete: boolean = true;
|
||||
|
||||
export class SourceUnitSyntax extends SyntaxNode {
|
||||
public syntaxTree: SyntaxTree = null;
|
||||
public syntaxTree: SyntaxTree = undefined;
|
||||
public moduleElements: IModuleElementSyntax[];
|
||||
public endOfFileToken: ISyntaxToken;
|
||||
constructor(data: number, moduleElements: IModuleElementSyntax[], endOfFileToken: ISyntaxToken) {
|
||||
super(data);
|
||||
this.parent = null,
|
||||
this.parent = undefined,
|
||||
this.moduleElements = moduleElements,
|
||||
this.endOfFileToken = endOfFileToken,
|
||||
!isShared(moduleElements) && (moduleElements.parent = this),
|
||||
@@ -141,6 +141,36 @@ module TypeScript.Syntax.Concrete {
|
||||
closeBracketToken.parent = this;
|
||||
}
|
||||
}
|
||||
export class UnionTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public left: ITypeSyntax;
|
||||
public barToken: ISyntaxToken;
|
||||
public right: ITypeSyntax;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax) {
|
||||
super(data);
|
||||
this.left = left,
|
||||
this.barToken = barToken,
|
||||
this.right = right,
|
||||
left.parent = this,
|
||||
barToken.parent = this,
|
||||
right.parent = this;
|
||||
}
|
||||
}
|
||||
export class ParenthesizedTypeSyntax extends SyntaxNode implements ITypeSyntax {
|
||||
public openParenToken: ISyntaxToken;
|
||||
public type: ITypeSyntax;
|
||||
public closeParenToken: ISyntaxToken;
|
||||
public _typeBrand: any;
|
||||
constructor(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken) {
|
||||
super(data);
|
||||
this.openParenToken = openParenToken,
|
||||
this.type = type,
|
||||
this.closeParenToken = closeParenToken,
|
||||
openParenToken.parent = this,
|
||||
type.parent = this,
|
||||
closeParenToken.parent = this;
|
||||
}
|
||||
}
|
||||
export class InterfaceDeclarationSyntax extends SyntaxNode implements IModuleElementSyntax {
|
||||
public modifiers: ISyntaxToken[];
|
||||
public interfaceKeyword: ISyntaxToken;
|
||||
@@ -1435,5 +1465,5 @@ module TypeScript.Syntax.Concrete {
|
||||
}
|
||||
}
|
||||
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kind = SyntaxKind.VariableDeclaration, (<any>VariableDeclaratorSyntax).prototype.__kind = SyntaxKind.VariableDeclarator, (<any>ArgumentListSyntax)Line truncated
|
||||
(<any>SourceUnitSyntax).prototype.__kind = SyntaxKind.SourceUnit, (<any>QualifiedNameSyntax).prototype.__kind = SyntaxKind.QualifiedName, (<any>ObjectTypeSyntax).prototype.__kind = SyntaxKind.ObjectType, (<any>FunctionTypeSyntax).prototype.__kind = SyntaxKind.FunctionType, (<any>ArrayTypeSyntax).prototype.__kind = SyntaxKind.ArrayType, (<any>ConstructorTypeSyntax).prototype.__kind = SyntaxKind.ConstructorType, (<any>GenericTypeSyntax).prototype.__kind = SyntaxKind.GenericType, (<any>TypeQuerySyntax).prototype.__kind = SyntaxKind.TypeQuery, (<any>TupleTypeSyntax).prototype.__kind = SyntaxKind.TupleType, (<any>UnionTypeSyntax).prototype.__kind = SyntaxKind.UnionType, (<any>ParenthesizedTypeSyntax).prototype.__kind = SyntaxKind.ParenthesizedType, (<any>InterfaceDeclarationSyntax).prototype.__kind = SyntaxKind.InterfaceDeclaration, (<any>FunctionDeclarationSyntax).prototype.__kind = SyntaxKind.FunctionDeclaration, (<any>ModuleDeclarationSyntax).prototype.__kind = SyntaxKind.ModuleDeclaration, (<any>ClassDeclarationSyntax).prototype.__kind = SyntaxKind.ClassDeclaration, (<any>EnumDeclarationSyntax).prototype.__kind = SyntaxKind.EnumDeclaration, (<any>ImportDeclarationSyntax).prototype.__kind = SyntaxKind.ImportDeclaration, (<any>ExportAssignmentSyntax).prototype.__kind = SyntaxKind.ExportAssignment, (<any>MemberFunctionDeclarationSyntax).prototype.__kind = SyntaxKind.MemberFunctionDeclaration, (<any>MemberVariableDeclarationSyntax).prototype.__kind = SyntaxKind.MemberVariableDeclaration, (<any>ConstructorDeclarationSyntax).prototype.__kind = SyntaxKind.ConstructorDeclaration, (<any>IndexMemberDeclarationSyntax).prototype.__kind = SyntaxKind.IndexMemberDeclaration, (<any>GetAccessorSyntax).prototype.__kind = SyntaxKind.GetAccessor, (<any>SetAccessorSyntax).prototype.__kind = SyntaxKind.SetAccessor, (<any>PropertySignatureSyntax).prototype.__kind = SyntaxKind.PropertySignature, (<any>CallSignatureSyntax).prototype.__kind = SyntaxKind.CallSignature, (<any>ConstructSignatureSyntax).prototype.__kind = SyntaxKind.ConstructSignature, (<any>IndexSignatureSyntax).prototype.__kind = SyntaxKind.IndexSignature, (<any>MethodSignatureSyntax).prototype.__kind = SyntaxKind.MethodSignature, (<any>BlockSyntax).prototype.__kind = SyntaxKind.Block, (<any>IfStatementSyntax).prototype.__kind = SyntaxKind.IfStatement, (<any>VariableStatementSyntax).prototype.__kind = SyntaxKind.VariableStatement, (<any>ExpressionStatementSyntax).prototype.__kind = SyntaxKind.ExpressionStatement, (<any>ReturnStatementSyntax).prototype.__kind = SyntaxKind.ReturnStatement, (<any>SwitchStatementSyntax).prototype.__kind = SyntaxKind.SwitchStatement, (<any>BreakStatementSyntax).prototype.__kind = SyntaxKind.BreakStatement, (<any>ContinueStatementSyntax).prototype.__kind = SyntaxKind.ContinueStatement, (<any>ForStatementSyntax).prototype.__kind = SyntaxKind.ForStatement, (<any>ForInStatementSyntax).prototype.__kind = SyntaxKind.ForInStatement, (<any>EmptyStatementSyntax).prototype.__kind = SyntaxKind.EmptyStatement, (<any>ThrowStatementSyntax).prototype.__kind = SyntaxKind.ThrowStatement, (<any>WhileStatementSyntax).prototype.__kind = SyntaxKind.WhileStatement, (<any>TryStatementSyntax).prototype.__kind = SyntaxKind.TryStatement, (<any>LabeledStatementSyntax).prototype.__kind = SyntaxKind.LabeledStatement, (<any>DoStatementSyntax).prototype.__kind = SyntaxKind.DoStatement, (<any>DebuggerStatementSyntax).prototype.__kind = SyntaxKind.DebuggerStatement, (<any>WithStatementSyntax).prototype.__kind = SyntaxKind.WithStatement, (<any>DeleteExpressionSyntax).prototype.__kind = SyntaxKind.DeleteExpression, (<any>TypeOfExpressionSyntax).prototype.__kind = SyntaxKind.TypeOfExpression, (<any>VoidExpressionSyntax).prototype.__kind = SyntaxKind.VoidExpression, (<any>ConditionalExpressionSyntax).prototype.__kind = SyntaxKind.ConditionalExpression, (<any>MemberAccessExpressionSyntax).prototype.__kind = SyntaxKind.MemberAccessExpression, (<any>InvocationExpressionSyntax).prototype.__kind = SyntaxKind.InvocationExpression, (<any>ArrayLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ArrayLiteralExpression, (<any>ObjectLiteralExpressionSyntax).prototype.__kind = SyntaxKind.ObjectLiteralExpression, (<any>ObjectCreationExpressionSyntax).prototype.__kind = SyntaxKind.ObjectCreationExpression, (<any>ParenthesizedExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedExpression, (<any>ParenthesizedArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.ParenthesizedArrowFunctionExpression, (<any>SimpleArrowFunctionExpressionSyntax).prototype.__kind = SyntaxKind.SimpleArrowFunctionExpression, (<any>CastExpressionSyntax).prototype.__kind = SyntaxKind.CastExpression, (<any>ElementAccessExpressionSyntax).prototype.__kind = SyntaxKind.ElementAccessExpression, (<any>FunctionExpressionSyntax).prototype.__kind = SyntaxKind.FunctionExpression, (<any>OmittedExpressionSyntax).prototype.__kind = SyntaxKind.OmittedExpression, (<any>VariableDeclarationSyntax).prototype.__kiLine truncated
|
||||
}
|
||||
@@ -47,6 +47,16 @@ module TypeScript {
|
||||
types: ITypeSyntax[];
|
||||
closeBracketToken: ISyntaxToken;
|
||||
}
|
||||
export interface UnionTypeSyntax extends ISyntaxNode, ITypeSyntax {
|
||||
left: ITypeSyntax;
|
||||
barToken: ISyntaxToken;
|
||||
right: ITypeSyntax;
|
||||
}
|
||||
export interface ParenthesizedTypeSyntax extends ISyntaxNode, ITypeSyntax {
|
||||
openParenToken: ISyntaxToken;
|
||||
type: ITypeSyntax;
|
||||
closeParenToken: ISyntaxToken;
|
||||
}
|
||||
export interface InterfaceDeclarationSyntax extends ISyntaxNode, IModuleElementSyntax {
|
||||
modifiers: ISyntaxToken[];
|
||||
interfaceKeyword: ISyntaxToken;
|
||||
@@ -483,7 +493,7 @@ module TypeScript {
|
||||
moduleName: INameSyntax;
|
||||
}
|
||||
|
||||
export var nodeMetadata: string[][] = [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],["moduleElements","endOfFileToken"],["left","dotToken","right"],["openBraceToken","typeMembers","closeBraceToken"],["typeParameterList","parameterList","equalsGreaterThanToken","type"],["type","openBracketToken","closeBracketToken"],["newKeyword","typeParameterList","parameterList","equalsGreaterThanToken","type"],["name","typeArgumentList"],["typeOfKeyword","name"],["openBracketToken","types","closeBracketToken"],["modifiers","interfaceKeyword","identifier","typeParameterList","heritageClauses","body"],["modifiers","functionKeyword","identifier","callSignature","block","semicolonToken"],["modifiers","moduleKeyword","name","stringLiteral","openBraceToken","moduleElements","closeBraceToken"],["modifiers","classKeyword","identifier","typeParameterList","heritageClauses","openBraceToken","classElements","closeBraceToken"],["modifiers","enumKeyword","identifier","openBraceToken","enumElements","closeBraceToken"],["modifiers","importKeyword","identifier","equalsToken","moduleReference","semicolonToken"],["exportKeyword","equalsToken","identifier","semicolonToken"],["modifiers","propertyName","callSignature","block","semicolonToken"],["modifiers","variableDeclarator","semicolonToken"],["modifiers","constructorKeyword","callSignature","block","semicolonToken"],["modifiers","indexSignature","semicolonToken"],["modifiers","getKeyword","propertyName","callSignature","block"],["modifiers","setKeyword","propertyName","callSignature","block"],["propertyName","questionToken","typeAnnotation"],["typeParameterList","parameterList","typeAnnotation"],["newKeyword","callSignature"],["openBracketToken","parameters","closeBracketToken","typeAnnotation"],["propertyName","questionToken","callSignature"],["openBraceToken","statements","closeBraceToken"],["ifKeyword","openParenToken","condition","closeParenToken","statement","elseClause"],["modifiers","variableDeclaration","semicolonToken"],["expression","semicolonToken"],["returnKeyword","expression","semicolonToken"],["switchKeyword","openParenToken","expression","closeParenToken","openBraceToken","switchClauses","closeBraceToken"],["breakKeyword","identifier","semicolonToken"],["continueKeyword","identifier","semicolonToken"],["forKeyword","openParenToken","variableDeclaration","initializer","firstSemicolonToken","condition","secondSemicolonToken","incrementor","closeParenToken","statement"],["forKeyword","openParenToken","variableDeclaration","left","inKeyword","expression","closeParenToken","statement"],["semicolonToken"],["throwKeyword","expression","semicolonToken"],["whileKeyword","openParenToken","condition","closeParenToken","statement"],["tryKeyword","block","catchClause","finallyClause"],["identifier","colonToken","statement"],["doKeyword","statement","whileKeyword","openParenToken","condition","closeParenToken","semicolonToken"],["debuggerKeyword","semicolonToken"],["withKeyword","openParenToken","condition","closeParenToken","statement"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["deleteKeyword","expression"],["typeOfKeyword","expression"],["voidKeyword","expression"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["condition","questionToken","whenTrue","colonToken","whenFalse"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["operand","operatorToken"],["operand","operatorToken"],["expression","dotToken","name"],["expression","argumentList"],["openBracketToken","expressions",Line truncated
|
||||
export var nodeMetadata: string[][] = [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],["moduleElements","endOfFileToken"],["left","dotToken","right"],["openBraceToken","typeMembers","closeBraceToken"],["typeParameterList","parameterList","equalsGreaterThanToken","type"],["type","openBracketToken","closeBracketToken"],["newKeyword","typeParameterList","parameterList","equalsGreaterThanToken","type"],["name","typeArgumentList"],["typeOfKeyword","name"],["openBracketToken","types","closeBracketToken"],["left","barToken","right"],["openParenToken","type","closeParenToken"],["modifiers","interfaceKeyword","identifier","typeParameterList","heritageClauses","body"],["modifiers","functionKeyword","identifier","callSignature","block","semicolonToken"],["modifiers","moduleKeyword","name","stringLiteral","openBraceToken","moduleElements","closeBraceToken"],["modifiers","classKeyword","identifier","typeParameterList","heritageClauses","openBraceToken","classElements","closeBraceToken"],["modifiers","enumKeyword","identifier","openBraceToken","enumElements","closeBraceToken"],["modifiers","importKeyword","identifier","equalsToken","moduleReference","semicolonToken"],["exportKeyword","equalsToken","identifier","semicolonToken"],["modifiers","propertyName","callSignature","block","semicolonToken"],["modifiers","variableDeclarator","semicolonToken"],["modifiers","constructorKeyword","callSignature","block","semicolonToken"],["modifiers","indexSignature","semicolonToken"],["modifiers","getKeyword","propertyName","callSignature","block"],["modifiers","setKeyword","propertyName","callSignature","block"],["propertyName","questionToken","typeAnnotation"],["typeParameterList","parameterList","typeAnnotation"],["newKeyword","callSignature"],["openBracketToken","parameters","closeBracketToken","typeAnnotation"],["propertyName","questionToken","callSignature"],["openBraceToken","statements","closeBraceToken"],["ifKeyword","openParenToken","condition","closeParenToken","statement","elseClause"],["modifiers","variableDeclaration","semicolonToken"],["expression","semicolonToken"],["returnKeyword","expression","semicolonToken"],["switchKeyword","openParenToken","expression","closeParenToken","openBraceToken","switchClauses","closeBraceToken"],["breakKeyword","identifier","semicolonToken"],["continueKeyword","identifier","semicolonToken"],["forKeyword","openParenToken","variableDeclaration","initializer","firstSemicolonToken","condition","secondSemicolonToken","incrementor","closeParenToken","statement"],["forKeyword","openParenToken","variableDeclaration","left","inKeyword","expression","closeParenToken","statement"],["semicolonToken"],["throwKeyword","expression","semicolonToken"],["whileKeyword","openParenToken","condition","closeParenToken","statement"],["tryKeyword","block","catchClause","finallyClause"],["identifier","colonToken","statement"],["doKeyword","statement","whileKeyword","openParenToken","condition","closeParenToken","semicolonToken"],["debuggerKeyword","semicolonToken"],["withKeyword","openParenToken","condition","closeParenToken","statement"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["operatorToken","operand"],["deleteKeyword","expression"],["typeOfKeyword","expression"],["voidKeyword","expression"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["condition","questionToken","whenTrue","colonToken","whenFalse"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["left","operatorToken","right"],["operand","operatorToken"],["operand","operatorToken"],["expression","dotToken",Line truncated
|
||||
|
||||
export module Syntax {
|
||||
export interface ISyntaxFactory {
|
||||
@@ -497,6 +507,8 @@ module TypeScript {
|
||||
GenericTypeSyntax: { new(data: number, name: INameSyntax, typeArgumentList: TypeArgumentListSyntax): GenericTypeSyntax };
|
||||
TypeQuerySyntax: { new(data: number, typeOfKeyword: ISyntaxToken, name: INameSyntax): TypeQuerySyntax };
|
||||
TupleTypeSyntax: { new(data: number, openBracketToken: ISyntaxToken, types: ITypeSyntax[], closeBracketToken: ISyntaxToken): TupleTypeSyntax };
|
||||
UnionTypeSyntax: { new(data: number, left: ITypeSyntax, barToken: ISyntaxToken, right: ITypeSyntax): UnionTypeSyntax };
|
||||
ParenthesizedTypeSyntax: { new(data: number, openParenToken: ISyntaxToken, type: ITypeSyntax, closeParenToken: ISyntaxToken): ParenthesizedTypeSyntax };
|
||||
InterfaceDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], interfaceKeyword: ISyntaxToken, identifier: ISyntaxToken, typeParameterList: TypeParameterListSyntax, heritageClauses: HeritageClauseSyntax[], body: ObjectTypeSyntax): InterfaceDeclarationSyntax };
|
||||
FunctionDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], functionKeyword: ISyntaxToken, identifier: ISyntaxToken, callSignature: CallSignatureSyntax, block: BlockSyntax, semicolonToken: ISyntaxToken): FunctionDeclarationSyntax };
|
||||
ModuleDeclarationSyntax: { new(data: number, modifiers: ISyntaxToken[], moduleKeyword: ISyntaxToken, name: INameSyntax, stringLiteral: ISyntaxToken, openBraceToken: ISyntaxToken, moduleElements: IModuleElementSyntax[], closeBraceToken: ISyntaxToken): ModuleDeclarationSyntax };
|
||||
|
||||
@@ -71,7 +71,7 @@ module TypeScript {
|
||||
module TypeScript {
|
||||
export function tokenValue(token: ISyntaxToken): any {
|
||||
if (token.fullWidth() === 0) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
var kind = token.kind();
|
||||
@@ -87,7 +87,7 @@ module TypeScript {
|
||||
case SyntaxKind.FalseKeyword:
|
||||
return false;
|
||||
case SyntaxKind.NullKeyword:
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
if (SyntaxFacts.isAnyKeyword(kind) || SyntaxFacts.isAnyPunctuation(kind)) {
|
||||
@@ -112,7 +112,7 @@ module TypeScript {
|
||||
return regularExpressionValue(text);
|
||||
}
|
||||
else if (kind === SyntaxKind.EndOfFileToken || kind === SyntaxKind.ErrorToken) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
else {
|
||||
throw Errors.invalidOperation();
|
||||
@@ -121,7 +121,7 @@ module TypeScript {
|
||||
|
||||
export function tokenValueText(token: ISyntaxToken): string {
|
||||
var value = tokenValue(token);
|
||||
return value === null ? "" : massageDisallowedIdentifiers(value.toString());
|
||||
return value === undefined ? "" : massageDisallowedIdentifiers(value.toString());
|
||||
}
|
||||
|
||||
export function massageEscapes(text: string): string {
|
||||
@@ -136,7 +136,7 @@ module TypeScript {
|
||||
return new RegExp(body, flags);
|
||||
}
|
||||
catch (e) {
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -235,13 +235,13 @@ module TypeScript {
|
||||
characterArray.push(ch);
|
||||
|
||||
if (i && !(i % 1024)) {
|
||||
result = result.concat(String.fromCharCode.apply(null, characterArray));
|
||||
result = result.concat(String.fromCharCode.apply(undefined, characterArray));
|
||||
characterArray.length = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (characterArray.length) {
|
||||
result = result.concat(String.fromCharCode.apply(null, characterArray));
|
||||
result = result.concat(String.fromCharCode.apply(undefined, characterArray));
|
||||
}
|
||||
|
||||
return result;
|
||||
@@ -330,14 +330,14 @@ module TypeScript.Syntax {
|
||||
// the full-start of this token to be at the full-end of that element.
|
||||
|
||||
var previousElement = this.previousNonZeroWidthElement();
|
||||
return previousElement === null ? 0 : fullStart(previousElement) + fullWidth(previousElement);
|
||||
return !previousElement ? 0 : fullStart(previousElement) + fullWidth(previousElement);
|
||||
}
|
||||
|
||||
private previousNonZeroWidthElement(): ISyntaxElement {
|
||||
var current: ISyntaxElement = this;
|
||||
while (true) {
|
||||
var parent = current.parent;
|
||||
if (parent === null) {
|
||||
if (parent === undefined) {
|
||||
Debug.assert(current.kind() === SyntaxKind.SourceUnit, "We had a node without a parent that was not the root node!");
|
||||
|
||||
// We walked all the way to the top, and never found a previous element. This
|
||||
@@ -346,9 +346,9 @@ module TypeScript.Syntax {
|
||||
// / b;
|
||||
//
|
||||
// We will have an empty identifier token as the first token in the tree. In
|
||||
// this case, return null so that the position of the empty token will be
|
||||
// this case, return undefined so that the position of the empty token will be
|
||||
// considered to be 0.
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
// Ok. We have a parent. First, find out which slot we're at in the parent.
|
||||
|
||||
@@ -8,7 +8,7 @@ module TypeScript {
|
||||
private _sourceUnit: SourceUnitSyntax;
|
||||
private _isDeclaration: boolean;
|
||||
private _parserDiagnostics: Diagnostic[];
|
||||
private _allDiagnostics: Diagnostic[] = null;
|
||||
private _allDiagnostics: Diagnostic[] = undefined;
|
||||
private _fileName: string;
|
||||
private _lineMap: LineMap;
|
||||
private _languageVersion: ts.ScriptTarget;
|
||||
@@ -60,7 +60,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
public diagnostics(): Diagnostic[] {
|
||||
if (this._allDiagnostics === null) {
|
||||
if (!this._allDiagnostics) {
|
||||
var start = new Date().getTime();
|
||||
this._allDiagnostics = this.computeDiagnostics();
|
||||
syntaxDiagnosticsTime += new Date().getTime() - start;
|
||||
@@ -87,7 +87,7 @@ module TypeScript {
|
||||
var firstToken = firstSyntaxTreeToken(this);
|
||||
var leadingTrivia = firstToken.leadingTrivia(this.text);
|
||||
|
||||
this._isExternalModule = externalModuleIndicatorSpanWorker(this, firstToken) !== null;
|
||||
this._isExternalModule = !!externalModuleIndicatorSpanWorker(this, firstToken);
|
||||
|
||||
var amdDependencies: string[] = [];
|
||||
for (var i = 0, n = leadingTrivia.count(); i < n; i++) {
|
||||
@@ -106,7 +106,7 @@ module TypeScript {
|
||||
private getAmdDependency(comment: string): string {
|
||||
var amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s+path=('|")(.+?)\1/gim;
|
||||
var match = amdDependencyRegEx.exec(comment);
|
||||
return match ? match[2] : null;
|
||||
return match ? match[2] : undefined;
|
||||
}
|
||||
|
||||
public isExternalModule(): boolean {
|
||||
@@ -144,7 +144,7 @@ module TypeScript {
|
||||
this.text = syntaxTree.text;
|
||||
}
|
||||
|
||||
private pushDiagnostic(element: ISyntaxElement, diagnosticKey: string, args: any[] = null): void {
|
||||
private pushDiagnostic(element: ISyntaxElement, diagnosticKey: string, args?: any[]): void {
|
||||
this.diagnostics.push(new Diagnostic(
|
||||
this.syntaxTree.fileName(), this.syntaxTree.lineMap(), start(element, this.text), width(element), diagnosticKey, args));
|
||||
}
|
||||
@@ -303,7 +303,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
public visitVariableDeclaration(node: VariableDeclarationSyntax): void {
|
||||
if (this.checkForAtLeastOneElement(node, node.variableDeclarators, node.varKeyword, getLocalizedText(DiagnosticCode.variable_declaration, null)) ||
|
||||
if (this.checkForAtLeastOneElement(node, node.variableDeclarators, node.varKeyword, getLocalizedText(DiagnosticCode.variable_declaration, undefined)) ||
|
||||
this.checkForTrailingComma(node.variableDeclarators)) {
|
||||
return;
|
||||
}
|
||||
@@ -313,7 +313,7 @@ module TypeScript {
|
||||
|
||||
public visitTypeArgumentList(node: TypeArgumentListSyntax): void {
|
||||
if (this.checkForTrailingComma(node.typeArguments) ||
|
||||
this.checkForAtLeastOneElement(node, node.typeArguments, node.lessThanToken, getLocalizedText(DiagnosticCode.type_argument, null))) {
|
||||
this.checkForAtLeastOneElement(node, node.typeArguments, node.lessThanToken, getLocalizedText(DiagnosticCode.type_argument, undefined))) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -322,7 +322,7 @@ module TypeScript {
|
||||
|
||||
public visitTupleType(node: TupleTypeSyntax): void {
|
||||
if (this.checkForTrailingComma(node.types) ||
|
||||
this.checkForAtLeastOneElement(node, node.types, node.openBracketToken, getLocalizedText(DiagnosticCode.type, null))) {
|
||||
this.checkForAtLeastOneElement(node, node.types, node.openBracketToken, getLocalizedText(DiagnosticCode.type, undefined))) {
|
||||
return
|
||||
}
|
||||
|
||||
@@ -331,7 +331,7 @@ module TypeScript {
|
||||
|
||||
public visitTypeParameterList(node: TypeParameterListSyntax): void {
|
||||
if (this.checkForTrailingComma(node.typeParameters) ||
|
||||
this.checkForAtLeastOneElement(node, node.typeParameters, node.lessThanToken, getLocalizedText(DiagnosticCode.type_parameter, null))) {
|
||||
this.checkForAtLeastOneElement(node, node.typeParameters, node.lessThanToken, getLocalizedText(DiagnosticCode.type_parameter, undefined))) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -635,7 +635,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
private checkForDisallowedAccessorTypeParameters(callSignature: CallSignatureSyntax): boolean {
|
||||
if (callSignature.typeParameterList !== null) {
|
||||
if (callSignature.typeParameterList) {
|
||||
this.pushDiagnostic(callSignature.typeParameterList, DiagnosticCode.Type_parameters_cannot_appear_on_an_accessor);
|
||||
return true;
|
||||
}
|
||||
@@ -745,7 +745,7 @@ module TypeScript {
|
||||
|
||||
public visitInvocationExpression(node: InvocationExpressionSyntax): void {
|
||||
if (node.expression.kind() === SyntaxKind.SuperKeyword &&
|
||||
node.argumentList.typeArgumentList !== null) {
|
||||
node.argumentList.typeArgumentList) {
|
||||
this.pushDiagnostic(node, DiagnosticCode.super_invocation_cannot_have_type_arguments);
|
||||
}
|
||||
|
||||
@@ -1529,11 +1529,11 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
private isEvalOrArguments(expr: IExpressionSyntax): boolean {
|
||||
return this.getEvalOrArguments(expr) !== null;
|
||||
return !!this.getEvalOrArguments(expr);
|
||||
}
|
||||
|
||||
public visitConstraint(node: ConstraintSyntax): void {
|
||||
@@ -1583,7 +1583,7 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function implicitImportSpanWorker(trivia: ISyntaxTrivia): TextSpan {
|
||||
@@ -1594,7 +1594,7 @@ module TypeScript {
|
||||
return new TextSpan(trivia.fullStart(), trivia.fullWidth());
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
function topLevelImportOrExportSpan(node: SourceUnitSyntax): TextSpan {
|
||||
@@ -1602,7 +1602,7 @@ module TypeScript {
|
||||
var moduleElement = node.moduleElements[i];
|
||||
|
||||
var _firstToken = firstToken(moduleElement);
|
||||
if (_firstToken !== null && _firstToken.kind() === SyntaxKind.ExportKeyword) {
|
||||
if (_firstToken && _firstToken.kind() === SyntaxKind.ExportKeyword) {
|
||||
return new TextSpan(start(_firstToken), width(_firstToken));
|
||||
}
|
||||
|
||||
@@ -1615,6 +1615,6 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
@@ -233,7 +233,7 @@ module TypeScript.Syntax {
|
||||
}
|
||||
|
||||
export function triviaList(trivia: ISyntaxTrivia[]): ISyntaxTriviaList {
|
||||
if (trivia === undefined || trivia === null || trivia.length === 0) {
|
||||
if (!trivia || trivia.length === 0) {
|
||||
return Syntax.emptyTriviaList;
|
||||
}
|
||||
|
||||
|
||||
@@ -21,7 +21,7 @@ module TypeScript {
|
||||
|
||||
public static isLastTokenOnLine(token: ISyntaxToken, text: ISimpleText): boolean {
|
||||
var _nextToken = nextToken(token, text);
|
||||
if (_nextToken === null) {
|
||||
if (_nextToken === undefined) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -252,7 +252,7 @@ module TypeScript {
|
||||
public static isAngleBracket(positionedElement: ISyntaxElement): boolean {
|
||||
var element = positionedElement;
|
||||
var parent = positionedElement.parent;
|
||||
if (parent !== null && (element.kind() === SyntaxKind.LessThanToken || element.kind() === SyntaxKind.GreaterThanToken)) {
|
||||
if (parent && (element.kind() === SyntaxKind.LessThanToken || element.kind() === SyntaxKind.GreaterThanToken)) {
|
||||
switch (parent.kind()) {
|
||||
case SyntaxKind.TypeArgumentList:
|
||||
case SyntaxKind.TypeParameterList:
|
||||
@@ -272,15 +272,15 @@ module TypeScript {
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
public static containsToken(list: ISyntaxToken[], kind: SyntaxKind): boolean {
|
||||
return SyntaxUtilities.getToken(list, kind) !== null;
|
||||
return !!SyntaxUtilities.getToken(list, kind);
|
||||
}
|
||||
|
||||
public static hasExportKeyword(moduleElement: IModuleElementSyntax): boolean {
|
||||
return SyntaxUtilities.getExportKeyword(moduleElement) !== null;
|
||||
return !!SyntaxUtilities.getExportKeyword(moduleElement);
|
||||
}
|
||||
|
||||
public static getExportKeyword(moduleElement: IModuleElementSyntax): ISyntaxToken {
|
||||
@@ -294,7 +294,7 @@ module TypeScript {
|
||||
case SyntaxKind.ImportDeclaration:
|
||||
return SyntaxUtilities.getToken((<any>moduleElement).modifiers, SyntaxKind.ExportKeyword);
|
||||
default:
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
module TypeScript {
|
||||
export function visitNodeOrToken(visitor: ISyntaxVisitor, element: ISyntaxNodeOrToken): any {
|
||||
if (element === null) { return null; }
|
||||
if (element === undefined) { return undefined; }
|
||||
if (isToken(element)) { return visitor.visitToken(<ISyntaxToken>element); }
|
||||
switch (element.kind()) {
|
||||
case SyntaxKind.SourceUnit: return visitor.visitSourceUnit(<SourceUnitSyntax>element);
|
||||
@@ -14,6 +14,8 @@ module TypeScript {
|
||||
case SyntaxKind.GenericType: return visitor.visitGenericType(<GenericTypeSyntax>element);
|
||||
case SyntaxKind.TypeQuery: return visitor.visitTypeQuery(<TypeQuerySyntax>element);
|
||||
case SyntaxKind.TupleType: return visitor.visitTupleType(<TupleTypeSyntax>element);
|
||||
case SyntaxKind.UnionType: return visitor.visitUnionType(<UnionTypeSyntax>element);
|
||||
case SyntaxKind.ParenthesizedType: return visitor.visitParenthesizedType(<ParenthesizedTypeSyntax>element);
|
||||
case SyntaxKind.InterfaceDeclaration: return visitor.visitInterfaceDeclaration(<InterfaceDeclarationSyntax>element);
|
||||
case SyntaxKind.FunctionDeclaration: return visitor.visitFunctionDeclaration(<FunctionDeclarationSyntax>element);
|
||||
case SyntaxKind.ModuleDeclaration: return visitor.visitModuleDeclaration(<ModuleDeclarationSyntax>element);
|
||||
@@ -111,6 +113,8 @@ module TypeScript {
|
||||
visitGenericType(node: GenericTypeSyntax): any;
|
||||
visitTypeQuery(node: TypeQuerySyntax): any;
|
||||
visitTupleType(node: TupleTypeSyntax): any;
|
||||
visitUnionType(node: UnionTypeSyntax): any;
|
||||
visitParenthesizedType(node: ParenthesizedTypeSyntax): any;
|
||||
visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): any;
|
||||
visitFunctionDeclaration(node: FunctionDeclarationSyntax): any;
|
||||
visitModuleDeclaration(node: ModuleDeclarationSyntax): any;
|
||||
|
||||
@@ -5,53 +5,24 @@ module TypeScript {
|
||||
public visitToken(token: ISyntaxToken): void {
|
||||
}
|
||||
|
||||
public visitNode(node: ISyntaxNode): void {
|
||||
visitNodeOrToken(this, node);
|
||||
}
|
||||
|
||||
public visitNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {
|
||||
if (isToken(nodeOrToken)) {
|
||||
this.visitToken(<ISyntaxToken>nodeOrToken);
|
||||
}
|
||||
else {
|
||||
this.visitNode(<ISyntaxNode>nodeOrToken);
|
||||
}
|
||||
}
|
||||
|
||||
private visitOptionalToken(token: ISyntaxToken): void {
|
||||
if (token === null) {
|
||||
if (token === undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.visitToken(token);
|
||||
}
|
||||
|
||||
public visitOptionalNode(node: ISyntaxNode): void {
|
||||
if (node === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.visitNode(node);
|
||||
}
|
||||
|
||||
public visitOptionalNodeOrToken(nodeOrToken: ISyntaxNodeOrToken): void {
|
||||
if (nodeOrToken === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
this.visitNodeOrToken(nodeOrToken);
|
||||
}
|
||||
|
||||
public visitList(list: ISyntaxNodeOrToken[]): void {
|
||||
for (var i = 0, n = list.length; i < n; i++) {
|
||||
this.visitNodeOrToken(list[i]);
|
||||
visitNodeOrToken(this, list[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public visitSeparatedList(list: ISyntaxNodeOrToken[]): void {
|
||||
for (var i = 0, n = childCount(list); i < n; i++) {
|
||||
var item = childAt(list, i);
|
||||
this.visitNodeOrToken(item);
|
||||
visitNodeOrToken(this, item);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -61,7 +32,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
public visitQualifiedName(node: QualifiedNameSyntax): void {
|
||||
this.visitNodeOrToken(node.left);
|
||||
visitNodeOrToken(this, node.left);
|
||||
this.visitToken(node.dotToken);
|
||||
this.visitToken(node.right);
|
||||
}
|
||||
@@ -73,34 +44,34 @@ module TypeScript {
|
||||
}
|
||||
|
||||
public visitFunctionType(node: FunctionTypeSyntax): void {
|
||||
this.visitOptionalNode(node.typeParameterList);
|
||||
this.visitNode(node.parameterList);
|
||||
visitNodeOrToken(this, node.typeParameterList);
|
||||
visitNodeOrToken(this, node.parameterList);
|
||||
this.visitToken(node.equalsGreaterThanToken);
|
||||
this.visitNodeOrToken(node.type);
|
||||
visitNodeOrToken(this, node.type);
|
||||
}
|
||||
|
||||
public visitArrayType(node: ArrayTypeSyntax): void {
|
||||
this.visitNodeOrToken(node.type);
|
||||
visitNodeOrToken(this, node.type);
|
||||
this.visitToken(node.openBracketToken);
|
||||
this.visitToken(node.closeBracketToken);
|
||||
}
|
||||
|
||||
public visitConstructorType(node: ConstructorTypeSyntax): void {
|
||||
this.visitToken(node.newKeyword);
|
||||
this.visitOptionalNode(node.typeParameterList);
|
||||
this.visitNode(node.parameterList);
|
||||
visitNodeOrToken(this, node.typeParameterList);
|
||||
visitNodeOrToken(this, node.parameterList);
|
||||
this.visitToken(node.equalsGreaterThanToken);
|
||||
this.visitNodeOrToken(node.type);
|
||||
visitNodeOrToken(this, node.type);
|
||||
}
|
||||
|
||||
public visitGenericType(node: GenericTypeSyntax): void {
|
||||
this.visitNodeOrToken(node.name);
|
||||
this.visitNode(node.typeArgumentList);
|
||||
visitNodeOrToken(this, node.name);
|
||||
visitNodeOrToken(this, node.typeArgumentList);
|
||||
}
|
||||
|
||||
public visitTypeQuery(node: TypeQuerySyntax): void {
|
||||
this.visitToken(node.typeOfKeyword);
|
||||
this.visitNodeOrToken(node.name);
|
||||
visitNodeOrToken(this, node.name);
|
||||
}
|
||||
|
||||
public visitTupleType(node: TupleTypeSyntax): void {
|
||||
@@ -109,28 +80,40 @@ module TypeScript {
|
||||
this.visitToken(node.closeBracketToken);
|
||||
}
|
||||
|
||||
public visitUnionType(node: UnionTypeSyntax): void {
|
||||
visitNodeOrToken(this, node.left);
|
||||
this.visitToken(node.barToken);
|
||||
visitNodeOrToken(this, node.right);
|
||||
}
|
||||
|
||||
public visitParenthesizedType(node: ParenthesizedTypeSyntax): void {
|
||||
this.visitToken(node.openParenToken);
|
||||
visitNodeOrToken(this, node.type);
|
||||
this.visitToken(node.closeParenToken);
|
||||
}
|
||||
|
||||
public visitInterfaceDeclaration(node: InterfaceDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.interfaceKeyword);
|
||||
this.visitToken(node.identifier);
|
||||
this.visitOptionalNode(node.typeParameterList);
|
||||
visitNodeOrToken(this, node.typeParameterList);
|
||||
this.visitList(node.heritageClauses);
|
||||
this.visitNode(node.body);
|
||||
visitNodeOrToken(this, node.body);
|
||||
}
|
||||
|
||||
public visitFunctionDeclaration(node: FunctionDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.functionKeyword);
|
||||
this.visitToken(node.identifier);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitOptionalNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitModuleDeclaration(node: ModuleDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.moduleKeyword);
|
||||
this.visitOptionalNodeOrToken(node.name);
|
||||
visitNodeOrToken(this, node.name);
|
||||
this.visitOptionalToken(node.stringLiteral);
|
||||
this.visitToken(node.openBraceToken);
|
||||
this.visitList(node.moduleElements);
|
||||
@@ -141,7 +124,7 @@ module TypeScript {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.classKeyword);
|
||||
this.visitToken(node.identifier);
|
||||
this.visitOptionalNode(node.typeParameterList);
|
||||
visitNodeOrToken(this, node.typeParameterList);
|
||||
this.visitList(node.heritageClauses);
|
||||
this.visitToken(node.openBraceToken);
|
||||
this.visitList(node.classElements);
|
||||
@@ -162,7 +145,7 @@ module TypeScript {
|
||||
this.visitToken(node.importKeyword);
|
||||
this.visitToken(node.identifier);
|
||||
this.visitToken(node.equalsToken);
|
||||
this.visitNodeOrToken(node.moduleReference);
|
||||
visitNodeOrToken(this, node.moduleReference);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
@@ -176,28 +159,28 @@ module TypeScript {
|
||||
public visitMemberFunctionDeclaration(node: MemberFunctionDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitOptionalNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitMemberVariableDeclaration(node: MemberVariableDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitNode(node.variableDeclarator);
|
||||
visitNodeOrToken(this, node.variableDeclarator);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitConstructorDeclaration(node: ConstructorDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.constructorKeyword);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitOptionalNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitIndexMemberDeclaration(node: IndexMemberDeclarationSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitNode(node.indexSignature);
|
||||
visitNodeOrToken(this, node.indexSignature);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
@@ -205,46 +188,46 @@ module TypeScript {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.getKeyword);
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
}
|
||||
|
||||
public visitSetAccessor(node: SetAccessorSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.setKeyword);
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
}
|
||||
|
||||
public visitPropertySignature(node: PropertySignatureSyntax): void {
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitOptionalToken(node.questionToken);
|
||||
this.visitOptionalNode(node.typeAnnotation);
|
||||
visitNodeOrToken(this, node.typeAnnotation);
|
||||
}
|
||||
|
||||
public visitCallSignature(node: CallSignatureSyntax): void {
|
||||
this.visitOptionalNode(node.typeParameterList);
|
||||
this.visitNode(node.parameterList);
|
||||
this.visitOptionalNode(node.typeAnnotation);
|
||||
visitNodeOrToken(this, node.typeParameterList);
|
||||
visitNodeOrToken(this, node.parameterList);
|
||||
visitNodeOrToken(this, node.typeAnnotation);
|
||||
}
|
||||
|
||||
public visitConstructSignature(node: ConstructSignatureSyntax): void {
|
||||
this.visitToken(node.newKeyword);
|
||||
this.visitNode(node.callSignature);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
}
|
||||
|
||||
public visitIndexSignature(node: IndexSignatureSyntax): void {
|
||||
this.visitToken(node.openBracketToken);
|
||||
this.visitSeparatedList(node.parameters);
|
||||
this.visitToken(node.closeBracketToken);
|
||||
this.visitOptionalNode(node.typeAnnotation);
|
||||
visitNodeOrToken(this, node.typeAnnotation);
|
||||
}
|
||||
|
||||
public visitMethodSignature(node: MethodSignatureSyntax): void {
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitOptionalToken(node.questionToken);
|
||||
this.visitNode(node.callSignature);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
}
|
||||
|
||||
public visitBlock(node: BlockSyntax): void {
|
||||
@@ -256,33 +239,33 @@ module TypeScript {
|
||||
public visitIfStatement(node: IfStatementSyntax): void {
|
||||
this.visitToken(node.ifKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.condition);
|
||||
visitNodeOrToken(this, node.condition);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
this.visitOptionalNode(node.elseClause);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
visitNodeOrToken(this, node.elseClause);
|
||||
}
|
||||
|
||||
public visitVariableStatement(node: VariableStatementSyntax): void {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitNode(node.variableDeclaration);
|
||||
visitNodeOrToken(this, node.variableDeclaration);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitExpressionStatement(node: ExpressionStatementSyntax): void {
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitReturnStatement(node: ReturnStatementSyntax): void {
|
||||
this.visitToken(node.returnKeyword);
|
||||
this.visitOptionalNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitSwitchStatement(node: SwitchStatementSyntax): void {
|
||||
this.visitToken(node.switchKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitToken(node.openBraceToken);
|
||||
this.visitList(node.switchClauses);
|
||||
@@ -304,25 +287,25 @@ module TypeScript {
|
||||
public visitForStatement(node: ForStatementSyntax): void {
|
||||
this.visitToken(node.forKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitOptionalNode(node.variableDeclaration);
|
||||
this.visitOptionalNodeOrToken(node.initializer);
|
||||
visitNodeOrToken(this, node.variableDeclaration);
|
||||
visitNodeOrToken(this, node.initializer);
|
||||
this.visitToken(node.firstSemicolonToken);
|
||||
this.visitOptionalNodeOrToken(node.condition);
|
||||
visitNodeOrToken(this, node.condition);
|
||||
this.visitToken(node.secondSemicolonToken);
|
||||
this.visitOptionalNodeOrToken(node.incrementor);
|
||||
visitNodeOrToken(this, node.incrementor);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
}
|
||||
|
||||
public visitForInStatement(node: ForInStatementSyntax): void {
|
||||
this.visitToken(node.forKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitOptionalNode(node.variableDeclaration);
|
||||
this.visitOptionalNodeOrToken(node.left);
|
||||
visitNodeOrToken(this, node.variableDeclaration);
|
||||
visitNodeOrToken(this, node.left);
|
||||
this.visitToken(node.inKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
}
|
||||
|
||||
public visitEmptyStatement(node: EmptyStatementSyntax): void {
|
||||
@@ -331,37 +314,37 @@ module TypeScript {
|
||||
|
||||
public visitThrowStatement(node: ThrowStatementSyntax): void {
|
||||
this.visitToken(node.throwKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
|
||||
public visitWhileStatement(node: WhileStatementSyntax): void {
|
||||
this.visitToken(node.whileKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.condition);
|
||||
visitNodeOrToken(this, node.condition);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
}
|
||||
|
||||
public visitTryStatement(node: TryStatementSyntax): void {
|
||||
this.visitToken(node.tryKeyword);
|
||||
this.visitNode(node.block);
|
||||
this.visitOptionalNode(node.catchClause);
|
||||
this.visitOptionalNode(node.finallyClause);
|
||||
visitNodeOrToken(this, node.block);
|
||||
visitNodeOrToken(this, node.catchClause);
|
||||
visitNodeOrToken(this, node.finallyClause);
|
||||
}
|
||||
|
||||
public visitLabeledStatement(node: LabeledStatementSyntax): void {
|
||||
this.visitToken(node.identifier);
|
||||
this.visitToken(node.colonToken);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
}
|
||||
|
||||
public visitDoStatement(node: DoStatementSyntax): void {
|
||||
this.visitToken(node.doKeyword);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
this.visitToken(node.whileKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.condition);
|
||||
visitNodeOrToken(this, node.condition);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitOptionalToken(node.semicolonToken);
|
||||
}
|
||||
@@ -374,59 +357,59 @@ module TypeScript {
|
||||
public visitWithStatement(node: WithStatementSyntax): void {
|
||||
this.visitToken(node.withKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.condition);
|
||||
visitNodeOrToken(this, node.condition);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
}
|
||||
|
||||
public visitPrefixUnaryExpression(node: PrefixUnaryExpressionSyntax): void {
|
||||
this.visitToken(node.operatorToken);
|
||||
this.visitNodeOrToken(node.operand);
|
||||
visitNodeOrToken(this, node.operand);
|
||||
}
|
||||
|
||||
public visitDeleteExpression(node: DeleteExpressionSyntax): void {
|
||||
this.visitToken(node.deleteKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitTypeOfExpression(node: TypeOfExpressionSyntax): void {
|
||||
this.visitToken(node.typeOfKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitVoidExpression(node: VoidExpressionSyntax): void {
|
||||
this.visitToken(node.voidKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitConditionalExpression(node: ConditionalExpressionSyntax): void {
|
||||
this.visitNodeOrToken(node.condition);
|
||||
visitNodeOrToken(this, node.condition);
|
||||
this.visitToken(node.questionToken);
|
||||
this.visitNodeOrToken(node.whenTrue);
|
||||
visitNodeOrToken(this, node.whenTrue);
|
||||
this.visitToken(node.colonToken);
|
||||
this.visitNodeOrToken(node.whenFalse);
|
||||
visitNodeOrToken(this, node.whenFalse);
|
||||
}
|
||||
|
||||
public visitBinaryExpression(node: BinaryExpressionSyntax): void {
|
||||
this.visitNodeOrToken(node.left);
|
||||
visitNodeOrToken(this, node.left);
|
||||
this.visitToken(node.operatorToken);
|
||||
this.visitNodeOrToken(node.right);
|
||||
visitNodeOrToken(this, node.right);
|
||||
}
|
||||
|
||||
public visitPostfixUnaryExpression(node: PostfixUnaryExpressionSyntax): void {
|
||||
this.visitNodeOrToken(node.operand);
|
||||
visitNodeOrToken(this, node.operand);
|
||||
this.visitToken(node.operatorToken);
|
||||
}
|
||||
|
||||
public visitMemberAccessExpression(node: MemberAccessExpressionSyntax): void {
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitToken(node.dotToken);
|
||||
this.visitToken(node.name);
|
||||
}
|
||||
|
||||
public visitInvocationExpression(node: InvocationExpressionSyntax): void {
|
||||
this.visitNodeOrToken(node.expression);
|
||||
this.visitNode(node.argumentList);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
visitNodeOrToken(this, node.argumentList);
|
||||
}
|
||||
|
||||
public visitArrayLiteralExpression(node: ArrayLiteralExpressionSyntax): void {
|
||||
@@ -443,49 +426,49 @@ module TypeScript {
|
||||
|
||||
public visitObjectCreationExpression(node: ObjectCreationExpressionSyntax): void {
|
||||
this.visitToken(node.newKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
this.visitOptionalNode(node.argumentList);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
visitNodeOrToken(this, node.argumentList);
|
||||
}
|
||||
|
||||
public visitParenthesizedExpression(node: ParenthesizedExpressionSyntax): void {
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitToken(node.closeParenToken);
|
||||
}
|
||||
|
||||
public visitParenthesizedArrowFunctionExpression(node: ParenthesizedArrowFunctionExpressionSyntax): void {
|
||||
this.visitNode(node.callSignature);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
this.visitToken(node.equalsGreaterThanToken);
|
||||
this.visitOptionalNode(node.block);
|
||||
this.visitOptionalNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.block);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitSimpleArrowFunctionExpression(node: SimpleArrowFunctionExpressionSyntax): void {
|
||||
this.visitNode(node.parameter);
|
||||
visitNodeOrToken(this, node.parameter);
|
||||
this.visitToken(node.equalsGreaterThanToken);
|
||||
this.visitOptionalNode(node.block);
|
||||
this.visitOptionalNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.block);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitCastExpression(node: CastExpressionSyntax): void {
|
||||
this.visitToken(node.lessThanToken);
|
||||
this.visitNodeOrToken(node.type);
|
||||
visitNodeOrToken(this, node.type);
|
||||
this.visitToken(node.greaterThanToken);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitElementAccessExpression(node: ElementAccessExpressionSyntax): void {
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitToken(node.openBracketToken);
|
||||
this.visitNodeOrToken(node.argumentExpression);
|
||||
visitNodeOrToken(this, node.argumentExpression);
|
||||
this.visitToken(node.closeBracketToken);
|
||||
}
|
||||
|
||||
public visitFunctionExpression(node: FunctionExpressionSyntax): void {
|
||||
this.visitToken(node.functionKeyword);
|
||||
this.visitOptionalToken(node.identifier);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
}
|
||||
|
||||
public visitOmittedExpression(node: OmittedExpressionSyntax): void {
|
||||
@@ -498,12 +481,12 @@ module TypeScript {
|
||||
|
||||
public visitVariableDeclarator(node: VariableDeclaratorSyntax): void {
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitOptionalNode(node.typeAnnotation);
|
||||
this.visitOptionalNode(node.equalsValueClause);
|
||||
visitNodeOrToken(this, node.typeAnnotation);
|
||||
visitNodeOrToken(this, node.equalsValueClause);
|
||||
}
|
||||
|
||||
public visitArgumentList(node: ArgumentListSyntax): void {
|
||||
this.visitOptionalNode(node.typeArgumentList);
|
||||
visitNodeOrToken(this, node.typeArgumentList);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitSeparatedList(node.arguments);
|
||||
this.visitToken(node.closeParenToken);
|
||||
@@ -534,12 +517,12 @@ module TypeScript {
|
||||
|
||||
public visitEqualsValueClause(node: EqualsValueClauseSyntax): void {
|
||||
this.visitToken(node.equalsToken);
|
||||
this.visitNodeOrToken(node.value);
|
||||
visitNodeOrToken(this, node.value);
|
||||
}
|
||||
|
||||
public visitCaseSwitchClause(node: CaseSwitchClauseSyntax): void {
|
||||
this.visitToken(node.caseKeyword);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
this.visitToken(node.colonToken);
|
||||
this.visitList(node.statements);
|
||||
}
|
||||
@@ -552,43 +535,43 @@ module TypeScript {
|
||||
|
||||
public visitElseClause(node: ElseClauseSyntax): void {
|
||||
this.visitToken(node.elseKeyword);
|
||||
this.visitNodeOrToken(node.statement);
|
||||
visitNodeOrToken(this, node.statement);
|
||||
}
|
||||
|
||||
public visitCatchClause(node: CatchClauseSyntax): void {
|
||||
this.visitToken(node.catchKeyword);
|
||||
this.visitToken(node.openParenToken);
|
||||
this.visitToken(node.identifier);
|
||||
this.visitOptionalNode(node.typeAnnotation);
|
||||
visitNodeOrToken(this, node.typeAnnotation);
|
||||
this.visitToken(node.closeParenToken);
|
||||
this.visitNode(node.block);
|
||||
visitNodeOrToken(this, node.block);
|
||||
}
|
||||
|
||||
public visitFinallyClause(node: FinallyClauseSyntax): void {
|
||||
this.visitToken(node.finallyKeyword);
|
||||
this.visitNode(node.block);
|
||||
visitNodeOrToken(this, node.block);
|
||||
}
|
||||
|
||||
public visitTypeParameter(node: TypeParameterSyntax): void {
|
||||
this.visitToken(node.identifier);
|
||||
this.visitOptionalNode(node.constraint);
|
||||
visitNodeOrToken(this, node.constraint);
|
||||
}
|
||||
|
||||
public visitConstraint(node: ConstraintSyntax): void {
|
||||
this.visitToken(node.extendsKeyword);
|
||||
this.visitNodeOrToken(node.typeOrExpression);
|
||||
visitNodeOrToken(this, node.typeOrExpression);
|
||||
}
|
||||
|
||||
public visitSimplePropertyAssignment(node: SimplePropertyAssignmentSyntax): void {
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitToken(node.colonToken);
|
||||
this.visitNodeOrToken(node.expression);
|
||||
visitNodeOrToken(this, node.expression);
|
||||
}
|
||||
|
||||
public visitFunctionPropertyAssignment(node: FunctionPropertyAssignmentSyntax): void {
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitNode(node.callSignature);
|
||||
this.visitNode(node.block);
|
||||
visitNodeOrToken(this, node.callSignature);
|
||||
visitNodeOrToken(this, node.block);
|
||||
}
|
||||
|
||||
public visitParameter(node: ParameterSyntax): void {
|
||||
@@ -596,18 +579,18 @@ module TypeScript {
|
||||
this.visitList(node.modifiers);
|
||||
this.visitToken(node.identifier);
|
||||
this.visitOptionalToken(node.questionToken);
|
||||
this.visitOptionalNode(node.typeAnnotation);
|
||||
this.visitOptionalNode(node.equalsValueClause);
|
||||
visitNodeOrToken(this, node.typeAnnotation);
|
||||
visitNodeOrToken(this, node.equalsValueClause);
|
||||
}
|
||||
|
||||
public visitEnumElement(node: EnumElementSyntax): void {
|
||||
this.visitToken(node.propertyName);
|
||||
this.visitOptionalNode(node.equalsValueClause);
|
||||
visitNodeOrToken(this, node.equalsValueClause);
|
||||
}
|
||||
|
||||
public visitTypeAnnotation(node: TypeAnnotationSyntax): void {
|
||||
this.visitToken(node.colonToken);
|
||||
this.visitNodeOrToken(node.type);
|
||||
visitNodeOrToken(this, node.type);
|
||||
}
|
||||
|
||||
public visitExternalModuleReference(node: ExternalModuleReferenceSyntax): void {
|
||||
@@ -618,7 +601,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
public visitModuleNameModuleReference(node: ModuleNameModuleReferenceSyntax): void {
|
||||
this.visitNodeOrToken(node.moduleName);
|
||||
visitNodeOrToken(this, node.moduleName);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,7 @@ module TypeScript {
|
||||
|
||||
export function nodeStructuralEquals(node1: TypeScript.ISyntaxNode, node2: TypeScript.ISyntaxNode, checkParents: boolean, text1: ISimpleText, text2: ISimpleText): boolean {
|
||||
if (node1 === node2) { return true; }
|
||||
if (node1 === null || node2 === null) { return false; }
|
||||
if (!node1 || !node2) { return false; }
|
||||
|
||||
Debug.assert(node1.kind() === TypeScript.SyntaxKind.SourceUnit || node1.parent);
|
||||
Debug.assert(node2.kind() === TypeScript.SyntaxKind.SourceUnit || node2.parent);
|
||||
@@ -37,7 +37,7 @@ module TypeScript {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (node1 === null || node2 === null) {
|
||||
if (!node1 || !node2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -56,7 +56,7 @@ module TypeScript {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (token1 === null || token2 === null) {
|
||||
if (!token1 || !token2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -156,7 +156,7 @@ module TypeScript {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (element1 === null || element2 === null) {
|
||||
if (!element1 || !element2) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@@ -32,7 +32,7 @@ module TypeScript {
|
||||
|
||||
export module ScriptSnapshot {
|
||||
class StringScriptSnapshot implements IScriptSnapshot {
|
||||
private _lineStartPositions: number[] = null;
|
||||
private _lineStartPositions: number[] = undefined;
|
||||
|
||||
constructor(private text: string) {
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
module TypeScript.SimpleText {
|
||||
class SimpleStringText implements ISimpleText {
|
||||
private _lineMap: LineMap = null;
|
||||
private _lineMap: LineMap = undefined;
|
||||
|
||||
constructor(private value: string) {
|
||||
}
|
||||
@@ -30,7 +30,7 @@ module TypeScript.SimpleText {
|
||||
|
||||
// Class which wraps a host IScriptSnapshot and exposes an ISimpleText for newer compiler code.
|
||||
class SimpleScriptSnapshotText implements ISimpleText {
|
||||
private _lineMap: LineMap = null;
|
||||
private _lineMap: LineMap = undefined;
|
||||
|
||||
constructor(public scriptSnapshot: IScriptSnapshot) {
|
||||
}
|
||||
@@ -48,7 +48,7 @@ module TypeScript.SimpleText {
|
||||
}
|
||||
|
||||
public lineMap(): LineMap {
|
||||
if (this._lineMap === null) {
|
||||
if (!this._lineMap) {
|
||||
this._lineMap = new LineMap(() => this.scriptSnapshot.getLineStartPositions(), this.length());
|
||||
}
|
||||
|
||||
|
||||
@@ -79,7 +79,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the overlap with the given span, or null if there is no overlap.
|
||||
* Returns the overlap with the given span, or undefined if there is no overlap.
|
||||
* @param span The span to check.
|
||||
*/
|
||||
public overlap(span: TextSpan): TextSpan {
|
||||
@@ -90,7 +90,7 @@ module TypeScript {
|
||||
return TextSpan.fromBounds(overlapStart, overlapEnd);
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -119,7 +119,7 @@ module TypeScript {
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the intersection with the given span, or null if there is no intersection.
|
||||
* Returns the intersection with the given span, or undefined if there is no intersection.
|
||||
* @param span The span to check.
|
||||
*/
|
||||
public intersection(span: TextSpan): TextSpan {
|
||||
@@ -130,7 +130,7 @@ module TypeScript {
|
||||
return TextSpan.fromBounds(intersectStart, intersectEnd);
|
||||
}
|
||||
|
||||
return null;
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Reference in new issue
Block a user