Weak type detection

src/compiler/checker.ts

@@ -2285,7 +2285,7 @@ namespace ts {
             Debug.assert(typeNode !== undefined, "should always get typenode?");
             const options = { removeComments: true };
             const writer = createTextWriter("");
-            const printer = createPrinter(options, writer);
+            const printer = createPrinter(options);
             const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
             printer.writeNode(EmitHint.Unspecified, typeNode, /*sourceFile*/ sourceFile, writer);
             const result = writer.getText();
@@ -8701,6 +8701,7 @@ namespace ts {
             let expandingFlags: number;
             let depth = 0;
             let overflow = false;
+            let disableWeakTypeErrors = false;
 
             Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
 
@@ -8977,17 +8978,35 @@ namespace ts {
                 }
             }
 
-            function typeRelatedToEachType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary {
+            function typeRelatedToEachType(source: Type, target: IntersectionType, reportErrors: boolean): Ternary {
                 let result = Ternary.True;
                 const targetTypes = target.types;
+                const saveDisableWeakTypeErrors = disableWeakTypeErrors;
+                disableWeakTypeErrors = true;
                 for (const targetType of targetTypes) {
                     const related = isRelatedTo(source, targetType, reportErrors);
                     if (!related) {
+                        disableWeakTypeErrors = saveDisableWeakTypeErrors;
                         return Ternary.False;
                     }
                     result &= related;
                 }
-                return result;
+                disableWeakTypeErrors = saveDisableWeakTypeErrors;
+                return reportAssignmentToWeakIntersection(source, target, reportErrors) ? Ternary.False : result;
+            }
+
+            function reportAssignmentToWeakIntersection(source: Type, target: IntersectionType, reportErrors: boolean) {
+                const needsWeakTypeCheck = source !== globalObjectType && getPropertiesOfType(source).length > 0 && every(target.types, isWeakType);
+                if (!needsWeakTypeCheck) {
+                    return false;
+                }
+                const hasSharedProperty = forEach(
+                    getPropertiesOfType(source),
+                    p => isKnownProperty(target, p.name, /*isComparingJsxAttributes*/ false));
+                if (!hasSharedProperty && reportErrors) {
+                    reportError(Diagnostics.Weak_type_0_has_no_properties_in_common_with_1, typeToString(target), typeToString(source));
+                }
+                return !hasSharedProperty;
             }
 
             function someTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean): Ternary {
@@ -9277,8 +9296,12 @@ namespace ts {
                 let result = Ternary.True;
                 const properties = getPropertiesOfObjectType(target);
                 const requireOptionalProperties = relation === subtypeRelation && !(getObjectFlags(source) & ObjectFlags.ObjectLiteral);
+                let foundMatchingProperty = !isWeakType(target);
                 for (const targetProp of properties) {
                     const sourceProp = getPropertyOfType(source, targetProp.name);
+                    if (sourceProp) {
+                        foundMatchingProperty = true;
+                    }
 
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
@@ -9329,7 +9352,10 @@ namespace ts {
                                 }
                                 return Ternary.False;
                             }
+                            const saveDisableWeakTypeErrors = disableWeakTypeErrors;
+                            disableWeakTypeErrors = false;
                             const related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
+                            disableWeakTypeErrors = saveDisableWeakTypeErrors;
                             if (!related) {
                                 if (reportErrors) {
                                     reportError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
@@ -9355,9 +9381,30 @@ namespace ts {
                         }
                     }
                 }
+                if (!foundMatchingProperty && !disableWeakTypeErrors && source !== globalObjectType && getPropertiesOfType(source).length > 0)  {
+                    if (reportErrors) {
+                        reportError(Diagnostics.Weak_type_0_has_no_properties_in_common_with_1, typeToString(target), typeToString(source));
+                    }
+                    return Ternary.False;
+                }
                 return result;
             }
 
+            /**
+             * A type is 'weak' if it is an object type with at least one optional property
+             * and no required properties, call/construct signatures or index signatures
+             */
+            function isWeakType(type: Type) {
+                const props = getPropertiesOfType(type);
+                return type.flags & TypeFlags.Object &&
+                    props.length > 0 &&
+                    every(props, p => !!(p.flags & SymbolFlags.Optional)) &&
+                    !getSignaturesOfType(type, SignatureKind.Call).length &&
+                    !getSignaturesOfType(type, SignatureKind.Construct).length &&
+                    !getIndexTypeOfType(type, IndexKind.String) &&
+                    !getIndexTypeOfType(type, IndexKind.Number);
+            }
+
             function propertiesIdenticalTo(source: Type, target: Type): Ternary {
                 if (!(source.flags & TypeFlags.Object && target.flags & TypeFlags.Object)) {
                     return Ternary.False;
@@ -14121,8 +14168,10 @@ namespace ts {
         function isKnownProperty(targetType: Type, name: string, isComparingJsxAttributes: boolean): boolean {
             if (targetType.flags & TypeFlags.Object) {
                 const resolved = resolveStructuredTypeMembers(<ObjectType>targetType);
-                if (resolved.stringIndexInfo || resolved.numberIndexInfo && isNumericLiteralName(name) ||
-                    getPropertyOfType(targetType, name) || isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
+                if (resolved.stringIndexInfo ||
+                    resolved.numberIndexInfo && isNumericLiteralName(name) ||
+                    getPropertyOfType(targetType, name) ||
+                    isComparingJsxAttributes && !isUnhyphenatedJsxName(name)) {
                     // For JSXAttributes, if the attribute has a hyphenated name, consider that the attribute to be known.
                     return true;
                 }
@@ -22671,12 +22720,12 @@ namespace ts {
                 return symbols;
             }
             else if (symbol.flags & SymbolFlags.Transient) {
-                if ((symbol as SymbolLinks).leftSpread) {
-                    const links = symbol as SymbolLinks;
-                    return [...getRootSymbols(links.leftSpread), ...getRootSymbols(links.rightSpread)];
+                const transient = symbol as TransientSymbol;
+                if (transient.leftSpread) {
+                    return [...getRootSymbols(transient.leftSpread), ...getRootSymbols(transient.rightSpread)];
                 }
-                if ((symbol as SymbolLinks).syntheticOrigin) {
-                    return getRootSymbols((symbol as SymbolLinks).syntheticOrigin);
+                if (transient.syntheticOrigin) {
+                    return getRootSymbols(transient.syntheticOrigin);
                 }
 
                 let target: Symbol;

src/compiler/diagnosticMessages.json

@@ -1879,6 +1879,10 @@
         "category": "Error",
         "code": 2558
     },
+    "Weak type '{0}' has no properties in common with '{1}'.": {
+        "category": "Error",
+        "code": 2559
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600

tests/baselines/reference/APISample_watcher.js

@@ -11,7 +11,7 @@ declare var fs: {
     existsSync(path: string): boolean;
     readdirSync(path: string): string[];
     readFileSync(filename: string, encoding?: string): string;
-    writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; } | string): void;
     watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: { mtime: Date }, prev: { mtime: Date }) => void): void;
 };
 declare var path: any;

tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.errors.txt

@@ -1,3 +1,18 @@
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(33,5): error TS2322: Type 'D' is not assignable to type 'C'.
+  Weak type 'C' has no properties in common with 'D'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(34,5): error TS2322: Type 'E' is not assignable to type 'C'.
+  Weak type 'C' has no properties in common with 'E'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(35,5): error TS2322: Type 'F' is not assignable to type 'C'.
+  Weak type 'C' has no properties in common with 'F'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(36,5): error TS2322: Type 'D' is not assignable to type '{ opt?: Base; }'.
+  Weak type '{ opt?: Base; }' has no properties in common with 'D'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(37,5): error TS2322: Type 'E' is not assignable to type '{ opt?: Base; }'.
+  Weak type '{ opt?: Base; }' has no properties in common with 'E'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(38,5): error TS2322: Type 'F' is not assignable to type '{ opt?: Base; }'.
+  Weak type '{ opt?: Base; }' has no properties in common with 'F'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(39,5): error TS2322: Type 'D' is not assignable to type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(40,5): error TS2322: Type 'E' is not assignable to type '{ opt?: Base; }'.
+tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(41,5): error TS2322: Type 'F' is not assignable to type '{ opt?: Base; }'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(74,5): error TS2322: Type 'D' is not assignable to type 'C'.
   Property 'opt' is missing in type 'D'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts(75,5): error TS2322: Type 'E' is not assignable to type 'C'.
@@ -18,7 +33,7 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
   Property 'opt' is missing in type 'F'.
 
 
-==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts (9 errors) ====
+==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithObjectMembersOptionality2.ts (18 errors) ====
     // M is optional and S contains no property with the same name as M
     // N is optional and T contains no property with the same name as N
 
@@ -50,20 +65,44 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
         var e: E;
         var f: F;
 
-        // all ok
+        // disallowed by weak type checking
         c = d;
+        ~
+!!! error TS2322: Type 'D' is not assignable to type 'C'.
+!!! error TS2322:   Weak type 'C' has no properties in common with 'D'.
         c = e;
+        ~
+!!! error TS2322: Type 'E' is not assignable to type 'C'.
+!!! error TS2322:   Weak type 'C' has no properties in common with 'E'.
         c = f;
-        c = a;
-
+        ~
+!!! error TS2322: Type 'F' is not assignable to type 'C'.
+!!! error TS2322:   Weak type 'C' has no properties in common with 'F'.
         a = d;
+        ~
+!!! error TS2322: Type 'D' is not assignable to type '{ opt?: Base; }'.
+!!! error TS2322:   Weak type '{ opt?: Base; }' has no properties in common with 'D'.
         a = e;
+        ~
+!!! error TS2322: Type 'E' is not assignable to type '{ opt?: Base; }'.
+!!! error TS2322:   Weak type '{ opt?: Base; }' has no properties in common with 'E'.
         a = f;
-        a = c;
-
+        ~
+!!! error TS2322: Type 'F' is not assignable to type '{ opt?: Base; }'.
+!!! error TS2322:   Weak type '{ opt?: Base; }' has no properties in common with 'F'.
         b = d;
+        ~
+!!! error TS2322: Type 'D' is not assignable to type '{ opt?: Base; }'.
         b = e;
+        ~
+!!! error TS2322: Type 'E' is not assignable to type '{ opt?: Base; }'.
         b = f;
+        ~
+!!! error TS2322: Type 'F' is not assignable to type '{ opt?: Base; }'.
+
+        // ok
+        c = a;
+        a = c;
         b = a;
         b = c;
     }
@@ -134,4 +173,5 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
 !!! error TS2322:   Property 'opt' is missing in type 'F'.
         b = a; // ok
         b = c; // ok
-    }
+    }
+

tests/baselines/reference/assignmentCompatWithObjectMembersOptionality2.js

@@ -30,20 +30,20 @@ module TargetHasOptional {
     var e: E;
     var f: F;
 
-    // all ok
+    // disallowed by weak type checking
     c = d;
     c = e;
     c = f;
-    c = a;
-
     a = d;
     a = e;
     a = f;
-    a = c;
-
     b = d;
     b = e;
     b = f;
+
+    // ok
+    c = a;
+    a = c;
     b = a;
     b = c;
 }
@@ -87,7 +87,8 @@ module SourceHasOptional {
     b = f; // error
     b = a; // ok
     b = c; // ok
-}
+}
+
 
 //// [assignmentCompatWithObjectMembersOptionality2.js]
 // M is optional and S contains no property with the same name as M
@@ -129,18 +130,19 @@ var TargetHasOptional;
     var d;
     var e;
     var f;
-    // all ok
+    // disallowed by weak type checking
     c = d;
     c = e;
     c = f;
-    c = a;
     a = d;
     a = e;
     a = f;
-    a = c;
     b = d;
     b = e;
     b = f;
+    // ok
+    c = a;
+    a = c;
     b = a;
     b = c;
 })(TargetHasOptional || (TargetHasOptional = {}));

tests/baselines/reference/checkJsxChildrenProperty1.symbols

@@ -13,8 +13,8 @@ interface Prop {
 
     children: string | JSX.Element
 >children : Symbol(Prop.children, Decl(file.tsx, 4, 14))
->JSX : Symbol(JSX, Decl(react.d.ts, 2352, 1))
->Element : Symbol(JSX.Element, Decl(react.d.ts, 2355, 27))
+>JSX : Symbol(JSX, Decl(react.d.ts, 2353, 1))
+>Element : Symbol(JSX.Element, Decl(react.d.ts, 2356, 27))
 }
 
 function Comp(p: Prop) {
@@ -23,11 +23,11 @@ function Comp(p: Prop) {
 >Prop : Symbol(Prop, Decl(file.tsx, 0, 32))
 
     return <div>{p.b}</div>;
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 >p.b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
 >p : Symbol(p, Decl(file.tsx, 8, 14))
 >b : Symbol(Prop.b, Decl(file.tsx, 3, 14))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 }
 
 // OK
@@ -59,8 +59,8 @@ let k2 =
 >b : Symbol(b, Decl(file.tsx, 19, 16))
 
         <div>hi hi hi!</div>
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
->div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2399, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
+>div : Symbol(JSX.IntrinsicElements.div, Decl(react.d.ts, 2400, 45))
 
     </Comp>;
 >Comp : Symbol(Comp, Decl(file.tsx, 6, 1))