Improve excess property checking for intersections

sandersn · sandersn · commit 9d274f612ee0 · 2019-07-26T11:17:06.000-07:00
Still a draft, the implementation needs improvement
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
diff --git a/tests/baselines/reference/excessPropertyCheckWithNestedArrayIntersection.js b/tests/baselines/reference/excessPropertyCheckWithNestedArrayIntersection.js
@@ -0,0 +1,34 @@
+//// [excessPropertyCheckWithNestedArrayIntersection.ts]
+interface ValueOnlyFields {
+    fields: Array<{
+        value: number | null;
+    }>;
+}
+interface ValueAndKeyFields {
+    fields: Array<{
+        key: string | null;
+        value: number | null;
+    }>;
+}
+interface BugRepro {
+  dataType: ValueAndKeyFields & ValueOnlyFields;
+}
+const repro: BugRepro = {
+  dataType: {
+    fields: [{
+      key: 'bla', // should be OK: Not excess
+      value: null,
+    }],
+  }
+}
+
+
+//// [excessPropertyCheckWithNestedArrayIntersection.js]
+var repro = {
+    dataType: {
+        fields: [{
+                key: 'bla',
+                value: null
+            }]
+    }
+};
diff --git a/tests/baselines/reference/excessPropertyCheckWithNestedArrayIntersection.symbols b/tests/baselines/reference/excessPropertyCheckWithNestedArrayIntersection.symbols
@@ -0,0 +1,56 @@
+=== tests/cases/compiler/excessPropertyCheckWithNestedArrayIntersection.ts ===
+interface ValueOnlyFields {
+>ValueOnlyFields : Symbol(ValueOnlyFields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 0, 0))
+
+    fields: Array<{
+>fields : Symbol(ValueOnlyFields.fields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 0, 27))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+
+        value: number | null;
+>value : Symbol(value, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 1, 19))
+
+    }>;
+}
+interface ValueAndKeyFields {
+>ValueAndKeyFields : Symbol(ValueAndKeyFields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 4, 1))
+
+    fields: Array<{
+>fields : Symbol(ValueAndKeyFields.fields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 5, 29))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+
+        key: string | null;
+>key : Symbol(key, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 6, 19))
+
+        value: number | null;
+>value : Symbol(value, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 7, 27))
+
+    }>;
+}
+interface BugRepro {
+>BugRepro : Symbol(BugRepro, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 10, 1))
+
+  dataType: ValueAndKeyFields & ValueOnlyFields;
+>dataType : Symbol(BugRepro.dataType, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 11, 20))
+>ValueAndKeyFields : Symbol(ValueAndKeyFields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 4, 1))
+>ValueOnlyFields : Symbol(ValueOnlyFields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 0, 0))
+}
+const repro: BugRepro = {
+>repro : Symbol(repro, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 14, 5))
+>BugRepro : Symbol(BugRepro, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 10, 1))
+
+  dataType: {
+>dataType : Symbol(dataType, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 14, 25))
+
+    fields: [{
+>fields : Symbol(fields, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 15, 13))
+
+      key: 'bla', // should be OK: Not excess
+>key : Symbol(key, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 16, 14))
+
+      value: null,
+>value : Symbol(value, Decl(excessPropertyCheckWithNestedArrayIntersection.ts, 17, 17))
+
+    }],
+  }
+}
+
diff --git a/tests/baselines/reference/excessPropertyCheckWithNestedArrayIntersection.types b/tests/baselines/reference/excessPropertyCheckWithNestedArrayIntersection.types
@@ -0,0 +1,54 @@
+=== tests/cases/compiler/excessPropertyCheckWithNestedArrayIntersection.ts ===
+interface ValueOnlyFields {
+    fields: Array<{
+>fields : { value: number; }[]
+
+        value: number | null;
+>value : number
+>null : null
+
+    }>;
+}
+interface ValueAndKeyFields {
+    fields: Array<{
+>fields : { key: string; value: number; }[]
+
+        key: string | null;
+>key : string
+>null : null
+
+        value: number | null;
+>value : number
+>null : null
+
+    }>;
+}
+interface BugRepro {
+  dataType: ValueAndKeyFields & ValueOnlyFields;
+>dataType : ValueAndKeyFields & ValueOnlyFields
+}
+const repro: BugRepro = {
+>repro : BugRepro
+>{  dataType: {    fields: [{      key: 'bla', // should be OK: Not excess      value: null,    }],  }} : { dataType: { fields: { key: string; value: null; }[]; }; }
+
+  dataType: {
+>dataType : { fields: { key: string; value: null; }[]; }
+>{    fields: [{      key: 'bla', // should be OK: Not excess      value: null,    }],  } : { fields: { key: string; value: null; }[]; }
+
+    fields: [{
+>fields : { key: string; value: null; }[]
+>[{      key: 'bla', // should be OK: Not excess      value: null,    }] : { key: string; value: null; }[]
+>{      key: 'bla', // should be OK: Not excess      value: null,    } : { key: string; value: null; }
+
+      key: 'bla', // should be OK: Not excess
+>key : string
+>'bla' : "bla"
+
+      value: null,
+>value : null
+>null : null
+
+    }],
+  }
+}
+
diff --git a/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.errors.txt b/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.errors.txt
@@ -47,7 +47,7 @@ tests/cases/compiler/excessPropertyChecksWithNestedIntersections.ts(70,50): erro
                       ~
 !!! error TS2322: Type 'number' is not assignable to type 'string'.
 !!! related TS6500 tests/cases/compiler/excessPropertyChecksWithNestedIntersections.ts:4:5: The expected type comes from property 'x' which is declared here on type 'A'
-    let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error
+    let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A
                                   ~~~~
 !!! error TS2322: Type '{ x: string; y: number; }' is not assignable to type 'A'.
 !!! error TS2322:   Object literal may only specify known properties, and 'y' does not exist in type 'A'.
diff --git a/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.js b/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.js
@@ -21,7 +21,7 @@ let c: B = { a: { x: 'hello', y: 2 } }; // error - y does not exist in type A
 
 let d: D = { a: { x: 'hello' }, c: 5 }; // ok
 let e: D = { a: { x: 2 }, c: 5 }; // error - types of property x are incompatible
-let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error
+let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A
 
 // https://github.com/Microsoft/TypeScript/issues/18075
 
@@ -80,7 +80,7 @@ var b = { a: { x: 2 } }; // error - types of property x are incompatible
 var c = { a: { x: 'hello', y: 2 } }; // error - y does not exist in type A
 var d = { a: { x: 'hello' }, c: 5 }; // ok
 var e = { a: { x: 2 }, c: 5 }; // error - types of property x are incompatible
-var f = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error
+var f = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A
 exports.photo = {
     id: 1,
     url: '',
diff --git a/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.symbols b/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.symbols
@@ -61,7 +61,7 @@ let e: D = { a: { x: 2 }, c: 5 }; // error - types of property x are incompatibl
 >x : Symbol(x, Decl(excessPropertyChecksWithNestedIntersections.ts, 21, 17))
 >c : Symbol(c, Decl(excessPropertyChecksWithNestedIntersections.ts, 21, 25))
 
-let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error
+let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A
 >f : Symbol(f, Decl(excessPropertyChecksWithNestedIntersections.ts, 22, 3))
 >D : Symbol(D, Decl(excessPropertyChecksWithNestedIntersections.ts, 12, 1))
 >a : Symbol(a, Decl(excessPropertyChecksWithNestedIntersections.ts, 22, 12))
diff --git a/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.types b/tests/baselines/reference/excessPropertyChecksWithNestedIntersections.types
@@ -65,7 +65,7 @@ let e: D = { a: { x: 2 }, c: 5 }; // error - types of property x are incompatibl
 >c : number
 >5 : 5
 
-let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error
+let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A
 >f : D
 >{ a: { x: 'hello', y: 2 }, c: 5 } : { a: { x: string; y: number; }; c: number; }
 >a : { x: string; y: number; }
diff --git a/tests/baselines/reference/weakType.errors.txt b/tests/baselines/reference/weakType.errors.txt
@@ -5,10 +5,8 @@ tests/cases/compiler/weakType.ts(18,13): error TS2559: Type '12' has no properti
 tests/cases/compiler/weakType.ts(19,13): error TS2559: Type '"completely wrong"' has no properties in common with type 'Settings'.
 tests/cases/compiler/weakType.ts(20,13): error TS2559: Type 'false' has no properties in common with type 'Settings'.
 tests/cases/compiler/weakType.ts(37,18): error TS2559: Type '{ error?: number; }' has no properties in common with type 'ChangeOptions'.
-tests/cases/compiler/weakType.ts(62,5): error TS2322: Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak & Spoiler'.
-  Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak'.
-    Types of property 'properties' are incompatible.
-      Type '{ wrong: string; }' has no properties in common with type '{ b?: number; }'.
+tests/cases/compiler/weakType.ts(62,5): error TS2326: Types of property 'properties' are incompatible.
+  Type '{ wrong: string; }' has no properties in common with type '{ b?: number; }'.
 
 
 ==== tests/cases/compiler/weakType.ts (8 errors) ====
@@ -85,16 +83,14 @@ tests/cases/compiler/weakType.ts(62,5): error TS2322: Type '{ properties: { wron
             b?: number
         }
     }
-    declare let unknown: {
+    declare let propertiesWrong: {
         properties: {
             wrong: string
         }
     }
-    let weak: Weak & Spoiler = unknown
+    let weak: Weak & Spoiler = propertiesWrong
         ~~~~
-!!! error TS2322: Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak & Spoiler'.
-!!! error TS2322:   Type '{ properties: { wrong: string; }; }' is not assignable to type 'Weak'.
-!!! error TS2322:     Types of property 'properties' are incompatible.
-!!! error TS2322:       Type '{ wrong: string; }' has no properties in common with type '{ b?: number; }'.
+!!! error TS2326: Types of property 'properties' are incompatible.
+!!! error TS2326:   Type '{ wrong: string; }' has no properties in common with type '{ b?: number; }'.
     
     
diff --git a/tests/baselines/reference/weakType.js b/tests/baselines/reference/weakType.js
@@ -55,12 +55,12 @@ type Weak = {
         b?: number
     }
 }
-declare let unknown: {
+declare let propertiesWrong: {
     properties: {
         wrong: string
     }
 }
-let weak: Weak & Spoiler = unknown
+let weak: Weak & Spoiler = propertiesWrong
 
 
 
@@ -89,4 +89,4 @@ var K = /** @class */ (function () {
     return K;
 }());
 var ctor = K;
-var weak = unknown;
+var weak = propertiesWrong;
diff --git a/tests/baselines/reference/weakType.symbols b/tests/baselines/reference/weakType.symbols
@@ -144,20 +144,20 @@ type Weak = {
 >b : Symbol(b, Decl(weakType.ts, 52, 18))
     }
 }
-declare let unknown: {
->unknown : Symbol(unknown, Decl(weakType.ts, 56, 11))
+declare let propertiesWrong: {
+>propertiesWrong : Symbol(propertiesWrong, Decl(weakType.ts, 56, 11))
 
     properties: {
->properties : Symbol(properties, Decl(weakType.ts, 56, 22))
+>properties : Symbol(properties, Decl(weakType.ts, 56, 30))
 
         wrong: string
 >wrong : Symbol(wrong, Decl(weakType.ts, 57, 17))
     }
 }
-let weak: Weak & Spoiler = unknown
+let weak: Weak & Spoiler = propertiesWrong
 >weak : Symbol(weak, Decl(weakType.ts, 61, 3))
 >Weak : Symbol(Weak, Decl(weakType.ts, 49, 32))
 >Spoiler : Symbol(Spoiler, Decl(weakType.ts, 47, 18))
->unknown : Symbol(unknown, Decl(weakType.ts, 56, 11))
+>propertiesWrong : Symbol(propertiesWrong, Decl(weakType.ts, 56, 11))
 
 
diff --git a/tests/baselines/reference/weakType.types b/tests/baselines/reference/weakType.types
@@ -147,8 +147,8 @@ type Weak = {
 >b : number
     }
 }
-declare let unknown: {
->unknown : { properties: { wrong: string; }; }
+declare let propertiesWrong: {
+>propertiesWrong : { properties: { wrong: string; }; }
 
     properties: {
 >properties : { wrong: string; }
@@ -157,8 +157,8 @@ declare let unknown: {
 >wrong : string
     }
 }
-let weak: Weak & Spoiler = unknown
+let weak: Weak & Spoiler = propertiesWrong
 >weak : Weak & Spoiler
->unknown : { properties: { wrong: string; }; }
+>propertiesWrong : { properties: { wrong: string; }; }
 
 
diff --git a/tests/cases/compiler/excessPropertyCheckWithNestedArrayIntersection.ts b/tests/cases/compiler/excessPropertyCheckWithNestedArrayIntersection.ts
@@ -0,0 +1,22 @@
+interface ValueOnlyFields {
+    fields: Array<{
+        value: number | null;
+    }>;
+}
+interface ValueAndKeyFields {
+    fields: Array<{
+        key: string | null;
+        value: number | null;
+    }>;
+}
+interface BugRepro {
+  dataType: ValueAndKeyFields & ValueOnlyFields;
+}
+const repro: BugRepro = {
+  dataType: {
+    fields: [{
+      key: 'bla', // should be OK: Not excess
+      value: null,
+    }],
+  }
+}
diff --git a/tests/cases/compiler/excessPropertyChecksWithNestedIntersections.ts b/tests/cases/compiler/excessPropertyChecksWithNestedIntersections.ts
@@ -20,7 +20,7 @@ let c: B = { a: { x: 'hello', y: 2 } }; // error - y does not exist in type A
 
 let d: D = { a: { x: 'hello' }, c: 5 }; // ok
 let e: D = { a: { x: 2 }, c: 5 }; // error - types of property x are incompatible
-let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error
+let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A
 
 // https://github.com/Microsoft/TypeScript/issues/18075
 
diff --git a/tests/cases/compiler/weakType.ts b/tests/cases/compiler/weakType.ts
@@ -54,10 +54,10 @@ type Weak = {
         b?: number
     }
 }
-declare let unknown: {
+declare let propertiesWrong: {
     properties: {
         wrong: string
     }
 }
-let weak: Weak & Spoiler = unknown
+let weak: Weak & Spoiler = propertiesWrong
 

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ tests/cases/compiler/excessPropertyChecksWithNestedIntersections.ts(70,50): erro`
`47`	`47`	`~`
`48`	`48`	`!!! error TS2322: Type 'number' is not assignable to type 'string'.`
`49`	`49`	`!!! related TS6500 tests/cases/compiler/excessPropertyChecksWithNestedIntersections.ts:4:5: The expected type comes from property 'x' which is declared here on type 'A'`
`50`		`- let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // should be an error`
	`50`	`+ let f: D = { a: { x: 'hello', y: 2 }, c: 5 }; // error - y does not exist in type A`
`51`	`51`	`~~~~`
`52`	`52`	`!!! error TS2322: Type '{ x: string; y: number; }' is not assignable to type 'A'.`
`53`	`53`	`!!! error TS2322: Object literal may only specify known properties, and 'y' does not exist in type 'A'.`
Original file line number	Diff line number	Diff line change
`@@ -55,12 +55,12 @@ type Weak = {`
`55`	`55`	`b?: number`
`56`	`56`	`}`
`57`	`57`	`}`
`58`		`-declare let unknown: {`
	`58`	`+declare let propertiesWrong: {`
`59`	`59`	`properties: {`
`60`	`60`	`wrong: string`
`61`	`61`	`}`
`62`	`62`	`}`
`63`		`-let weak: Weak & Spoiler = unknown`
	`63`	`+let weak: Weak & Spoiler = propertiesWrong`
`64`	`64`
`65`	`65`
`66`	`66`
`@@ -89,4 +89,4 @@ var K = /** @class */ (function () {`
`89`	`89`	`return K;`
`90`	`90`	`}());`
`91`	`91`	`var ctor = K;`
`92`		`-var weak = unknown;`
	`92`	`+var weak = propertiesWrong;`
Original file line number	Diff line number	Diff line change
`@@ -144,20 +144,20 @@ type Weak = {`
`144`	`144`	`>b : Symbol(b, Decl(weakType.ts, 52, 18))`
`145`	`145`	`}`
`146`	`146`	`}`
`147`		`-declare let unknown: {`
`148`		`->unknown : Symbol(unknown, Decl(weakType.ts, 56, 11))`
	`147`	`+declare let propertiesWrong: {`
	`148`	`+>propertiesWrong : Symbol(propertiesWrong, Decl(weakType.ts, 56, 11))`
`149`	`149`
`150`	`150`	`properties: {`
`151`		`->properties : Symbol(properties, Decl(weakType.ts, 56, 22))`
	`151`	`+>properties : Symbol(properties, Decl(weakType.ts, 56, 30))`
`152`	`152`
`153`	`153`	`wrong: string`
`154`	`154`	`>wrong : Symbol(wrong, Decl(weakType.ts, 57, 17))`
`155`	`155`	`}`
`156`	`156`	`}`
`157`		`-let weak: Weak & Spoiler = unknown`
	`157`	`+let weak: Weak & Spoiler = propertiesWrong`
`158`	`158`	`>weak : Symbol(weak, Decl(weakType.ts, 61, 3))`
`159`	`159`	`>Weak : Symbol(Weak, Decl(weakType.ts, 49, 32))`
`160`	`160`	`>Spoiler : Symbol(Spoiler, Decl(weakType.ts, 47, 18))`
`161`		`->unknown : Symbol(unknown, Decl(weakType.ts, 56, 11))`
	`161`	`+>propertiesWrong : Symbol(propertiesWrong, Decl(weakType.ts, 56, 11))`
`162`	`162`
`163`	`163`
Original file line number	Diff line number	Diff line change
`@@ -147,8 +147,8 @@ type Weak = {`
`147`	`147`	`>b : number`
`148`	`148`	`}`
`149`	`149`	`}`
`150`		`-declare let unknown: {`
`151`		`->unknown : { properties: { wrong: string; }; }`
	`150`	`+declare let propertiesWrong: {`
	`151`	`+>propertiesWrong : { properties: { wrong: string; }; }`
`152`	`152`
`153`	`153`	`properties: {`
`154`	`154`	`>properties : { wrong: string; }`
`@@ -157,8 +157,8 @@ declare let unknown: {`
`157`	`157`	`>wrong : string`
`158`	`158`	`}`
`159`	`159`	`}`
`160`		`-let weak: Weak & Spoiler = unknown`
	`160`	`+let weak: Weak & Spoiler = propertiesWrong`
`161`	`161`	`>weak : Weak & Spoiler`
`162`		`->unknown : { properties: { wrong: string; }; }`
	`162`	`+>propertiesWrong : { properties: { wrong: string; }; }`
`163`	`163`
`164`	`164`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,10 @@ type Weak = {`
`54`	`54`	`b?: number`
`55`	`55`	`}`
`56`	`56`	`}`
`57`		`-declare let unknown: {`
	`57`	`+declare let propertiesWrong: {`
`58`	`58`	`properties: {`
`59`	`59`	`wrong: string`
`60`	`60`	`}`
`61`	`61`	`}`
`62`		`-let weak: Weak & Spoiler = unknown`
	`62`	`+let weak: Weak & Spoiler = propertiesWrong`
`63`	`63`