Allow union and intersection as targets for object spread and rest, and distribute spread&rest over unions

tests/cases/compiler/restIntersectionOrIntersection.ts

@@ -0,0 +1,10 @@
+var intersection: { x: number, y: number } & { w: string, z: string };
+var union: { a: number, c: boolean } | { a: string, b: string };
+
+
+var rest1: { y: number, w: string, z: string };
+var {x, ...rest1 } = intersection;
+
+var rest2: { c: boolean } | { b: string };
+var {a, ...rest2 } = union;
+

tests/cases/compiler/restInvalidArgumentType.ts

@@ -0,0 +1,59 @@
+enum E { v1, v2 };
+
+function f<T extends { b: string }>(p1: T, p2: T[]) {
+    var t: T;
+
+    var i: T["b"];
+    var k: keyof T;
+
+    var mapped_generic: {[P in keyof T]: T[P]};
+    var mapped: {[P in "b"]: T[P]};
+
+    var union_generic: T | { a: number };
+    var union_primitive: { a: number } | number;
+
+    var intersection_generic: T & { a: number };
+    var intersection_premitive: { a: number } | string;
+
+    var num: number;
+    var str: number;
+
+    var u: undefined;
+    var n: null;
+
+    var a: any;
+
+    var literal_string: "string";
+    var literal_number: 42;
+
+    var e: E;
+
+    var {...r1} = p1;   // Error, generic type paramterre
+    var {...r2} = p2;   // OK
+    var {...r3} = t;   // Error, generic type paramter
+
+    var {...r4} = i;   // Error, index access
+    var {...r5} = k;   // Error, index
+
+    var {...r6} = mapped_generic; // Error, generic mapped object type
+    var {...r7} = mapped;  // OK, non-generic mapped type
+
+    var {...r8} = union_generic;  // Error, union with generic type parameter
+    var {...r9} = union_primitive;  // Error, union with generic type parameter
+
+    var {...r10} = intersection_generic;  // Error, intersection with generic type parameter
+    var {...r11} = intersection_premitive;  // Error, intersection with generic type parameter
+
+    var {...r12} = num;  // Error
+    var {...r13} = str;  // Error
+
+    var {...r14} = u;  // Error
+    var {...r15} = n;  // Error
+
+    var {...r16} = a;  // OK
+
+    var {...r17} = literal_string;  // Error
+    var {...r18} = literal_number;  // Error
+
+    var {...r19} = e;  // Error, enum
+}

tests/cases/compiler/spreadIntersection.ts

@@ -0,0 +1,7 @@
+var intersection: { a: number } & { b: string };
+
+var o1: { a: number, b: string };
+var o1 = { ...intersection };
+
+var o2: { a: number, b: string, c: boolean };
+var o2 = { ...intersection, c: false };

tests/cases/compiler/spreadInvalidArgumentType.ts

@@ -0,0 +1,59 @@
+enum E { v1, v2 };
+
+function f<T extends { b: string }>(p1: T, p2: T[]) {
+    var t: T;
+
+    var i: T["b"];
+    var k: keyof T;
+
+    var mapped_generic: {[P in keyof T]: T[P]};
+    var mapped: {[P in "b"]: T[P]};
+
+    var union_generic: T | { a: number };
+    var union_primitive: { a: number } | number;
+
+    var intersection_generic: T & { a: number };
+    var intersection_premitive: { a: number } | string;
+
+    var num: number;
+    var str: number;
+
+    var u: undefined;
+    var n: null;
+
+    var a: any;
+
+    var literal_string: "string";
+    var literal_number: 42;
+
+    var e: E;
+
+    var o1 = { ...p1 };   // Error, generic type paramterre
+    var o2 = { ...p2 };   // OK
+    var o3 = { ...t };   // Error, generic type paramter
+
+    var o4 = { ...i };   // Error, index access
+    var o5 = { ...k };   // Error, index
+
+    var o6 = { ...mapped_generic }; // Error, generic mapped object type
+    var o7 = { ...mapped };  // OK, non-generic mapped type
+
+    var o8 = { ...union_generic };  // Error, union with generic type parameter
+    var o9 = { ...union_primitive };  // Error, union with generic type parameter
+
+    var o10 = { ...intersection_generic };  // Error, intersection with generic type parameter
+    var o11 = { ...intersection_premitive };  // Error, intersection with generic type parameter
+
+    var o12 = { ...num };  // Error
+    var o13 = { ...str };  // Error
+
+    var o14 = { ...u };  // Error
+    var o15 = { ...n };  // Error
+
+    var o16 = { ...a };  // OK
+
+    var o17 = { ...literal_string };  // Error
+    var o18 = { ...literal_number };  // Error
+
+    var o19 = { ...e };  // Error, enum
+}

tests/cases/compiler/spreadUnion.ts

@@ -0,0 +1,10 @@
+var union: { a: number } | { b: string };
+
+var o3: { a: number } | { b: string };
+var o3 =  { ...union };
+
+var o4: { a: boolean } | { b: string , a: boolean};
+var o4 =  { ...union, a: false };
+
+var o5: { a: number } | { b: string } | { a: number, b: string };
+var o5 =  { ...union, ...union };