Switch to assignability check and fix compiler bugs found by check

ahejlsberg · ahejlsberg · commit 11aecee9a6e7 · 2015-07-10T19:16:53.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1966,15 +1966,12 @@ namespace ts {
             }
 
             return _displayBuilder || (_displayBuilder = {
-                symbolToString: symbolToString,
-                typeToString: typeToString,
                 buildSymbolDisplay: buildSymbolDisplay,
                 buildTypeDisplay: buildTypeDisplay,
                 buildTypeParameterDisplay: buildTypeParameterDisplay,
                 buildParameterDisplay: buildParameterDisplay,
                 buildDisplayForParametersAndDelimiters: buildDisplayForParametersAndDelimiters,
                 buildDisplayForTypeParametersAndDelimiters: buildDisplayForTypeParametersAndDelimiters,
-                buildDisplayForTypeArgumentsAndDelimiters: buildDisplayForTypeArgumentsAndDelimiters,
                 buildTypeParameterDisplayFromSymbol: buildTypeParameterDisplayFromSymbol,
                 buildSignatureDisplay: buildSignatureDisplay,
                 buildReturnTypeDisplay: buildReturnTypeDisplay
@@ -4480,6 +4477,16 @@ namespace ts {
                 errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
             }
 
+            function reportRelationError(message: DiagnosticMessage, source: Type, target: Type) {
+                let sourceType = typeToString(source);
+                let targetType = typeToString(target);
+                if (sourceType === targetType) {
+                    sourceType = typeToString(source, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
+                    targetType = typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
+                }
+                reportError(message || Diagnostics.Type_0_is_not_assignable_to_type_1, sourceType, targetType);
+            }
+
             // Compare two types and return
             // Ternary.True if they are related with no assumptions,
             // Ternary.Maybe if they are related with assumptions of other relationships, or
@@ -4499,7 +4506,19 @@ namespace ts {
                         if (source === numberType && target.flags & TypeFlags.Enum) return Ternary.True;
                     }
                 }
+
+                if (relation === assignableRelation && source.flags & TypeFlags.ObjectLiteral && source.flags & TypeFlags.FreshObjectLiteral) {
+                    if (hasExcessProperties(<ObjectType>source, target, reportErrors)) {
+                        if (reportErrors) {
+                            reportRelationError(headMessage, source, target);
+                        }
+                        return Ternary.False;
+                    }
+                    source = getRegularTypeOfObjectLiteral(source);
+                }
+
                 let saveErrorInfo = errorInfo;
+
                 if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (<TypeReference>source).target === (<TypeReference>target).target) {
                     // We have type references to same target type, see if relationship holds for all type arguments
                     if (result = typesRelatedTo((<TypeReference>source).typeArguments, (<TypeReference>target).typeArguments, reportErrors)) {
@@ -4576,18 +4595,28 @@ namespace ts {
                 }
 
                 if (reportErrors) {
-                    headMessage = headMessage || Diagnostics.Type_0_is_not_assignable_to_type_1;
-                    let sourceType = typeToString(source);
-                    let targetType = typeToString(target);
-                    if (sourceType === targetType) {
-                        sourceType = typeToString(source, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
-                        targetType = typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
-                    }
-                    reportError(headMessage, sourceType, targetType);
+                    reportRelationError(headMessage, source, target);
                 }
                 return Ternary.False;
             }
 
+            function hasExcessProperties(source: ObjectType, target: Type, reportErrors: boolean): boolean {
+                if (target.flags & TypeFlags.ObjectType) {
+                    var resolved = resolveStructuredTypeMembers(target);
+                    if (resolved.properties.length > 0 && !resolved.stringIndexType && !resolved.numberIndexType) {
+                        for (let prop of getPropertiesOfObjectType(source)) {
+                            if (!getPropertyOfType(target, prop.name)) {
+                                if (reportErrors) {
+                                    reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(prop), typeToString(target));
+                                }
+                                return true;
+                            }
+                        }
+                    }
+                }
+                return false;
+            }
+
             function eachTypeRelatedToSomeType(source: UnionOrIntersectionType, target: UnionOrIntersectionType): Ternary {
                 let result = Ternary.True;
                 let sourceTypes = source.types;
@@ -5255,6 +5284,24 @@ namespace ts {
             return (type.flags & TypeFlags.Tuple) && !!(<TupleType>type).elementTypes;
         }
 
+        function getRegularTypeOfObjectLiteral(type: Type): Type {
+            if (type.flags & TypeFlags.FreshObjectLiteral) {
+                let regularType = (<FreshObjectLiteralType>type).regularType;
+                if (!regularType) {
+                    regularType = <ResolvedType>createType((<ResolvedType>type).flags & ~TypeFlags.FreshObjectLiteral);
+                    regularType.symbol = (<ResolvedType>type).symbol;
+                    regularType.members = (<ResolvedType>type).members;
+                    regularType.properties = (<ResolvedType>type).properties;
+                    regularType.callSignatures = (<ResolvedType>type).callSignatures;
+                    regularType.constructSignatures = (<ResolvedType>type).constructSignatures;
+                    regularType.stringIndexType = (<ResolvedType>type).stringIndexType;
+                    regularType.numberIndexType = (<ResolvedType>type).numberIndexType;
+                }
+                return regularType;
+            }
+            return type;
+        }
+
         function getWidenedTypeOfObjectLiteral(type: Type): Type {
             let properties = getPropertiesOfObjectType(type);
             let members: SymbolTable = {};
@@ -6830,18 +6877,6 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function isPermittedProperty(contextualType: Type, propName: string): boolean {
-            if (contextualType.flags & TypeFlags.ObjectType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>contextualType);
-                return !!(resolved.properties.length === 0 || resolved.stringIndexType ||
-                    resolved.numberIndexType || getPropertyOfObjectType(contextualType, propName));
-            }
-            if (contextualType.flags & TypeFlags.UnionOrIntersection) {
-                return !forEach((<UnionOrIntersectionType>contextualType).types, type => !isPermittedProperty(type, propName));
-            }
-            return true;
-        }
-
         function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type {
             // Grammar checking
             checkGrammarObjectLiteralExpression(node);
@@ -6891,17 +6926,14 @@ namespace ts {
 
                 if (!hasDynamicName(memberDecl)) {
                     propertiesTable[member.name] = member;
-                    if (contextualType && !isPermittedProperty(contextualType, member.name)) {
-                        error(memberDecl.name, Diagnostics.Property_0_does_not_exist_in_contextual_type_1, member.name, typeToString(contextualType));
-                    }
                 }
                 propertiesArray.push(member);
             }
 
             let stringIndexType = getIndexType(IndexKind.String);
             let numberIndexType = getIndexType(IndexKind.Number);
             let result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
-            result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
+            result.flags |= TypeFlags.ObjectLiteral | TypeFlags.FreshObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
             return result;
 
             function getIndexType(kind: IndexKind) {
@@ -8782,7 +8814,7 @@ namespace ts {
         }
 
         function checkAssertion(node: AssertionExpression) {
-            let exprType = checkExpression(node.expression);
+            let exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
             let targetType = getTypeFromTypeNode(node.type);
             if (produceDiagnostics && targetType !== unknownType) {
                 let widenedType = getWidenedType(exprType);
@@ -9559,7 +9591,7 @@ namespace ts {
                     return getUnionType([leftType, rightType]);
                 case SyntaxKind.EqualsToken:
                     checkAssignmentOperator(rightType);
-                    return rightType;
+                    return getRegularTypeOfObjectLiteral(rightType);
                 case SyntaxKind.CommaToken:
                     return rightType;
             }
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
@@ -414,7 +414,6 @@ namespace ts {
         The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression." },
         yield_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2523, category: DiagnosticCategory.Error, key: "'yield' expressions cannot be used in a parameter initializer." },
         await_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2524, category: DiagnosticCategory.Error, key: "'await' expressions cannot be used in a parameter initializer." },
-        Property_0_does_not_exist_in_contextual_type_1: { code: 2525, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist in contextual type '{1}'." },
         JSX_element_attributes_type_0_must_be_an_object_type: { code: 2600, category: DiagnosticCategory.Error, key: "JSX element attributes type '{0}' must be an object type." },
         The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: DiagnosticCategory.Error, key: "The return type of a JSX element constructor must return an object type." },
         JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: { code: 2602, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -1645,10 +1645,6 @@
         "category": "Error",
         "code": 2524
     },
-    "Property '{0}' does not exist in contextual type '{1}'.": {
-        "category": "Error",
-        "code": 2525
-    },
     "JSX element attributes type '{0}' must be an object type.": {
         "category": "Error",
         "code": 2600
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -1743,10 +1743,12 @@ namespace ts {
         FromSignature           = 0x00040000,  // Created for signature assignment check
         ObjectLiteral           = 0x00080000,  // Originates in an object literal
         /* @internal */
-        ContainsUndefinedOrNull = 0x00100000,  // Type is or contains Undefined or Null type
+        FreshObjectLiteral      = 0x00100000,  // Fresh object literal type
         /* @internal */
-        ContainsObjectLiteral   = 0x00200000,  // Type is or contains object literal type
-        ESSymbol                = 0x00400000,  // Type of symbol primitive introduced in ES6
+        ContainsUndefinedOrNull = 0x00200000,  // Type is or contains Undefined or Null type
+        /* @internal */
+        ContainsObjectLiteral   = 0x00400000,  // Type is or contains object literal type
+        ESSymbol                = 0x00800000,  // Type of symbol primitive introduced in ES6
 
         /* @internal */ 
         Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null,
@@ -1839,6 +1841,11 @@ namespace ts {
         numberIndexType?: Type;            // Numeric index type
     }
 
+    /* @internal */
+    export interface FreshObjectLiteralType extends ResolvedType {
+        regularType: ResolvedType;  // Regular version of fresh type
+    }
+
     // Just a place to cache element types of iterables and iterators
     /* @internal */
     export interface IterableOrIteratorType extends ObjectType, UnionType {
@@ -2189,6 +2196,7 @@ namespace ts {
 
     export interface CompilerHost {
         getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
+        getCancellationToken?(): CancellationToken;
         getDefaultLibFileName(options: CompilerOptions): string;
         writeFile: WriteFileCallback;
         getCurrentDirectory(): string;
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -26,9 +26,8 @@ module FourSlash {
     export interface FourSlashFile {
         // The contents of the file (with markers, etc stripped out)
         content: string;
-
         fileName: string;
-
+        version: number;
         // File-specific options (name/value pairs)
         fileOptions: { [index: string]: string; };
     }
diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts
@@ -12,6 +12,7 @@ interface FindFileResult {
 }
 
 interface IOLog {
+    timestamp: string;
     arguments: string[];
     executingPath: string;
     currentDirectory: string;
diff --git a/src/server/client.ts b/src/server/client.ts
@@ -202,9 +202,7 @@ namespace ts.server {
             return  {
                 isMemberCompletion: false,
                 isNewIdentifierLocation: false,
-                entries: response.body,
-                fileName: fileName,
-                position: position
+                entries: response.body
             };
         }
      
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -1102,6 +1102,7 @@ namespace ts {
     }
 
     export interface HighlightSpan {
+        fileName?: string;
         textSpan: TextSpan;
         kind: string;
     }
@@ -1408,7 +1409,9 @@ namespace ts {
           * @param fileName The name of the file to be released
           * @param compilationSettings The compilation settings used to acquire the file
           */
-        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void
+        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
+
+        reportStats(): string;
     }
 
     // TODO: move these to enums
diff --git a/src/services/shims.ts b/src/services/shims.ts
@@ -428,11 +428,11 @@ namespace ts {
         }
     }
 
-    export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; } []{
+    export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; code: number; } []{
         return diagnostics.map(d => realizeDiagnostic(d, newLine));
     }
 
-    function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; } {
+    function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; code: number; } {
         return {
             message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
             start: diagnostic.start,

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ interface FindFileResult {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`interface IOLog {`
	`15`	`+ timestamp: string;`
`15`	`16`	`arguments: string[];`
`16`	`17`	`executingPath: string;`
`17`	`18`	`currentDirectory: string;`
Original file line number	Diff line number	Diff line change
`@@ -1102,6 +1102,7 @@ namespace ts {`
`1102`	`1102`	`}`
`1103`	`1103`
`1104`	`1104`	`export interface HighlightSpan {`
	`1105`	`+ fileName?: string;`
`1105`	`1106`	`textSpan: TextSpan;`
`1106`	`1107`	`kind: string;`
`1107`	`1108`	`}`
`@@ -1408,7 +1409,9 @@ namespace ts {`
`1408`	`1409`	`* @param fileName The name of the file to be released`
`1409`	`1410`	`* @param compilationSettings The compilation settings used to acquire the file`
`1410`	`1411`	`*/`
`1411`		`- releaseDocument(fileName: string, compilationSettings: CompilerOptions): void`
	`1412`	`+ releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;`
	`1413`	`+`
	`1414`	`+ reportStats(): string;`
`1412`	`1415`	`}`
`1413`	`1416`
`1414`	`1417`	`// TODO: move these to enums`
Original file line number	Diff line number	Diff line change
`@@ -428,11 +428,11 @@ namespace ts {`
`428`	`428`	`}`
`429`	`429`	`}`
`430`	`430`
`431`		`- export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; } []{`
	`431`	`+ export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; code: number; } []{`
`432`	`432`	`return diagnostics.map(d => realizeDiagnostic(d, newLine));`
`433`	`433`	`}`
`434`	`434`
`435`		`- function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; } {`
	`435`	`+ function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; code: number; } {`
`436`	`436`	`return {`
`437`	`437`	`message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),`
`438`	`438`	`start: diagnostic.start,`