From ce4c95f332975ea5c2fd18e5c17bf4443056b5b1 Mon Sep 17 00:00:00 2001
From: Herrington Darkholme <nonamesheep1@gmail.com>
Date: Fri, 25 Nov 2016 22:24:31 +0800
Subject: [PATCH] fix error reporting

---
 src/compiler/checker.ts | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 39832dfcb35..c863e2fd2c7 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1685,11 +1685,10 @@ namespace ts {
             return type;
         }
 
-        function createNonPrimitiveType(): NonPrimitiveType {
-            const type = <NonPrimitiveType>setStructuredTypeMembers(
+        function createNonPrimitiveType(): ResolvedType {
+            const type = setStructuredTypeMembers(
                 createObjectType(ObjectFlags.NonPrimitive, undefined),
                 emptySymbols, emptyArray, emptyArray, undefined, undefined);
-            type.intrinsicName = "object";
             return type;
         }
 
@@ -2321,6 +2320,9 @@ namespace ts {
                     else if (type.flags & TypeFlags.UnionOrIntersection) {
                         writeUnionOrIntersectionType(<UnionOrIntersectionType>type, nextFlags);
                     }
+                    else if (getObjectFlags(type) & ObjectFlags.NonPrimitive) {
+                        writer.writeKeyword("object");
+                    }
                     else if (getObjectFlags(type) & (ObjectFlags.Anonymous | ObjectFlags.Mapped)) {
                         writeAnonymousType(<ObjectType>type, nextFlags);
                     }
@@ -3087,6 +3089,10 @@ namespace ts {
             return type && (type.flags & TypeFlags.Never) !== 0;
         }
 
+        function isTypeNonPrimitive(type: Type) {
+            return type === nonPrimitiveType;
+        }
+
         // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
         // assigned by contextual typing.
         function getTypeForBindingElementParent(node: VariableLikeDeclaration) {
@@ -7151,7 +7157,6 @@ namespace ts {
             if (source.flags & TypeFlags.Enum && target.flags & TypeFlags.Enum && isEnumTypeRelatedTo(<EnumType>source, <EnumType>target, errorReporter)) return true;
             if (source.flags & TypeFlags.Undefined && (!strictNullChecks || target.flags & (TypeFlags.Undefined | TypeFlags.Void))) return true;
             if (source.flags & TypeFlags.Null && (!strictNullChecks || target.flags & TypeFlags.Null)) return true;
-            if (source.flags & TypeFlags.Object && (<ObjectType>source).objectFlags & ObjectFlags.NonPrimitive && target.flags & TypeFlags.Primitive) return false;
             if (relation === assignableRelation || relation === comparableRelation) {
                 if (source.flags & TypeFlags.Any) return true;
                 if ((source.flags & TypeFlags.Number | source.flags & TypeFlags.NumberLiteral) && target.flags & TypeFlags.EnumLike) return true;
@@ -7470,7 +7475,7 @@ namespace ts {
                         }
                     }
                 }
-                else {
+                else if (!(source.flags & TypeFlags.Primitive && isTypeNonPrimitive(target))) {
                     if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(target) & ObjectFlags.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 = typeArgumentsRelatedTo(<TypeReference>source, <TypeReference>target, reportErrors)) {
@@ -18085,6 +18090,7 @@ namespace ts {
                 case "string":
                 case "symbol":
                 case "void":
+                case "object":
                     error(name, message, (<Identifier>name).text);
             }
         }