Revert spread-falsy-union/fix spread of primitive

sandersn · sandersn · commit cb8d9d6143c2 · 2017-09-15T16:11:41.000-07:00
Turns out partialising falsy unions wasn't needed -- I was just
returning the wrong thing when spreading primitives.
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -7846,7 +7846,6 @@ namespace ts {
          * and right = the new element to be spread.
          */
         function getSpreadType(left: Type, right: Type): Type {
-            let truthyRight: Type;
             if (left.flags & TypeFlags.Any || right.flags & TypeFlags.Any) {
                 return anyType;
             }
@@ -7860,16 +7859,13 @@ namespace ts {
                 return mapType(left, t => getSpreadType(t, right));
             }
             if (right.flags & TypeFlags.Union) {
-                truthyRight = getTruthyTypeFromFalsyUnion(right as UnionType);
-                if (!truthyRight || truthyRight.flags & TypeFlags.Union) {
-                    return mapType(right, t => getSpreadType(left, t));
-                }
-                else {
-                    right = truthyRight;
-                }
+                return mapType(right, t => getSpreadType(left, t));
             }
-            if (right.flags & (TypeFlags.NonPrimitive | TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.StringLike | TypeFlags.EnumLike)) {
-                return emptyObjectType;
+            if (right.flags & TypeFlags.NonPrimitive) {
+                return nonPrimitiveType;
+            }
+            if (right.flags & (TypeFlags.BooleanLike | TypeFlags.NumberLike | TypeFlags.StringLike | TypeFlags.EnumLike)) {
+                return left;
             }
 
             const members = createSymbolTable();
@@ -7893,7 +7889,7 @@ namespace ts {
                     skippedPrivateMembers.set(rightProp.escapedName, true);
                 }
                 else if (!isClassMethod(rightProp) && !isSetterWithoutGetter) {
-                    members.set(rightProp.escapedName, getSymbolOfSpreadProperty(rightProp, !!truthyRight));
+                    members.set(rightProp.escapedName, getNonReadonlySymbol(rightProp));
                 }
             }
 
@@ -7918,22 +7914,19 @@ namespace ts {
                     }
                 }
                 else {
-                    members.set(leftProp.escapedName, getSymbolOfSpreadProperty(leftProp, /*makeOptional*/ false));
+                    members.set(leftProp.escapedName, getNonReadonlySymbol(leftProp));
                 }
             }
             return createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);
         }
 
