Fix bug in checker that created zero length intersections, try constraint based types

Author: weswigham

src/compiler/checker.ts

@@ -7951,6 +7951,15 @@ namespace ts {
                     typeSet.push(type);
                 }
             }
+            // cases for the non-strict null and undefined - if, for example, the interection is _just_ null and/or undefined
+            else if (flags & TypeFlags.Nullable) {
+                if (flags & TypeFlags.Null) {
+                    includes |= TypeIncludes.Null
+                }
+                if (flags & TypeFlags.Undefined) {
+                    includes |= TypeIncludes.Undefined;
+                }
+            }
             return includes;
         }
 
@@ -7988,6 +7997,14 @@ namespace ts {
             if (includes & TypeIncludes.EmptyObject && !(includes & TypeIncludes.ObjectType)) {
                 typeSet.push(emptyObjectType);
             }
+            if (typeSet.length === 0) {
+                if (includes & TypeIncludes.Null) {
+                    typeSet.push(nullType);
+                }
+                if (includes & TypeIncludes.Undefined) {
+                    typeSet.push(undefinedType);
+                }
+            }
             if (typeSet.length === 1) {
                 return typeSet[0];
             }
@@ -7999,6 +8016,7 @@ namespace ts {
                 return getUnionType(map(unionType.types, t => getIntersectionType(replaceElement(typeSet, unionIndex, t))),
                     UnionReduction.Literal, aliasSymbol, aliasTypeArguments);
             }
+            Debug.assert(typeSet.length > 1, "Intersection type must have more than one member");
             const id = getTypeListId(typeSet);
             let type = intersectionTypes.get(id);
             if (!type) {

src/lib/es5.d.ts

@@ -1361,35 +1361,85 @@ type Extract<T, U> = T extends U ? T : never;
 type NonNullable<T> = T extends null | undefined ? never : T;
 
 declare namespace TypeFacts {
+  /**
+   * Effectively replaces a `T` with a `T extends string`
+   */
+  export type IsString<T extends string> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends number`
+   */
+  export type IsNumber<T extends number> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends boolean`
+   */
+  export type IsBoolean<T extends boolean> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends symbol`
+   */
+  export type IsSymbol<T extends symbol> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends object`
+   */
+  export type IsObject<T extends object> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends (...args: any[]) => any`
+   */
+  export type IsFunction<T extends (...args: any[]) => any> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends undefined | void`
+   */
+  export type IsUndefined<T extends undefined | void> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends null`
+   */
+  export type IsNull<T extends null> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends undefined | null | void`
+   */
+  export type IsUndefinedOrNull<T extends undefined | null | void> = T;
+
+  /**
+   * Effectively replaces a `T` with a `T extends false | null | undefined | void | 0 | ""`
+   */
+  export type IsFalsy<T extends false | null | undefined | void | 0 | ""> = T;
+
   /**
    * Include only string from T
    */
-  export type EQString<T> = T extends string ? T : never;
+  export type EQString<T> = T extends IsString<infer U> ? T&U : never;
 
   /**
    * Include only number from T
    */
-  export type EQNumber<T> = T extends number ? T : never;
+  export type EQNumber<T> = T extends IsNumber<infer U> ? T&U : never;
 
   /**
    * Include only boolean from T
    */
-  export type EQBoolean<T> = T extends boolean ? T : never;
+  export type EQBoolean<T> = T extends IsBoolean<infer U> ? T&U : never;
 
   /**
    * Include only symbol from T
    */
-  export type EQSymbol<T> = T extends symbol ? T : never;
+  export type EQSymbol<T> = T extends IsSymbol<infer U> ? T&U : never;
 
   /**
    * Include only object from T
    */
-  export type EQObject<T> = T extends object ? T : never;
+  export type EQObject<T> = T extends IsObject<infer U> ? T&U : never;
 
   /**
    * Include only functions from T
    */
-  export type EQFunction<T> = T extends (...args: any[]) => any ? T : never;
+  export type EQFunction<T> = T extends IsFunction<infer U> ? T&U : never;
 
   /**
    * Exclude only string from T
@@ -1424,17 +1474,17 @@ declare namespace TypeFacts {
   /**
    * Include only undefined from T
    */
-  export type EQUndefined<T> = T extends undefined | void ? T : never;
+  export type EQUndefined<T> = T extends IsUndefined<infer U> ? T&U : never;
 
   /**
    * Include only null from T
    */
-  export type EQNull<T> = T extends null ? T : never;
+  export type EQNull<T> = T extends IsNull<infer U> ? T&U : never;
 
   /**
    * Include only null and undefined from T
    */
-  export type EQUndefinedOrNull<T> = T extends null | undefined | void ? T : never;
+  export type EQUndefinedOrNull<T> = T extends IsUndefinedOrNull<infer U> ? T&U : never;
 
   /**
    * Exclude only undefined from T
@@ -1459,7 +1509,7 @@ declare namespace TypeFacts {
   /**
    * Include falsy from T
    */
-  export type Falsy<T> = T extends false | null | undefined | void | 0 | "" ? T : never;
+  export type Falsy<T> = T extends IsFalsy<infer U> ? T&U : never;
 }
 
 /**