Merge pull request #5737 from Microsoft/unionIntersectionTypeInference

Improved union/intersection type inference
Conflicts:
	src/compiler/checker.ts

Author: ahejlsberg

src/compiler/checker.ts

@@ -43,6 +43,8 @@ namespace ts {
         let emptyArray: any[] = [];
         let emptySymbols: SymbolTable = {};
 
+        let jsxElementClassType: Type = undefined;
+
         let compilerOptions = host.getCompilerOptions();
         let languageVersion = compilerOptions.target || ScriptTarget.ES3;
         let modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None;
@@ -5928,6 +5930,17 @@ namespace ts {
             }
 
             function inferFromTypes(source: Type, target: Type) {
+                if (source.flags & TypeFlags.Union && target.flags & TypeFlags.Union ||
+                    source.flags & TypeFlags.Intersection && target.flags & TypeFlags.Intersection) {
+                    // Source and target are both unions or both intersections. To improve the quality of
+                    // inferences we first reduce the types by removing constituents that are identically
+                    // matched by a constituent in the other type. For example, when inferring from
+                    // 'string | string[]' to 'string | T', we reduce the types to 'string[]' and 'T'.
+                    const reducedSource = reduceUnionOrIntersectionType(<UnionOrIntersectionType>source, <UnionOrIntersectionType>target);
+                    const reducedTarget = reduceUnionOrIntersectionType(<UnionOrIntersectionType>target, <UnionOrIntersectionType>source);
+                    source = reducedSource;
+                    target = reducedTarget;
+                }
                 if (target.flags & TypeFlags.TypeParameter) {
                     // If target is a type parameter, make an inference, unless the source type contains
                     // the anyFunctionType (the wildcard type that's used to avoid contextually typing functions).
@@ -5938,8 +5951,7 @@ namespace ts {
                     if (source.flags & TypeFlags.ContainsAnyFunctionType) {
                         return;
                     }
-
-                    let typeParameters = context.typeParameters;
+                    const typeParameters = context.typeParameters;
                     for (let i = 0; i < typeParameters.length; i++) {
                         if (target === typeParameters[i]) {
                             let inferences = context.inferences[i];
@@ -6086,6 +6098,41 @@ namespace ts {
             }
         }
 
+        function typeIdenticalToSomeType(source: Type, target: UnionOrIntersectionType): boolean {
+            for (const t of target.types) {
+                if (isTypeIdenticalTo(source, t)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /**
+         * Return the reduced form of the source type. This type is computed by by removing all source
+         * constituents that have an identical match in the target type.
+         */
+        function reduceUnionOrIntersectionType(source: UnionOrIntersectionType, target: UnionOrIntersectionType) {
+            let sourceTypes = source.types;
+            let sourceIndex = 0;
+            let modified = false;
+            while (sourceIndex < sourceTypes.length) {
+                if (typeIdenticalToSomeType(sourceTypes[sourceIndex], target)) {
+                    if (!modified) {
+                        sourceTypes = sourceTypes.slice(0);
+                        modified = true;
+                    }
+                    sourceTypes.splice(sourceIndex, 1);
+                }
+                else {
+                    sourceIndex++;
+                }
+            }
+            if (modified) {
+                return source.flags & TypeFlags.Union ? getUnionType(sourceTypes, /*noSubtypeReduction*/ true) : getIntersectionType(sourceTypes);
+            }
+            return source;
+        }
+
         function getInferenceCandidates(context: InferenceContext, index: number): Type[] {
             let inferences = context.inferences[index];
             return inferences.primary || inferences.secondary || emptyArray;
@@ -7859,7 +7906,6 @@ namespace ts {
             return prop || unknownSymbol;
         }
 
-        let jsxElementClassType: Type = undefined;
         function getJsxGlobalElementClassType(): Type {
             if (!jsxElementClassType) {
                 jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);

tests/baselines/reference/unionAndIntersectionInference1.js

@@ -0,0 +1,113 @@
+//// [unionAndIntersectionInference1.ts]
+// Repro from #2264
+
+interface Y { 'i am a very certain type': Y }
+var y: Y = <Y>undefined;
+function destructure<a, r>(
+    something: a | Y,
+    haveValue: (value: a) => r,
+    haveY: (value: Y) => r
+): r {
+    return something === y ? haveY(y) : haveValue(<a>something);
+}
+
+var value = Math.random() > 0.5 ? 'hey!' : <Y>undefined;
+
+var result = destructure(value, text => 'string', y => 'other one'); // text: string, y: Y
+
+// Repro from #4212
+
+function isVoid<a>(value: void | a): value is void {
+    return undefined;
+}
+
+function isNonVoid<a>(value: void | a) : value is a {
+    return undefined;
+}
+
+function foo1<a>(value: void|a): void {
+    if (isVoid(value)) {
+        value; // value is void
+    } else {
+        value; // value is a
+    }
+}
+
+function baz1<a>(value: void|a): void {
+      if (isNonVoid(value)) {
+          value; // value is a
+      } else {
+          value; // value is void
+      }
+}
+
+// Repro from #5417
+
+type Maybe<T> = T | void;
+
+function get<U>(x: U | void): U {
+   return null; // just an example
+}
+
+let foo: Maybe<string>;
+get(foo).toUpperCase(); // Ok
+
+// Repro from #5456
+
+interface Man {
+    walks: boolean;
+}
+
+interface Bear {
+    roars: boolean;
+}
+
+interface Pig {
+    oinks: boolean;
+}
+
+declare function pigify<T>(y: T & Bear): T & Pig;
+declare var mbp: Man & Bear;
+
+pigify(mbp).oinks; // OK, mbp is treated as Pig
+pigify(mbp).walks; // Ok, mbp is treated as Man
+
+
+//// [unionAndIntersectionInference1.js]
+// Repro from #2264
+var y = undefined;
+function destructure(something, haveValue, haveY) {
+    return something === y ? haveY(y) : haveValue(something);
+}
+var value = Math.random() > 0.5 ? 'hey!' : undefined;
+var result = destructure(value, function (text) { return 'string'; }, function (y) { return 'other one'; }); // text: string, y: Y
+// Repro from #4212
+function isVoid(value) {
+    return undefined;
+}
+function isNonVoid(value) {
+    return undefined;
+}
+function foo1(value) {
+    if (isVoid(value)) {
+        value; // value is void
+    }
+    else {
+        value; // value is a
+    }
+}
+function baz1(value) {
+    if (isNonVoid(value)) {
+        value; // value is a
+    }
+    else {
+        value; // value is void
+    }
+}
+function get(x) {
+    return null; // just an example
+}
+var foo;
+get(foo).toUpperCase(); // Ok
+pigify(mbp).oinks; // OK, mbp is treated as Pig
+pigify(mbp).walks; // Ok, mbp is treated as Man