-        function getSymbolOfSpreadProperty(prop: Symbol, makeOptional: boolean) {
-            if (!isReadonlySymbol(prop) && (!makeOptional || prop.flags & SymbolFlags.Optional)) {
+        function getNonReadonlySymbol(prop: Symbol) {
+            if (!isReadonlySymbol(prop)) {
                 return prop;
             }
-            const flags = SymbolFlags.Property | (makeOptional ? SymbolFlags.Optional : prop.flags & SymbolFlags.Optional);
+            const flags = SymbolFlags.Property | (prop.flags & SymbolFlags.Optional);
             const result = createSymbol(flags, prop.escapedName);
             result.type = getTypeOfSymbol(prop);
-            if (makeOptional) {
-                result.type = getUnionType([result.type, undefinedType]);
-            }
             result.declarations = prop.declarations;
             result.syntheticOrigin = prop;
             return result;
@@ -7943,13 +7936,6 @@ namespace ts {
             return prop.flags & SymbolFlags.Method && find(prop.declarations, decl => isClassLike(decl.parent));
         }
 
-        function getTruthyTypeFromFalsyUnion(type: UnionType): Type | undefined {
-            const truthy = removeDefinitelyFalsyTypes(type);
-            if (truthy !== type) {
-                return truthy;
-            }
-        }
-
         function createLiteralType(flags: TypeFlags, value: string | number, symbol: Symbol) {
             const type = <LiteralType>createType(flags);
             type.symbol = symbol;
diff --git a/tests/baselines/reference/objectSpread.types b/tests/baselines/reference/objectSpread.types
@@ -247,7 +247,7 @@ function from16326(this: { header: Header }, header: Header, authToken: string):
 >Header : Header
 
     return {
->{        ...this.header,        ...header,        ...authToken && { authToken }    } : { authToken: string; head: string; body: string; }
+>{        ...this.header,        ...header,        ...authToken && { authToken }    } : { head: string; body: string; authToken: string; } | { authToken: string; head: string; body: string; }
 
         ...this.header,
 >this.header : Header
@@ -280,9 +280,9 @@ function conditionalSpreadBoolean(b: boolean) : { x: number, y: number } {
 >13 : 13
 
     o = {
->o = {        ...o,        ...b && { x: 14 }    } : { x: number; y: number; }
+>o = {        ...o,        ...b && { x: 14 }    } : { x: number; y: number; } | { x: number; y: number; }
 >o : { x: number; y: number; }
->{        ...o,        ...b && { x: 14 }    } : { x: number; y: number; }
+>{        ...o,        ...b && { x: 14 }    } : { x: number; y: number; } | { x: number; y: number; }
 
         ...o,
 >o : { x: number; y: number; }
@@ -295,8 +295,8 @@ function conditionalSpreadBoolean(b: boolean) : { x: number, y: number } {
 >14 : 14
     }
     let o2 = { ...b && { x: 21 }}
->o2 : { x?: number | undefined; }
->{ ...b && { x: 21 }} : { x?: number | undefined; }
+>o2 : {} | { x: number; }
+>{ ...b && { x: 21 }} : {} | { x: number; }
 >b && { x: 21 } : false | { x: number; }
 >b : boolean
 >{ x: 21 } : { x: number; }
@@ -321,9 +321,9 @@ function conditionalSpreadNumber(nt: number): { x: number, y: number } {
 >16 : 16
 
     o = {
->o = {        ...o,        ...nt && { x: nt }    } : { x: number; y: number; }
+>o = {        ...o,        ...nt && { x: nt }    } : { x: number; y: number; } | { x: number; y: number; }
 >o : { x: number; y: number; }
->{        ...o,        ...nt && { x: nt }    } : { x: number; y: number; }
+>{        ...o,        ...nt && { x: nt }    } : { x: number; y: number; } | { x: number; y: number; }
 
         ...o,
 >o : { x: number; y: number; }
@@ -336,8 +336,8 @@ function conditionalSpreadNumber(nt: number): { x: number, y: number } {
 >nt : number
     }
     let o2 = { ...nt && { x: nt }}
->o2 : { x?: number | undefined; }
->{ ...nt && { x: nt }} : { x?: number | undefined; }
+>o2 : {} | { x: number; }
+>{ ...nt && { x: nt }} : {} | { x: number; }
 >nt && { x: nt } : 0 | { x: number; }
 >nt : number
 >{ x: nt } : { x: number; }
@@ -362,9 +362,9 @@ function conditionalSpreadString(st: string): { x: string, y: number } {
 >17 : 17
 
     o = {
->o = {        ...o,        ...st && { x: st }    } : { x: string; y: number; }
+>o = {        ...o,        ...st && { x: st }    } : { x: string; y: number; } | { x: string; y: number; }
 >o : { x: string; y: number; }
->{        ...o,        ...st && { x: st }    } : { x: string; y: number; }
+>{        ...o,        ...st && { x: st }    } : { x: string; y: number; } | { x: string; y: number; }
 
         ...o,
 >o : { x: string; y: number; }
@@ -377,8 +377,8 @@ function conditionalSpreadString(st: string): { x: string, y: number } {
 >st : string
     }
     let o2 = { ...st && { x: st }}
->o2 : { x?: string | undefined; }
->{ ...st && { x: st }} : { x?: string | undefined; }
+>o2 : {} | { x: string; }
+>{ ...st && { x: st }} : {} | { x: string; }
 >st && { x: st } : "" | { x: string; }
 >st : string
 >{ x: st } : { x: string; }
@@ -571,8 +571,8 @@ let shortCutted: { a: number, b: string } = { ...o, a }
 
 // non primitive
 let spreadNonPrimitive = { ...<object>{}};
->spreadNonPrimitive : {}
->{ ...<object>{}} : {}
+>spreadNonPrimitive : object
+>{ ...<object>{}} : object
 ><object>{} : object
 >{} : {}
 
diff --git a/tests/baselines/reference/objectSpreadNegative.errors.txt b/tests/baselines/reference/objectSpreadNegative.errors.txt
@@ -15,7 +15,7 @@ tests/cases/conformance/types/spread/objectSpreadNegative.ts(38,19): error TS269
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(43,1): error TS2349: Cannot invoke an expression whose type lacks a call signature. Type '{}' has no compatible call signatures.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(47,12): error TS2339: Property 'b' does not exist on type '{}'.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(53,9): error TS2339: Property 'm' does not exist on type '{ p: number; }'.
-tests/cases/conformance/types/spread/objectSpreadNegative.ts(58,11): error TS2339: Property 'a' does not exist on type '{}'.
+tests/cases/conformance/types/spread/objectSpreadNegative.ts(58,11): error TS2339: Property 'a' does not exist on type 'object'.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(62,14): error TS2698: Spread types may only be created from object types.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(65,14): error TS2698: Spread types may only be created from object types.
 tests/cases/conformance/types/spread/objectSpreadNegative.ts(79,37): error TS2322: Type '{ a: string; b: string; extra: string; }' is not assignable to type 'A'.
@@ -117,7 +117,7 @@ tests/cases/conformance/types/spread/objectSpreadNegative.ts(84,7): error TS2322
     let spreadObj = { ...obj };
     spreadObj.a; // error 'a' is not in {}
               ~
-!!! error TS2339: Property 'a' does not exist on type '{}'.
+!!! error TS2339: Property 'a' does not exist on type 'object'.
     
     // generics
     function f<T, U>(t: T, u: U) {
diff --git a/tests/baselines/reference/spreadUnion2.js b/tests/baselines/reference/spreadUnion2.js
@@ -2,20 +2,20 @@
 declare const undefinedUnion: { a: number } | undefined;
 declare const nullUnion: { b: number } | null;
 
-var o1: { a?: number | undefined };
+var o1: {} | { a: number };
 var o1 = { ...undefinedUnion };
 
-var o2: { b?: number | undefined };
+var o2: {} | { b: number };
 var o2 = { ...nullUnion };
 
-var o3: { a?: number | undefined, b?: number | undefined };
+var o3: {} | { a: number } | { b: number } | { a: number, b: number };
 var o3 = { ...undefinedUnion, ...nullUnion };
 var o3 = { ...nullUnion, ...undefinedUnion };
 
-var o4: { a?: number | undefined };
+var o4: {} | { a: number };
 var o4 = { ...undefinedUnion, ...undefinedUnion };
 
-var o5: { b?: number | undefined };
+var o5: {} | { b: number };
 var o5 = { ...nullUnion, ...nullUnion };
 
 
diff --git a/tests/baselines/reference/spreadUnion2.symbols b/tests/baselines/reference/spreadUnion2.symbols
@@ -7,26 +7,28 @@ declare const nullUnion: { b: number } | null;
 >nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13))
 >b : Symbol(b, Decl(spreadUnion2.ts, 1, 26))
 
-var o1: { a?: number | undefined };
+var o1: {} | { a: number };
 >o1 : Symbol(o1, Decl(spreadUnion2.ts, 3, 3), Decl(spreadUnion2.ts, 4, 3))
->a : Symbol(a, Decl(spreadUnion2.ts, 3, 9))
+>a : Symbol(a, Decl(spreadUnion2.ts, 3, 14))
 
 var o1 = { ...undefinedUnion };
 >o1 : Symbol(o1, Decl(spreadUnion2.ts, 3, 3), Decl(spreadUnion2.ts, 4, 3))
 >undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13))
 
-var o2: { b?: number | undefined };
+var o2: {} | { b: number };
 >o2 : Symbol(o2, Decl(spreadUnion2.ts, 6, 3), Decl(spreadUnion2.ts, 7, 3))
->b : Symbol(b, Decl(spreadUnion2.ts, 6, 9))
+>b : Symbol(b, Decl(spreadUnion2.ts, 6, 14))
 
 var o2 = { ...nullUnion };
 >o2 : Symbol(o2, Decl(spreadUnion2.ts, 6, 3), Decl(spreadUnion2.ts, 7, 3))
 >nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13))
 
-var o3: { a?: number | undefined, b?: number | undefined };
+var o3: {} | { a: number } | { b: number } | { a: number, b: number };
 >o3 : Symbol(o3, Decl(spreadUnion2.ts, 9, 3), Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3))
->a : Symbol(a, Decl(spreadUnion2.ts, 9, 9))
->b : Symbol(b, Decl(spreadUnion2.ts, 9, 33))
+>a : Symbol(a, Decl(spreadUnion2.ts, 9, 14))
+>b : Symbol(b, Decl(spreadUnion2.ts, 9, 30))
+>a : Symbol(a, Decl(spreadUnion2.ts, 9, 46))
+>b : Symbol(b, Decl(spreadUnion2.ts, 9, 57))
 
 var o3 = { ...undefinedUnion, ...nullUnion };
 >o3 : Symbol(o3, Decl(spreadUnion2.ts, 9, 3), Decl(spreadUnion2.ts, 10, 3), Decl(spreadUnion2.ts, 11, 3))
@@ -38,18 +40,18 @@ var o3 = { ...nullUnion, ...undefinedUnion };
 >nullUnion : Symbol(nullUnion, Decl(spreadUnion2.ts, 1, 13))
 >undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13))
 
-var o4: { a?: number | undefined };
+var o4: {} | { a: number };
 >o4 : Symbol(o4, Decl(spreadUnion2.ts, 13, 3), Decl(spreadUnion2.ts, 14, 3))
->a : Symbol(a, Decl(spreadUnion2.ts, 13, 9))
+>a : Symbol(a, Decl(spreadUnion2.ts, 13, 14))
 
 var o4 = { ...undefinedUnion, ...undefinedUnion };
 >o4 : Symbol(o4, Decl(spreadUnion2.ts, 13, 3), Decl(spreadUnion2.ts, 14, 3))
 >undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13))
 >undefinedUnion : Symbol(undefinedUnion, Decl(spreadUnion2.ts, 0, 13))
 
-var o5: { b?: number | undefined };
+var o5: {} | { b: number };
 >o5 : Symbol(o5, Decl(spreadUnion2.ts, 16, 3), Decl(spreadUnion2.ts, 17, 3))
->b : Symbol(b, Decl(spreadUnion2.ts, 16, 9))
+>b : Symbol(b, Decl(spreadUnion2.ts, 16, 14))
 
 var o5 = { ...nullUnion, ...nullUnion };
 >o5 : Symbol(o5, Decl(spreadUnion2.ts, 16, 3), Decl(spreadUnion2.ts, 17, 3))
diff --git a/tests/baselines/reference/spreadUnion2.types b/tests/baselines/reference/spreadUnion2.types
@@ -8,58 +8,60 @@ declare const nullUnion: { b: number } | null;
 >b : number
 >null : null
 
-var o1: { a?: number | undefined };
->o1 : { a?: number | undefined; }
->a : number | undefined
+var o1: {} | { a: number };
+>o1 : {} | { a: number; }
+>a : number
 
 var o1 = { ...undefinedUnion };
->o1 : { a?: number | undefined; }
->{ ...undefinedUnion } : { a?: number | undefined; }
+>o1 : {} | { a: number; }
+>{ ...undefinedUnion } : {} | { a: number; }
 >undefinedUnion : { a: number; } | undefined
 
-var o2: { b?: number | undefined };
->o2 : { b?: number | undefined; }
->b : number | undefined
+var o2: {} | { b: number };
+>o2 : {} | { b: number; }
+>b : number
 
 var o2 = { ...nullUnion };
->o2 : { b?: number | undefined; }
->{ ...nullUnion } : { b?: number | undefined; }
+>o2 : {} | { b: number; }
+>{ ...nullUnion } : {} | { b: number; }
 >nullUnion : { b: number; } | null
 
-var o3: { a?: number | undefined, b?: number | undefined };
->o3 : { a?: number | undefined; b?: number | undefined; }
->a : number | undefined
->b : number | undefined
+var o3: {} | { a: number } | { b: number } | { a: number, b: number };
+>o3 : {} | { a: number; } | { b: number; } | { a: number; b: number; }
+>a : number
+>b : number
+>a : number
+>b : number
 
 var o3 = { ...undefinedUnion, ...nullUnion };
->o3 : { a?: number | undefined; b?: number | undefined; }
->{ ...undefinedUnion, ...nullUnion } : { b?: number | undefined; a?: number | undefined; }
+>o3 : {} | { a: number; } | { b: number; } | { a: number; b: number; }
+>{ ...undefinedUnion, ...nullUnion } : {} | { b: number; } | { a: number; } | { b: number; a: number; }
 >undefinedUnion : { a: number; } | undefined
 >nullUnion : { b: number; } | null
 
 var o3 = { ...nullUnion, ...undefinedUnion };
->o3 : { a?: number | undefined; b?: number | undefined; }
->{ ...nullUnion, ...undefinedUnion } : { a?: number | undefined; b?: number | undefined; }
+>o3 : {} | { a: number; } | { b: number; } | { a: number; b: number; }
+>{ ...nullUnion, ...undefinedUnion } : {} | { a: number; } | { b: number; } | { a: number; b: number; }
 >nullUnion : { b: number; } | null
 >undefinedUnion : { a: number; } | undefined
 
-var o4: { a?: number | undefined };
->o4 : { a?: number | undefined; }
->a : number | undefined
+var o4: {} | { a: number };
+>o4 : {} | { a: number; }
+>a : number
 
 var o4 = { ...undefinedUnion, ...undefinedUnion };
->o4 : { a?: number | undefined; }
->{ ...undefinedUnion, ...undefinedUnion } : { a?: number | undefined; }
+>o4 : {} | { a: number; }
+>{ ...undefinedUnion, ...undefinedUnion } : {} | { a: number; } | { a: number; } | { a: number; }
 >undefinedUnion : { a: number; } | undefined
 >undefinedUnion : { a: number; } | undefined
 
-var o5: { b?: number | undefined };
->o5 : { b?: number | undefined; }
->b : number | undefined
+var o5: {} | { b: number };
+>o5 : {} | { b: number; }
+>b : number
 
 var o5 = { ...nullUnion, ...nullUnion };
->o5 : { b?: number | undefined; }
->{ ...nullUnion, ...nullUnion } : { b?: number | undefined; }
+>o5 : {} | { b: number; }
+>{ ...nullUnion, ...nullUnion } : {} | { b: number; } | { b: number; } | { b: number; }
 >nullUnion : { b: number; } | null
 >nullUnion : { b: number; } | null
 
diff --git a/tests/baselines/reference/spreadUnion3.errors.txt b/tests/baselines/reference/spreadUnion3.errors.txt
diff --git a/tests/cases/conformance/types/spread/spreadUnion2.ts b/tests/cases/conformance/types/spread/spreadUnion2.ts

Original file line number	Diff line number	Diff line change
`@@ -7846,7 +7846,6 @@ namespace ts {`
`7846`	`7846`	`* and right = the new element to be spread.`
`7847`	`7847`	`*/`
`7848`	`7848`	`function getSpreadType(left: Type, right: Type): Type {`
`7849`		`- let truthyRight: Type;`
`7850`	`7849`	`if (left.flags & TypeFlags.Any \|\| right.flags & TypeFlags.Any) {`
`7851`	`7850`	`return anyType;`
`7852`	`7851`	`}`
`@@ -7860,16 +7859,13 @@ namespace ts {`
`7860`	`7859`	`return mapType(left, t => getSpreadType(t, right));`
`7861`	`7860`	`}`
`7862`	`7861`	`if (right.flags & TypeFlags.Union) {`
`7863`		`- truthyRight = getTruthyTypeFromFalsyUnion(right as UnionType);`
`7864`		`- if (!truthyRight \|\| truthyRight.flags & TypeFlags.Union) {`
`7865`		`- return mapType(right, t => getSpreadType(left, t));`
`7866`		`- }`
`7867`		`- else {`
`7868`		`- right = truthyRight;`
`7869`		`- }`
	`7862`	`+ return mapType(right, t => getSpreadType(left, t));`
`7870`	`7863`	`}`
`7871`		`- if (right.flags & (TypeFlags.NonPrimitive \| TypeFlags.BooleanLike \| TypeFlags.NumberLike \| TypeFlags.StringLike \| TypeFlags.EnumLike)) {`
`7872`		`- return emptyObjectType;`
	`7864`	`+ if (right.flags & TypeFlags.NonPrimitive) {`
	`7865`	`+ return nonPrimitiveType;`
	`7866`	`+ }`
	`7867`	`+ if (right.flags & (TypeFlags.BooleanLike \| TypeFlags.NumberLike \| TypeFlags.StringLike \| TypeFlags.EnumLike)) {`
	`7868`	`+ return left;`
`7873`	`7869`	`}`
`7874`	`7870`
`7875`	`7871`	`const members = createSymbolTable();`
`@@ -7893,7 +7889,7 @@ namespace ts {`
`7893`	`7889`	`skippedPrivateMembers.set(rightProp.escapedName, true);`
`7894`	`7890`	`}`
`7895`	`7891`	`else if (!isClassMethod(rightProp) && !isSetterWithoutGetter) {`
`7896`		`- members.set(rightProp.escapedName, getSymbolOfSpreadProperty(rightProp, !!truthyRight));`
	`7892`	`+ members.set(rightProp.escapedName, getNonReadonlySymbol(rightProp));`
`7897`	`7893`	`}`
`7898`	`7894`	`}`
`7899`	`7895`
`@@ -7918,22 +7914,19 @@ namespace ts {`
`7918`	`7914`	`}`
`7919`	`7915`	`}`
`7920`	`7916`	`else {`
`7921`		`- members.set(leftProp.escapedName, getSymbolOfSpreadProperty(leftProp, /makeOptional/ false));`
	`7917`	`+ members.set(leftProp.escapedName, getNonReadonlySymbol(leftProp));`
`7922`	`7918`	`}`
`7923`	`7919`	`}`
`7924`	`7920`	`return createAnonymousType(undefined, members, emptyArray, emptyArray, stringIndexInfo, numberIndexInfo);`
`7925`	`7921`	`}`
`7926`	`7922`
`7927`		`- function getSymbolOfSpreadProperty(prop: Symbol, makeOptional: boolean) {`
`7928`		`- if (!isReadonlySymbol(prop) && (!makeOptional \|\| prop.flags & SymbolFlags.Optional)) {`
	`7923`	`+ function getNonReadonlySymbol(prop: Symbol) {`
	`7924`	`+ if (!isReadonlySymbol(prop)) {`
`7929`	`7925`	`return prop;`
`7930`	`7926`	`}`
`7931`		`- const flags = SymbolFlags.Property \| (makeOptional ? SymbolFlags.Optional : prop.flags & SymbolFlags.Optional);`
	`7927`	`+ const flags = SymbolFlags.Property \| (prop.flags & SymbolFlags.Optional);`
`7932`	`7928`	`const result = createSymbol(flags, prop.escapedName);`
`7933`	`7929`	`result.type = getTypeOfSymbol(prop);`
`7934`		`- if (makeOptional) {`
`7935`		`- result.type = getUnionType([result.type, undefinedType]);`
`7936`		`- }`
`7937`	`7930`	`result.declarations = prop.declarations;`
`7938`	`7931`	`result.syntheticOrigin = prop;`
`7939`	`7932`	`return result;`
`@@ -7943,13 +7936,6 @@ namespace ts {`
`7943`	`7936`	`return prop.flags & SymbolFlags.Method && find(prop.declarations, decl => isClassLike(decl.parent));`
`7944`	`7937`	`}`
`7945`	`7938`
`7946`		`- function getTruthyTypeFromFalsyUnion(type: UnionType): Type \| undefined {`
`7947`		`- const truthy = removeDefinitelyFalsyTypes(type);`
`7948`		`- if (truthy !== type) {`
`7949`		`- return truthy;`
`7950`		`- }`
`7951`		`- }`
`7952`		`-`
`7953`	`7939`	`function createLiteralType(flags: TypeFlags, value: string \| number, symbol: Symbol) {`
`7954`	`7940`	`const type = <LiteralType>createType(flags);`
`7955`	`7941`	`type.symbol = symbol;`