address code review feedback

Author: HerringtonDarkholme

src/compiler/checker.ts

@@ -3089,10 +3089,6 @@ 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) {
@@ -7475,7 +7471,7 @@ namespace ts {
                         }
                     }
                 }
-                else if (!(source.flags & TypeFlags.Primitive && isTypeNonPrimitive(target))) {
+                else if (!(source.flags & TypeFlags.Primitive && target === nonPrimitiveType)) {
                     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)) {

tests/cases/conformance/types/nonPrimitive/nonPrimitiveAccessProperty.ts

@@ -0,0 +1,3 @@
+var a: object;
+a.toString();
+a.nonExist(); // error

tests/cases/conformance/types/nonPrimitive/nonPrimitiveAssignError.ts

@@ -15,3 +15,11 @@ a = s; // expect error
 n = a; // expect error
 b = a; // expect error
 s = a; // expect error
+
+var numObj: Number = 123;
+var boolObj: Boolean = true;
+var strObj: String = "string";
+
+a = numObj; // ok
+a = boolObj; // ok
+a = strObj; // ok

tests/cases/conformance/types/nonPrimitive/nonPrimitiveInGeneric.ts

@@ -13,3 +13,10 @@ bound({});
 bound(a);
 bound(123); // expect error
 bound(b); // expect error
+
+function bound2<T extends object>() {}
+
+bound2<{}>();
+bound2<Object>();
+bound2<number>(); // expect error
+bound2<string>(); // expect error

tests/cases/conformance/types/nonPrimitive/nonPrimitiveNarrow.ts

@@ -0,0 +1,22 @@
+class Narrow {
+    narrowed: boolean
+}
+
+var a: object
+
+if (a instanceof Narrow) {
+    a.narrowed; // ok
+    a = 123; // error
+}
+
+if (typeof a === 'number') {
+    a.toFixed(); // error, never
+}
+
+var b: object | null
+
+if (typeof b === 'object') {
+   b.toString(); // error, object | null
+} else {
+   b.toString(); // error, never
+}

tests/cases/conformance/types/nonPrimitive/nonPrimitiveStrictNull.ts

@@ -0,0 +1,48 @@
+// @strictNullChecks: true
+
+var a: object
+declare var b: object | null
+declare var c: object | undefined
+declare var d: object | null | undefined
+var e: object | null
+a.toString; // error
+a = undefined; // error
+a = null; // error
+a = b; // error
+a = c; // error
+a = d; // error
+
+e = a; // ok
+a = e; // ok
+
+if (typeof b !== 'object') {
+    b.toString(); // error, never
+}
+
+if (typeof b === 'object') {
+    a = b; // error, b is not narrowed
+}
+
+if (typeof d === 'object') {
+    b = d; // ok
+} else {
+    d; // undefined
+}
+
+if (d == null) {
+    d; // null | undefined
+} else {
+    d.toString(); // object
+}
+
+if (d === null) {
+    d; // null
+} else {
+    d.toString(); // error, object | undefined
+}
+
+if (typeof d === 'undefined') {
+    d; // undefined
+} else {
+    d.toString(); // error, object | null
+}