Extract types from object literals instead of using the type checker.

Author: dragomirtitian

src/compiler/checker.ts

@@ -6154,15 +6154,21 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const type = instantiateType(getWidenedType(getRegularTypeOfExpression(expr)), context.mapper);
                 return typeToTypeNodeHelper(type, context);
             },
-            serializeTypeOfDeclaration(syntacticContext, declaration, symbol) {
+            serializeTypeOfDeclaration(syntacticContext, declaration, symbol, widen) {
                 // Get type of the symbol if this is the valid symbol otherwise get type at location
                 const context = syntacticContext as NodeBuilderContext;
                 symbol ??= getSymbolOfDeclaration(declaration);
                 let type = context.enclosingSymbolTypes?.get(getSymbolId(symbol));
                 if (type === undefined) {
-                    type = symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))
-                        ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper)
-                        : errorType;
+                    const symbolType = getTypeOfSymbol(symbol);
+                    if (widen) {
+                        type = instantiateType(getWidenedType(symbolType), context.mapper);
+                    }
+                    else {
+                        type = symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))
+                            ? instantiateType(getWidenedLiteralType(symbolType), context.mapper)
+                            : errorType;
+                    }
                 }
                 const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
                 if (addUndefinedForParameter) {

src/compiler/expressionToTypeNode.ts

@@ -834,14 +834,15 @@ export function createSyntacticTypeNodeBuilder(
         symbol: Symbol | undefined,
         context: SyntacticTypeNodeBuilderContext,
         reportFallback = true,
+        widen = false,
     ) {
         if (reportFallback) {
             context.tracker.reportInferenceFallback(node);
         }
         if (context.noInferenceFallback === true) {
             return factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
         }
-        return resolver.serializeTypeOfDeclaration(context, node, symbol);
+        return resolver.serializeTypeOfDeclaration(context, node, symbol, widen);
     }
 
     function inferExpressionType(node: Expression, context: SyntacticTypeNodeBuilderContext, reportFallback = true, requiresAddingUndefined?: boolean) {
@@ -1058,9 +1059,6 @@ export function createSyntacticTypeNodeBuilder(
             }
             return syntacticResult(inferExpressionType(objectLiteral, context, /*reportFallback*/ false, requiresAddingUndefined));
         }
-        // Disable any inference fallback since we won't actually use the resulting type and we don't want to generate errors
-        const oldNoInferenceFallback = context.noInferenceFallback;
-        context.noInferenceFallback = true;
         const properties: TypeElement[] = [];
         const oldFlags = context.flags;
         context.flags |= NodeBuilderFlags.InObjectTypeLiteral;
@@ -1092,16 +1090,15 @@ export function createSyntacticTypeNodeBuilder(
         if (!(context.flags & NodeBuilderFlags.MultilineObjectLiterals)) {
             setEmitFlags(typeNode, EmitFlags.SingleLine);
         }
-        context.noInferenceFallback = oldNoInferenceFallback;
-        return notImplemented;
+        return syntacticResult(addUndefinedIfNeeded(typeNode, requiresAddingUndefined, objectLiteral, context));
     }
 
     function typeFromObjectLiteralPropertyAssignment(prop: PropertyAssignment, name: PropertyName, context: SyntacticTypeNodeBuilderContext, isConstContext: boolean) {
         const modifiers = isConstContext ?
             [factory.createModifier(SyntaxKind.ReadonlyKeyword)] :
             [];
         const expressionResult = typeFromExpression(prop.initializer, context, isConstContext);
-        const typeNode = expressionResult.type !== undefined ? expressionResult.type : inferTypeOfDeclaration(prop, /*symbol*/ undefined, context, expressionResult.reportFallback);
+        const typeNode = expressionResult.type !== undefined ? expressionResult.type : inferTypeOfDeclaration(prop, /*symbol*/ undefined, context, expressionResult.reportFallback, !isConstContext);
 
         return factory.createPropertySignature(
             modifiers,

src/compiler/types.ts

@@ -10556,7 +10556,7 @@ export interface SyntacticTypeNodeBuilderResolver {
     serializeExistingTypeNode(context: SyntacticTypeNodeBuilderContext, node: TypeNode, addUndefined?: boolean): TypeNode | undefined;
     serializeReturnTypeForSignature(context: SyntacticTypeNodeBuilderContext, signatureDeclaration: SignatureDeclaration | JSDocSignature): TypeNode | undefined;
     serializeTypeOfExpression(context: SyntacticTypeNodeBuilderContext, expr: Expression): TypeNode;
-    serializeTypeOfDeclaration(context: SyntacticTypeNodeBuilderContext, node: HasInferredType | GetAccessorDeclaration | SetAccessorDeclaration, symbol: Symbol | undefined): TypeNode | undefined;
+    serializeTypeOfDeclaration(context: SyntacticTypeNodeBuilderContext, node: HasInferredType | GetAccessorDeclaration | SetAccessorDeclaration, symbol: Symbol | undefined, widen?: boolean): TypeNode | undefined;
     serializeNameOfParameter(context: SyntacticTypeNodeBuilderContext, parameter: ParameterDeclaration): BindingName | string;
     serializeTypeName(context: SyntacticTypeNodeBuilderContext, node: EntityName, isTypeOf?: boolean, typeArguments?: readonly TypeNode[]): TypeNode | undefined;
     serializeEntityName(context: SyntacticTypeNodeBuilderContext, node: EntityNameExpression): Expression | undefined;

tests/baselines/reference/ES5For-of10.types

@@ -3,7 +3,7 @@
 === ES5For-of10.ts ===
 function foo() {
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 
     return { x: 0 };
 >{ x: 0 } : { x: number; }
@@ -19,7 +19,7 @@ for (foo().x of []) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 >[] : undefined[]
@@ -31,7 +31,7 @@ for (foo().x of []) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 >[] : undefined[]
@@ -45,7 +45,7 @@ for (foo().x of []) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 }

tests/baselines/reference/ES5For-of34.types

@@ -3,7 +3,7 @@
 === ES5For-of34.ts ===
 function foo() {
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 
     return { x: 0 };
 >{ x: 0 } : { x: number; }
@@ -19,7 +19,7 @@ for (foo().x of ['a', 'b', 'c']) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 >['a', 'b', 'c'] : string[]
@@ -39,7 +39,7 @@ for (foo().x of ['a', 'b', 'c']) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 }

tests/baselines/reference/ES5For-of8.types

@@ -3,7 +3,7 @@
 === ES5For-of8.ts ===
 function foo() {
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 
     return { x: 0 };
 >{ x: 0 } : { x: number; }
@@ -19,7 +19,7 @@ for (foo().x of ['a', 'b', 'c']) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 >['a', 'b', 'c'] : string[]
@@ -39,7 +39,7 @@ for (foo().x of ['a', 'b', 'c']) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 }

tests/baselines/reference/ES5For-of9.types

@@ -3,7 +3,7 @@
 === ES5For-of9.ts ===
 function foo() {
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 
     return { x: 0 };
 >{ x: 0 } : { x: number; }
@@ -19,7 +19,7 @@ for (foo().x of []) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 >[] : undefined[]
@@ -31,7 +31,7 @@ for (foo().x of []) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
 >[] : undefined[]
@@ -45,7 +45,7 @@ for (foo().x of []) {
 >foo() : { x: number; }
 >      : ^^^^^^^^^^^^^^
 >foo : () => { x: number; }
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^ ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
     }

tests/baselines/reference/ES5For-ofTypeCheck10.types

@@ -8,7 +8,7 @@ class MyStringIterator {
 
     next() {
 >next : () => { done: boolean; value: string; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^^^^^^^^    ^^^^^^^^^^^     ^^^^^^^^^^^
 
         return {
 >{            done: true,            value: ""        } : { done: boolean; value: string; }

tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types

@@ -7,7 +7,7 @@ module A {
 
     export function Point() {
 >Point : () => { x: number; y: number; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^
 
         return { x: 0, y: 0 };
 >{ x: 0, y: 0 } : { x: number; y: number; }
@@ -61,11 +61,11 @@ var fn = A.Point;
 >fn : () => { x: number; y: number; }
 >   : ^^^^^^                         
 >A.Point : () => { x: number; y: number; }
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^
 >A : typeof A
 >  : ^^^^^^^^
 >Point : () => { x: number; y: number; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^
 
 var cl: { x: number; y: number; }
 >cl : { x: number; y: number; }

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types

@@ -29,7 +29,7 @@ module A {
 
         fromCarthesian(p: A.Point) {
 >fromCarthesian : (p: A.Point) => { x: number; y: number; }
->               : ^ ^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>               : ^ ^^       ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^
 >p : A.Point
 >  : ^^^^^^^
 >A : any