@@ -16,6 +16,8 @@ module ts {
16
16
var emptySymbols: SymbolTable = {};
17
17
18
18
var compilerOptions = host.getCompilerOptions();
19
+ var languageVersion = compilerOptions.target || ScriptTarget.ES3;
20
+
19
21
var emitResolver = createResolver();
20
22
21
23
var checker: TypeChecker = {
@@ -5618,7 +5620,7 @@ module ts {
5618
5620
}
5619
5621
5620
5622
var isConstEnum = isConstEnumObjectType(objectType);
5621
- if (isConstEnum &&
5623
+ if (isConstEnum &&
5622
5624
(!node.argumentExpression || node.argumentExpression.kind !== SyntaxKind.StringLiteral)) {
5623
5625
error(node.argumentExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
5624
5626
return unknownType;
@@ -5650,10 +5652,10 @@ module ts {
5650
5652
}
5651
5653
5652
5654
// Check for compatible indexer types.
5653
- if (indexType.flags & ( TypeFlags.Any | TypeFlags.StringLike | TypeFlags.NumberLike)) {
5655
+ if (isTypeOfKind( indexType, TypeFlags.Any | TypeFlags.StringLike | TypeFlags.NumberLike)) {
5654
5656
5655
5657
// Try to use a number indexer.
5656
- if (indexType.flags & ( TypeFlags.Any | TypeFlags.NumberLike)) {
5658
+ if (isTypeOfKind( indexType, TypeFlags.Any | TypeFlags.NumberLike)) {
5657
5659
var numberIndexType = getIndexTypeOfType(objectType, IndexKind.Number);
5658
5660
if (numberIndexType) {
5659
5661
return numberIndexType;
@@ -6357,7 +6359,7 @@ module ts {
6357
6359
6358
6360
function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
6359
6361
// Grammar checking
6360
- if (compilerOptions.target < ScriptTarget.ES6) {
6362
+ if (languageVersion < ScriptTarget.ES6) {
6361
6363
grammarErrorOnFirstToken(node.template, Diagnostics.Tagged_templates_are_only_available_when_targeting_ECMAScript_6_and_higher);
6362
6364
}
6363
6365
@@ -6554,7 +6556,7 @@ module ts {
6554
6556
}
6555
6557
6556
6558
function checkArithmeticOperandType(operand: Node, type: Type, diagnostic: DiagnosticMessage): boolean {
6557
- if (!(type.flags & ( TypeFlags.Any | TypeFlags.NumberLike) )) {
6559
+ if (!isTypeOfKind (type, TypeFlags.Any | TypeFlags.NumberLike)) {
6558
6560
error(operand, diagnostic);
6559
6561
return false;
6560
6562
}
@@ -6705,12 +6707,21 @@ module ts {
6705
6707
return numberType;
6706
6708
}
6707
6709
6708
- // Return true if type an object type, a type parameter, or a union type composed of only those kinds of types
6709
- function isStructuredType(type: Type): boolean {
6710
+ // Return true if type has the given flags, or is a union type composed of types that all have those flags
6711
+ function isTypeOfKind(type: Type, kind: TypeFlags): boolean {
6712
+ if (type.flags & kind) {
6713
+ return true;
6714
+ }
6710
6715
if (type.flags & TypeFlags.Union) {
6711
- return !forEach((<UnionType>type).types, t => !isStructuredType(t));
6716
+ var types = (<UnionType>type).types;
6717
+ for (var i = 0; i < types.length; i++) {
6718
+ if (!(types[i].flags & kind)) {
6719
+ return false;
6720
+ }
6721
+ }
6722
+ return true;
6712
6723
}
6713
- return (type.flags & (TypeFlags.ObjectType | TypeFlags.TypeParameter)) !== 0 ;
6724
+ return false ;
6714
6725
}
6715
6726
6716
6727
function isConstEnumObjectType(type: Type): boolean {
@@ -6727,7 +6738,7 @@ module ts {
6727
6738
// and the right operand to be of type Any or a subtype of the 'Function' interface type.
6728
6739
// The result is always of the Boolean primitive type.
6729
6740
// NOTE: do not raise error if leftType is unknown as related error was already reported
6730
- if (!(leftType.flags & TypeFlags.Any || isStructuredType(leftType) )) {
6741
+ if (!isTypeOfKind (leftType, TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.TypeParameter )) {
6731
6742
error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
6732
6743
}
6733
6744
// NOTE: do not raise error if right is unknown as related error was already reported
@@ -6742,10 +6753,10 @@ module ts {
6742
6753
// The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
6743
6754
// and the right operand to be of type Any, an object type, or a type parameter type.
6744
6755
// The result is always of the Boolean primitive type.
6745
- if (leftType !== anyType && leftType !== stringType && leftType !== numberType ) {
6756
+ if (!isTypeOfKind( leftType, TypeFlags.Any | TypeFlags.StringLike | TypeFlags.NumberLike) ) {
6746
6757
error(node.left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number);
6747
6758
}
6748
- if (!(rightType.flags & TypeFlags.Any || isStructuredType(rightType) )) {
6759
+ if (!isTypeOfKind (rightType, TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.TypeParameter )) {
6749
6760
error(node.right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
6750
6761
}
6751
6762
return booleanType;
@@ -6906,16 +6917,16 @@ module ts {
6906
6917
if (rightType.flags & (TypeFlags.Undefined | TypeFlags.Null)) rightType = leftType;
6907
6918
6908
6919
var resultType: Type;
6909
- if (leftType.flags & TypeFlags.NumberLike && rightType.flags & TypeFlags.NumberLike) {
6920
+ if (isTypeOfKind( leftType, TypeFlags.NumberLike) && isTypeOfKind( rightType, TypeFlags.NumberLike) ) {
6910
6921
// Operands of an enum type are treated as having the primitive type Number.
6911
6922
// If both operands are of the Number primitive type, the result is of the Number primitive type.
6912
6923
resultType = numberType;
6913
6924
}
6914
- else if (leftType.flags & TypeFlags.StringLike || rightType.flags & TypeFlags.StringLike) {
6925
+ else if (isTypeOfKind( leftType, TypeFlags.StringLike) || isTypeOfKind( rightType, TypeFlags.StringLike) ) {
6915
6926
// If one or both operands are of the String primitive type, the result is of the String primitive type.
6916
6927
resultType = stringType;
6917
6928
}
6918
- else if (leftType.flags & TypeFlags.Any || leftType === unknownType || rightType.flags & TypeFlags.Any || rightType === unknownType ) {
6929
+ else if (leftType.flags & TypeFlags.Any || rightType.flags & TypeFlags.Any) {
6919
6930
// Otherwise, the result is of type Any.
6920
6931
// NOTE: unknown type here denotes error type. Old compiler treated this case as any type so do we.
6921
6932
resultType = anyType;
@@ -8271,7 +8282,7 @@ module ts {
8271
8282
var exprType = checkExpression(node.expression);
8272
8283
// unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved
8273
8284
// in this case error about missing name is already reported - do not report extra one
8274
- if (!(exprType.flags & TypeFlags.Any || isStructuredType(exprType) )) {
8285
+ if (!isTypeOfKind (exprType, TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.TypeParameter )) {
8275
8286
error(node.expression, Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter);
8276
8287
}
8277
8288
@@ -10055,7 +10066,7 @@ module ts {
10055
10066
globalRegExpType = getGlobalType("RegExp");
10056
10067
// If we're in ES6 mode, load the TemplateStringsArray.
10057
10068
// Otherwise, default to 'unknown' for the purposes of type checking in LS scenarios.
10058
- globalTemplateStringsArrayType = compilerOptions.target >= ScriptTarget.ES6
10069
+ globalTemplateStringsArrayType = languageVersion >= ScriptTarget.ES6
10059
10070
? getGlobalType("TemplateStringsArray")
10060
10071
: unknownType;
10061
10072
anyArrayType = createArrayType(anyType);
@@ -10427,7 +10438,7 @@ module ts {
10427
10438
return;
10428
10439
10429
10440
var computedPropertyName = <ComputedPropertyName>node;
10430
- if (compilerOptions.target < ScriptTarget.ES6) {
10441
+ if (languageVersion < ScriptTarget.ES6) {
10431
10442
grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher);
10432
10443
}
10433
10444
else if (computedPropertyName.expression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>computedPropertyName.expression).operator === SyntaxKind.CommaToken) {
@@ -10527,7 +10538,7 @@ module ts {
10527
10538
10528
10539
function checkGrammarAccessor(accessor: MethodDeclaration): boolean {
10529
10540
var kind = accessor.kind;
10530
- if (compilerOptions.target < ScriptTarget.ES5) {
10541
+ if (languageVersion < ScriptTarget.ES5) {
10531
10542
return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
10532
10543
}
10533
10544
else if (isInAmbientContext(accessor)) {
@@ -10732,7 +10743,7 @@ module ts {
10732
10743
return grammarErrorAtPos(getSourceFileOfNode(declarationList), declarations.pos, declarations.end - declarations.pos, Diagnostics.Variable_declaration_list_cannot_be_empty);
10733
10744
}
10734
10745
10735
- if (compilerOptions.target < ScriptTarget.ES6) {
10746
+ if (languageVersion < ScriptTarget.ES6) {
10736
10747
if (isLet(declarationList)) {
10737
10748
return grammarErrorOnFirstToken(declarationList, Diagnostics.let_declarations_are_only_available_when_targeting_ECMAScript_6_and_higher);
10738
10749
}
@@ -10834,7 +10845,7 @@ module ts {
10834
10845
function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
10835
10846
var sourceFile = getSourceFileOfNode(node);
10836
10847
if (!hasParseDiagnostics(sourceFile)) {
10837
- var scanner = createScanner(compilerOptions.target , /*skipTrivia*/ true, sourceFile.text);
10848
+ var scanner = createScanner(languageVersion , /*skipTrivia*/ true, sourceFile.text);
10838
10849
var start = scanToken(scanner, node.pos);
10839
10850
diagnostics.push(createFileDiagnostic(sourceFile, start, scanner.getTextPos() - start, message, arg0, arg1, arg2));
10840
10851
return true;
@@ -10976,7 +10987,7 @@ module ts {
10976
10987
if (node.parserContextFlags & ParserContextFlags.StrictMode) {
10977
10988
return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode);
10978
10989
}
10979
- else if (compilerOptions.target >= ScriptTarget.ES5) {
10990
+ else if (languageVersion >= ScriptTarget.ES5) {
10980
10991
return grammarErrorOnNode(node, Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
10981
10992
}
10982
10993
}
@@ -10985,7 +10996,7 @@ module ts {
10985
10996
function grammarErrorAfterFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
10986
10997
var sourceFile = getSourceFileOfNode(node);
10987
10998
if (!hasParseDiagnostics(sourceFile)) {
10988
- var scanner = createScanner(compilerOptions.target , /*skipTrivia*/ true, sourceFile.text);
10999
+ var scanner = createScanner(languageVersion , /*skipTrivia*/ true, sourceFile.text);
10989
11000
scanToken(scanner, node.pos);
10990
11001
diagnostics.push(createFileDiagnostic(sourceFile, scanner.getTextPos(), 0, message, arg0, arg1, arg2));
10991
11002
return true;
0 commit comments