typescript 5.7.0-dev.20240930 → 5.7.0-dev.20241002

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-dev.20240930`;
+var version = `${versionMajorMinor}.0-dev.20241002`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -7567,7 +7567,7 @@ var Diagnostics = {
   Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."),
   Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: diag(9007, 1 /* Error */, "Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9007", "Function must have an explicit return type annotation with --isolatedDeclarations."),
   Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: diag(9008, 1 /* Error */, "Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9008", "Method must have an explicit return type annotation with --isolatedDeclarations."),
-  At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations: diag(9009, 1 /* Error */, "At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations_9009", "At least one accessor must have an explicit return type annotation with --isolatedDeclarations."),
+  At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9009, 1 /* Error */, "At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9009", "At least one accessor must have an explicit type annotation with --isolatedDeclarations."),
   Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9010, 1 /* Error */, "Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9010", "Variable must have an explicit type annotation with --isolatedDeclarations."),
   Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9011, 1 /* Error */, "Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9011", "Parameter must have an explicit type annotation with --isolatedDeclarations."),
   Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations: diag(9012, 1 /* Error */, "Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations_9012", "Property must have an explicit type annotation with --isolatedDeclarations."),
@@ -14196,9 +14196,6 @@ function isVariableLike(node) {
   }
   return false;
 }
-function isVariableLikeOrAccessor(node) {
-  return isVariableLike(node) || isAccessor(node);
-}
 function isVariableDeclarationInVariableStatement(node) {
   return node.parent.kind === 261 /* VariableDeclarationList */ && node.parent.parent.kind === 243 /* VariableStatement */;
 }
@@ -19718,6 +19715,9 @@ function hasInferredType(node) {
     case 260 /* VariableDeclaration */:
     case 277 /* ExportAssignment */:
     case 303 /* PropertyAssignment */:
+    case 304 /* ShorthandPropertyAssignment */:
+    case 341 /* JSDocParameterTag */:
+    case 348 /* JSDocPropertyTag */:
       return true;
     default:
       assertType(node);
@@ -19837,6 +19837,9 @@ function getNodeAtPosition(sourceFile, position, includeJSDoc) {
     current = child;
   }
 }
+function isNewScopeNode(node) {
+  return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -26617,6 +26620,9 @@ function isJsxAttributes(node) {
 function isJsxSpreadAttribute(node) {
   return node.kind === 293 /* JsxSpreadAttribute */;
 }
+function isJsxExpression(node) {
+  return node.kind === 294 /* JsxExpression */;
+}
 function isJsxNamespacedName(node) {
   return node.kind === 295 /* JsxNamespacedName */;
 }
@@ -41871,7 +41877,7 @@ function createBinder() {
   var inStrictMode;
   var inAssignmentPattern = false;
   var symbolCount = 0;
-  var Symbol12;
+  var Symbol13;
   var classifiableNames;
   var unreachableFlow = createFlowNode(
     1 /* Unreachable */,
@@ -41900,7 +41906,7 @@ function createBinder() {
     inStrictMode = bindInStrictMode(file, opts);
     classifiableNames = /* @__PURE__ */ new Set();
     symbolCount = 0;
-    Symbol12 = objectAllocator.getSymbolConstructor();
+    Symbol13 = objectAllocator.getSymbolConstructor();
     Debug.attachFlowNodeDebugInfo(unreachableFlow);
     Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
     if (!file.locals) {
@@ -41951,7 +41957,7 @@ function createBinder() {
   }
   function createSymbol(flags, name) {
     symbolCount++;
-    return new Symbol12(flags, name);
+    return new Symbol13(flags, name);
   }
   function addDeclarationToSymbol(symbol, node, symbolFlags) {
     symbol.flags |= symbolFlags;
@@ -45908,7 +45914,7 @@ function createTypeChecker(host) {
   };
   var cancellationToken;
   var scanner;
-  var Symbol12 = objectAllocator.getSymbolConstructor();
+  var Symbol13 = objectAllocator.getSymbolConstructor();
   var Type7 = objectAllocator.getTypeConstructor();
   var Signature5 = objectAllocator.getSignatureConstructor();
   var typeCount = 0;
@@ -45942,17 +45948,7 @@ function createTypeChecker(host) {
   var checkBinaryExpression = createCheckBinaryExpression();
   var emitResolver = createResolver();
   var nodeBuilder = createNodeBuilder();
-  var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions, {
-    isEntityNameVisible,
-    isExpandoFunctionDeclaration,
-    getAllAccessorDeclarations: getAllAccessorDeclarationsForDeclaration,
-    requiresAddingImplicitUndefined,
-    isUndefinedIdentifierExpression(node) {
-      Debug.assert(isExpressionNode(node));
-      return getSymbolAtLocation(node) === undefinedSymbol;
-    },
-    isDefinitelyReferenceToGlobalSymbolObject
-  });
+  var syntacticNodeBuilder = createSyntacticTypeNodeBuilder(compilerOptions, nodeBuilder.syntacticBuilderResolver);
   var evaluate = createEvaluator({
     evaluateElementAccessExpression,
     evaluateEntityNameExpression
@@ -47097,7 +47093,7 @@ function createTypeChecker(host) {
   }
   function createSymbol(flags, name, checkFlags) {
     symbolCount++;
-    const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
+    const symbol = new Symbol13(flags | 33554432 /* Transient */, name);
     symbol.links = new SymbolLinks();
     symbol.links.checkFlags = checkFlags || 0 /* None */;
     return symbol;
@@ -50110,12 +50106,191 @@ function createTypeChecker(host) {
     return getTypeFromTypeNode(node);
   }
   function createNodeBuilder() {
+    const syntacticBuilderResolver = {
+      evaluateEntityNameExpression,
+      isExpandoFunctionDeclaration,
+      hasLateBindableName,
+      shouldRemoveDeclaration(context, node) {
+        return !(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */);
+      },
+      createRecoveryBoundary(context) {
+        return createRecoveryBoundary(context);
+      },
+      isDefinitelyReferenceToGlobalSymbolObject,
+      getAllAccessorDeclarations: getAllAccessorDeclarationsForDeclaration,
+      requiresAddingImplicitUndefined(declaration, symbol, enclosingDeclaration) {
+        var _a;
+        switch (declaration.kind) {
+          case 172 /* PropertyDeclaration */:
+          case 171 /* PropertySignature */:
+          case 348 /* JSDocPropertyTag */:
+            symbol ?? (symbol = getSymbolOfDeclaration(declaration));
+            const type = getTypeOfSymbol(symbol);
+            return !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declaration) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type));
+          case 169 /* Parameter */:
+          case 341 /* JSDocParameterTag */:
+            return requiresAddingImplicitUndefined(declaration, enclosingDeclaration);
+          default:
+            Debug.assertNever(declaration);
+        }
+      },
+      isOptionalParameter,
+      isUndefinedIdentifierExpression(node) {
+        Debug.assert(isExpressionNode(node));
+        return getSymbolAtLocation(node) === undefinedSymbol;
+      },
+      isEntityNameVisible(context, entityName, shouldComputeAliasToMakeVisible) {
+        return isEntityNameVisible(entityName, context.enclosingDeclaration, shouldComputeAliasToMakeVisible);
+      },
+      serializeExistingTypeNode(context, typeNode, addUndefined) {
+        return serializeExistingTypeNode(context, typeNode, !!addUndefined);
+      },
+      serializeReturnTypeForSignature(syntacticContext, signatureDeclaration) {
+        const context = syntacticContext;
+        const signature = getSignatureFromDeclaration(signatureDeclaration);
+        const returnType = context.enclosingSymbolTypes.get(getSymbolId(getSymbolOfDeclaration(signatureDeclaration))) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
+        return serializeInferredReturnTypeForSignature(context, signature, returnType);
+      },
+      serializeTypeOfExpression(syntacticContext, expr) {
+        const context = syntacticContext;
+        const type = instantiateType(getWidenedType(getRegularTypeOfExpression(expr)), context.mapper);
+        return typeToTypeNodeHelper(type, context);
+      },
+      serializeTypeOfDeclaration(syntacticContext, declaration, symbol) {
+        var _a;
+        const context = syntacticContext;
+        symbol ?? (symbol = getSymbolOfDeclaration(declaration));
+        let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol));
+        if (type === void 0) {
+          type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
+        }
+        const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
+        if (addUndefinedForParameter) {
+          type = getOptionalType(type);
+        }
+        return serializeInferredTypeForDeclaration(symbol, context, type);
+      },
+      serializeNameOfParameter(context, parameter) {
+        return parameterToParameterDeclarationName(getSymbolOfDeclaration(parameter), parameter, context);
+      },
+      serializeEntityName(syntacticContext, node) {
+        const context = syntacticContext;
+        const symbol = getSymbolAtLocation(
+          node,
+          /*ignoreErrors*/
+          true
+        );
+        if (!symbol) return void 0;
+        if (!isValueSymbolAccessible(symbol, context.enclosingDeclaration)) return void 0;
+        return symbolToExpression(symbol, context, 111551 /* Value */ | 1048576 /* ExportValue */);
+      },
+      serializeTypeName(context, node, isTypeOf, typeArguments) {
+        return serializeTypeName(context, node, isTypeOf, typeArguments);
+      },
+      getJsDocPropertyOverride(syntacticContext, jsDocTypeLiteral, jsDocProperty) {
+        const context = syntacticContext;
+        const name = isIdentifier(jsDocProperty.name) ? jsDocProperty.name : jsDocProperty.name.right;
+        const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode2(context, jsDocTypeLiteral), name.escapedText);
+        const overrideTypeNode = typeViaParent && jsDocProperty.typeExpression && getTypeFromTypeNode2(context, jsDocProperty.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
+        return overrideTypeNode;
+      },
+      enterNewScope(context, node) {
+        if (isFunctionLike(node) || isJSDocSignature(node)) {
+          const signature = getSignatureFromDeclaration(node);
+          const expandedParams = getExpandedParameters(
+            signature,
+            /*skipUnionExpanding*/
+            true
+          )[0];
+          return enterNewScope(context, node, expandedParams, signature.typeParameters);
+        } else {
+          const typeParameters = isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
+          return enterNewScope(
+            context,
+            node,
+            /*expandedParams*/
+            void 0,
+            typeParameters
+          );
+        }
+      },
+      markNodeReuse(context, range, location) {
+        return setTextRange2(context, range, location);
+      },
+      trackExistingEntityName(context, node) {
+        return trackExistingEntityName(node, context);
+      },
+      trackComputedName(context, accessExpression) {
+        trackComputedName(accessExpression, context.enclosingDeclaration, context);
+      },
+      getModuleSpecifierOverride(syntacticContext, parent, lit) {
+        const context = syntacticContext;
+        if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
+          let name = lit.text;
+          const nodeSymbol = getNodeLinks(parent).resolvedSymbol;
+          const meaning = parent.isTypeOf ? 111551 /* Value */ : 788968 /* Type */;
+          const parentSymbol = nodeSymbol && isSymbolAccessible(
+            nodeSymbol,
+            context.enclosingDeclaration,
+            meaning,
+            /*shouldComputeAliasesToMakeVisible*/
+            false
+          ).accessibility === 0 /* Accessible */ && lookupSymbolChain(
+            nodeSymbol,
+            context,
+            meaning,
+            /*yieldModuleSymbol*/
+            true
+          )[0];
+          if (parentSymbol && isExternalModuleSymbol(parentSymbol)) {
+            name = getSpecifierForModuleSymbol(parentSymbol, context);
+          } else {
+            const targetFile = getExternalModuleFileFromDeclaration(parent);
+            if (targetFile) {
+              name = getSpecifierForModuleSymbol(targetFile.symbol, context);
+            }
+          }
+          if (name.includes("/node_modules/")) {
+            context.encounteredError = true;
+            if (context.tracker.reportLikelyUnsafeImportRequiredError) {
+              context.tracker.reportLikelyUnsafeImportRequiredError(name);
+            }
+          }
+          return name;
+        }
+      },
+      canReuseTypeNode(context, typeNode) {
+        return canReuseTypeNode(context, typeNode);
+      },
+      canReuseTypeNodeAnnotation(syntacticContext, node, existing, symbol, requiresAddingUndefined) {
+        var _a;
+        const context = syntacticContext;
+        if (context.enclosingDeclaration === void 0) return false;
+        symbol ?? (symbol = getSymbolOfDeclaration(node));
+        let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol));
+        if (type === void 0) {
+          if (symbol.flags & 98304 /* Accessor */) {
+            type = node.kind === 178 /* SetAccessor */ ? getWriteTypeOfSymbol(symbol) : getTypeOfAccessors(symbol);
+          } else if (isValueSignatureDeclaration(node)) {
+            type = getReturnTypeOfSignature(getSignatureFromDeclaration(node));
+          } else {
+            type = getTypeOfSymbol(symbol);
+          }
+        }
+        let annotationType = getTypeFromTypeNodeWithoutContext(existing);
+        if (requiresAddingUndefined && annotationType) {
+          annotationType = getOptionalType(annotationType, !isParameter(node));
+        }
+        return !!annotationType && typeNodeIsEquivalentToType(node, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type);
+      }
+    };
     return {
+      syntacticBuilderResolver,
       typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
       typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -50163,65 +50338,6 @@ function createTypeChecker(host) {
       }
       return range;
     }
-    function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
-      const restoreFlags = saveRestoreFlags(context);
-      if (expr && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
-        syntacticNodeBuilder.serializeTypeOfExpression(expr, context, addUndefined);
-      }
-      context.internalFlags |= 2 /* NoSyntacticPrinter */;
-      const result = expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined);
-      restoreFlags();
-      return result;
-    }
-    function expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined) {
-      if (expr) {
-        const typeNode = isAssertionExpression(expr) ? expr.type : isJSDocTypeAssertion(expr) ? getJSDocTypeAssertionType(expr) : void 0;
-        if (typeNode && !isConstTypeReference(typeNode)) {
-          const result = tryReuseExistingTypeNode(context, typeNode, type, expr.parent, addUndefined);
-          if (result) {
-            return result;
-          }
-        }
-      }
-      if (addUndefined) {
-        type = getOptionalType(type);
-      }
-      return typeToTypeNodeHelper(type, context);
-    }
-    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined) {
-      const originalType = type;
-      if (addUndefined) {
-        type = getOptionalType(type, !isParameter(host2));
-      }
-      const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2);
-      if (clone) {
-        if (addUndefined && containsNonMissingUndefinedType(type) && !someType(getTypeFromTypeNode2(context, typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
-          return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
-        }
-        return clone;
-      }
-      if (addUndefined && originalType !== type) {
-        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2);
-        if (cloneMissingUndefined) {
-          return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
-        }
-      }
-      return void 0;
-    }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType = getTypeFromTypeNode2(
-      context,
-      existing,
-      /*noMappedTypes*/
-      true
-    )) {
-      if (annotationType && typeNodeIsEquivalentToType(host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-        const result = tryReuseExistingTypeNodeHelper(context, existing);
-        if (result) {
-          return result;
-        }
-      }
-      return void 0;
-    }
     function symbolToNode(symbol, context, meaning) {
       if (context.internalFlags & 1 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
@@ -50245,6 +50361,7 @@ function createTypeChecker(host) {
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
         encounteredError: false,
+        suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
         visitedTypes: void 0,
         symbolDepth: void 0,
@@ -50263,6 +50380,7 @@ function createTypeChecker(host) {
         typeParameterNames: void 0,
         typeParameterNamesByText: void 0,
         typeParameterNamesByTextNextNameCount: void 0,
+        enclosingSymbolTypes: /* @__PURE__ */ new Map(),
         mapper: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
@@ -50272,6 +50390,19 @@ function createTypeChecker(host) {
       }
       return context.encounteredError ? void 0 : resultingNode;
     }
+    function addSymbolTypeToContext(context, symbol, type) {
+      const id = getSymbolId(symbol);
+      const oldType = context.enclosingSymbolTypes.get(id);
+      context.enclosingSymbolTypes.set(id, type);
+      return restore;
+      function restore() {
+        if (oldType) {
+          context.enclosingSymbolTypes.set(id, oldType);
+        } else {
+          context.enclosingSymbolTypes.delete(id);
+        }
+      }
+    }
     function saveRestoreFlags(context) {
       const flags = context.flags;
       const internalFlags = context.internalFlags;
@@ -50683,8 +50814,8 @@ function createTypeChecker(host) {
           if (isInstantiationExpressionType) {
             const instantiationExpressionType = type2;
             const existing = instantiationExpressionType.node;
-            if (isTypeQueryNode(existing)) {
-              const typeNode = tryReuseExistingNonParameterTypeNode(context, existing, type2);
+            if (isTypeQueryNode(existing) && getTypeFromTypeNode2(context, existing) === type2) {
+              const typeNode = syntacticNodeBuilder.tryReuseExistingTypeNode(context, existing);
               if (typeNode) {
                 return typeNode;
               }
@@ -51435,14 +51566,85 @@ function createTypeChecker(host) {
       cleanup == null ? void 0 : cleanup();
       return node;
     }
-    function isNewScopeNode(node) {
-      return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
-    }
-    function getTypeParametersInScope(node) {
-      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
-    }
-    function getParametersInScope(node) {
-      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0;
+    function createRecoveryBoundary(context) {
+      if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
+        cancellationToken.throwIfCancellationRequested();
+      }
+      let trackedSymbols;
+      let unreportedErrors;
+      let hadError = false;
+      const oldTracker = context.tracker;
+      const oldTrackedSymbols = context.trackedSymbols;
+      context.trackedSymbols = void 0;
+      const oldEncounteredError = context.encounteredError;
+      context.tracker = new SymbolTrackerImpl(context, {
+        ...oldTracker.inner,
+        reportCyclicStructureError() {
+          markError(() => oldTracker.reportCyclicStructureError());
+        },
+        reportInaccessibleThisError() {
+          markError(() => oldTracker.reportInaccessibleThisError());
+        },
+        reportInaccessibleUniqueSymbolError() {
+          markError(() => oldTracker.reportInaccessibleUniqueSymbolError());
+        },
+        reportLikelyUnsafeImportRequiredError(specifier) {
+          markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier));
+        },
+        reportNonSerializableProperty(name) {
+          markError(() => oldTracker.reportNonSerializableProperty(name));
+        },
+        reportPrivateInBaseOfClassExpression(propertyName) {
+          markError(() => oldTracker.reportPrivateInBaseOfClassExpression(propertyName));
+        },
+        trackSymbol(sym, decl, meaning) {
+          (trackedSymbols ?? (trackedSymbols = [])).push([sym, decl, meaning]);
+          return false;
+        },
+        moduleResolverHost: context.tracker.moduleResolverHost
+      }, context.tracker.moduleResolverHost);
+      return {
+        startRecoveryScope,
+        finalizeBoundary,
+        markError,
+        hadError: () => hadError
+      };
+      function markError(unreportedError) {
+        hadError = true;
+        if (unreportedError) {
+          (unreportedErrors ?? (unreportedErrors = [])).push(unreportedError);
+        }
+      }
+      function startRecoveryScope() {
+        const trackedSymbolsTop = (trackedSymbols == null ? void 0 : trackedSymbols.length) ?? 0;
+        const unreportedErrorsTop = (unreportedErrors == null ? void 0 : unreportedErrors.length) ?? 0;
+        return () => {
+          hadError = false;
+          if (trackedSymbols) {
+            trackedSymbols.length = trackedSymbolsTop;
+          }
+          if (unreportedErrors) {
+            unreportedErrors.length = unreportedErrorsTop;
+          }
+        };
+      }
+      function finalizeBoundary() {
+        context.tracker = oldTracker;
+        context.trackedSymbols = oldTrackedSymbols;
+        context.encounteredError = oldEncounteredError;
+        unreportedErrors == null ? void 0 : unreportedErrors.forEach((fn) => fn());
+        if (hadError) {
+          return false;
+        }
+        trackedSymbols == null ? void 0 : trackedSymbols.forEach(
+          ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol(
+            symbol,
+            enclosingDeclaration,
+            meaning
+          )
+        );
+        return true;
+      }
     }
     function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters, mapper) {
       const cleanupContext = cloneNodeBuilderContext(context);
@@ -51585,7 +51787,7 @@ function createTypeChecker(host) {
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
-      return typeNode && tryReuseExistingNonParameterTypeNode(context, typeNode, type) || typeToTypeNodeHelper(type, context);
+      return typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
     }
     function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) {
       const constraintNode = constraint && typeToTypeNodeHelperWithPossibleReusableTypeNode(constraint, getConstraintDeclaration(type), context);
@@ -52207,35 +52409,34 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
+    function serializeInferredTypeForDeclaration(symbol, context, type) {
+      if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === context.enclosingFile))) {
+        context.flags |= 1048576 /* AllowUniqueESSymbolType */;
+      }
+      const result = typeToTypeNodeHelper(type, context);
+      return result;
+    }
     function serializeTypeForDeclaration(context, declaration, type, symbol) {
-      var _a, _b;
+      var _a;
+      let result;
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
-      const enclosingDeclaration = context.enclosingDeclaration;
-      const restoreFlags = saveRestoreFlags(context);
-      if (declaration && hasInferredType(declaration) && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
-        syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context);
-      }
-      context.internalFlags |= 2 /* NoSyntacticPrinter */;
-      if (enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */)) {
-        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol);
-        if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
-          const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          const addUndefined = addUndefinedForParameter || !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declWithExistingAnnotation) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type));
-          const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
-          if (result2) {
-            restoreFlags();
-            return result2;
-          }
+      const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
+      if (decl) {
+        if (isAccessor(decl)) {
+          result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
+        } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
+          const restore = addSymbolTypeToContext(context, symbol, type);
+          result = syntacticNodeBuilder.serializeTypeOfDeclaration(decl, symbol, context);
+          restore();
         }
       }
-      if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
-        context.flags |= 1048576 /* AllowUniqueESSymbolType */;
+      if (!result) {
+        if (addUndefinedForParameter) {
+          type = getOptionalType(type);
+        }
+        result = serializeInferredTypeForDeclaration(symbol, context, type);
       }
-      const decl = declaration ?? symbol.valueDeclaration ?? ((_b = symbol.declarations) == null ? void 0 : _b[0]);
-      const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
-      const result = expressionOrTypeToTypeNode(context, expr, type, addUndefinedForParameter);
-      restoreFlags();
-      return result;
+      return result ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
     }
     function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) {
       if (typeFromTypeNode === type) {
@@ -52258,37 +52459,32 @@ function createTypeChecker(host) {
       if (suppressAny) context.flags &= ~256 /* SuppressAnyReturnType */;
       let returnTypeNode;
       const returnType = getReturnTypeOfSignature(signature);
-      if (returnType && !(suppressAny && isTypeAny(returnType))) {
-        if (signature.declaration && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
-          syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, context);
+      if (!(suppressAny && isTypeAny(returnType))) {
+        if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+          const declarationSymbol = getSymbolOfDeclaration(signature.declaration);
+          const restore = addSymbolTypeToContext(context, declarationSymbol, returnType);
+          returnTypeNode = syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, declarationSymbol, context);
+          restore();
+        }
+        if (!returnTypeNode) {
+          returnTypeNode = serializeInferredReturnTypeForSignature(context, signature, returnType);
         }
-        context.internalFlags |= 2 /* NoSyntacticPrinter */;
-        returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
-      } else if (!suppressAny) {
+      }
+      if (!returnTypeNode && !suppressAny) {
         returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
       }
       restoreFlags();
       return returnTypeNode;
     }
-    function serializeReturnTypeForSignatureWorker(context, signature) {
+    function serializeInferredReturnTypeForSignature(context, signature, returnType) {
+      const oldSuppressReportInferenceFallback = context.suppressReportInferenceFallback;
+      context.suppressReportInferenceFallback = true;
       const typePredicate = getTypePredicateOfSignature(signature);
-      const type = getReturnTypeOfSignature(signature);
-      if (context.enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
-        const annotation = getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
-        if (annotation) {
-          const result = tryReuseExistingTypeNode(context, annotation, type, context.enclosingDeclaration);
-          if (result) {
-            return result;
-          }
-        }
-      }
-      if (typePredicate) {
-        return typePredicateToTypePredicateNodeHelper(typePredicate, context);
-      }
-      const expr = signature.declaration && getPossibleTypeNodeReuseExpression(signature.declaration);
-      return expressionOrTypeToTypeNode(context, expr, type);
+      const returnTypeNode = typePredicate ? typePredicateToTypePredicateNodeHelper(context.mapper ? instantiateTypePredicate(typePredicate, context.mapper) : typePredicate, context) : typeToTypeNodeHelper(returnType, context);
+      context.suppressReportInferenceFallback = oldSuppressReportInferenceFallback;
+      return returnTypeNode;
     }
-    function trackExistingEntityName(node, context) {
+    function trackExistingEntityName(node, context, enclosingDeclaration = context.enclosingDeclaration) {
       let introducesError = false;
       const leftmost = getFirstIdentifier(node);
       if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) {
@@ -52339,7 +52535,7 @@ function createTypeChecker(host) {
         if (
           // Check for unusable parameters symbols
           symAtLocation === unknownSymbol || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node
-          symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it shoudl point to the same reference
+          symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it should point to the same reference
           symAtLocation && sym && !getSymbolIfSameReference(getExportSymbolOfValueSymbolIfExported(symAtLocation), sym)
         ) {
           if (symAtLocation !== unknownSymbol) {
@@ -52360,7 +52556,7 @@ function createTypeChecker(host) {
         if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the current context if they are are resolvable
         !isDeclarationName(node) && isSymbolAccessible(
           sym,
-          context.enclosingDeclaration,
+          enclosingDeclaration,
           meaning,
           /*shouldComputeAliasesToMakeVisible*/
           false
@@ -52368,7 +52564,7 @@ function createTypeChecker(host) {
           context.tracker.reportInferenceFallback(node);
           introducesError = true;
         } else {
-          context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
+          context.tracker.trackSymbol(sym, enclosingDeclaration, meaning);
         }
         return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
       }
@@ -52412,6 +52608,15 @@ function createTypeChecker(host) {
       return symbolToTypeNode(resolvedSymbol, context, meaning, typeArguments);
     }
     function canReuseTypeNode(context, existing) {
+      const type = getTypeFromTypeNode2(
+        context,
+        existing,
+        /*noMappedTypes*/
+        true
+      );
+      if (!type) {
+        return false;
+      }
       if (isInJSFile(existing)) {
         if (isLiteralImportTypeNode(existing)) {
           void getTypeFromImportTypeNode(existing);
@@ -52421,29 +52626,16 @@ function createTypeChecker(host) {
           !(length(existing.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))));
         }
       }
-      if (isThisTypeNode(existing)) {
-        if (context.mapper === void 0) return true;
-        const type = getTypeFromTypeNode2(
-          context,
-          existing,
-          /*noMappedTypes*/
-          true
-        );
-        return !!type;
-      }
       if (isTypeReferenceNode(existing)) {
         if (isConstTypeReference(existing)) return false;
-        const type = getTypeFromTypeReference(existing);
         const symbol = getNodeLinks(existing).resolvedSymbol;
         if (!symbol) return false;
         if (symbol.flags & 262144 /* TypeParameter */) {
-          const type2 = getDeclaredTypeOfSymbol(symbol);
-          if (context.mapper && getMappedType(type2, context.mapper) !== type2) {
-            return false;
-          }
+          const declaredType = getDeclaredTypeOfSymbol(symbol);
+          return !(context.mapper && getMappedType(declaredType, context.mapper) !== declaredType);
         }
         if (isInJSDoc(existing)) {
-          return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && symbol.flags & 788968 /* Type */;
+          return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && !!(symbol.flags & 788968 /* Type */);
         }
       }
       if (isTypeOperatorNode(existing) && existing.operator === 158 /* UniqueKeyword */ && existing.type.kind === 155 /* SymbolKeyword */) {
@@ -52452,511 +52644,15 @@ function createTypeChecker(host) {
       }
       return true;
     }
-    function serializeExistingTypeNode(context, typeNode) {
+    function serializeExistingTypeNode(context, typeNode, addUndefined) {
       const type = getTypeFromTypeNode2(context, typeNode);
-      return typeToTypeNodeHelper(type, context);
-    }
-    function tryReuseExistingTypeNodeHelper(context, existing) {
-      if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
-        cancellationToken.throwIfCancellationRequested();
-      }
-      let hadError = false;
-      const { finalizeBoundary, startRecoveryScope } = createRecoveryBoundary();
-      const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
-      if (!finalizeBoundary()) {
-        return void 0;
-      }
-      context.approximateLength += existing.end - existing.pos;
-      return transformed;
-      function visitExistingNodeTreeSymbols(node) {
-        if (hadError) return node;
-        const recover = startRecoveryScope();
-        const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
-        const result = visitExistingNodeTreeSymbolsWorker(node);
-        onExitNewScope == null ? void 0 : onExitNewScope();
-        if (hadError) {
-          if (isTypeNode(node) && !isTypePredicateNode(node)) {
-            recover();
-            return serializeExistingTypeNode(context, node);
-          }
-          return node;
-        }
-        return result ? setTextRange2(context, result, node) : void 0;
-      }
-      function createRecoveryBoundary() {
-        let trackedSymbols;
-        let unreportedErrors;
-        const oldTracker = context.tracker;
-        const oldTrackedSymbols = context.trackedSymbols;
-        context.trackedSymbols = void 0;
-        const oldEncounteredError = context.encounteredError;
-        context.tracker = new SymbolTrackerImpl(context, {
-          ...oldTracker.inner,
-          reportCyclicStructureError() {
-            markError(() => oldTracker.reportCyclicStructureError());
-          },
-          reportInaccessibleThisError() {
-            markError(() => oldTracker.reportInaccessibleThisError());
-          },
-          reportInaccessibleUniqueSymbolError() {
-            markError(() => oldTracker.reportInaccessibleUniqueSymbolError());
-          },
-          reportLikelyUnsafeImportRequiredError(specifier) {
-            markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier));
-          },
-          reportNonSerializableProperty(name) {
-            markError(() => oldTracker.reportNonSerializableProperty(name));
-          },
-          trackSymbol(sym, decl, meaning) {
-            (trackedSymbols ?? (trackedSymbols = [])).push([sym, decl, meaning]);
-            return false;
-          },
-          moduleResolverHost: context.tracker.moduleResolverHost
-        }, context.tracker.moduleResolverHost);
-        return {
-          startRecoveryScope: startRecoveryScope2,
-          finalizeBoundary: finalizeBoundary2
-        };
-        function markError(unreportedError) {
-          hadError = true;
-          (unreportedErrors ?? (unreportedErrors = [])).push(unreportedError);
-        }
-        function startRecoveryScope2() {
-          const trackedSymbolsTop = (trackedSymbols == null ? void 0 : trackedSymbols.length) ?? 0;
-          const unreportedErrorsTop = (unreportedErrors == null ? void 0 : unreportedErrors.length) ?? 0;
-          return () => {
-            hadError = false;
-            if (trackedSymbols) {
-              trackedSymbols.length = trackedSymbolsTop;
-            }
-            if (unreportedErrors) {
-              unreportedErrors.length = unreportedErrorsTop;
-            }
-          };
-        }
-        function finalizeBoundary2() {
-          context.tracker = oldTracker;
-          context.trackedSymbols = oldTrackedSymbols;
-          context.encounteredError = oldEncounteredError;
-          unreportedErrors == null ? void 0 : unreportedErrors.forEach((fn) => fn());
-          if (hadError) {
-            return false;
-          }
-          trackedSymbols == null ? void 0 : trackedSymbols.forEach(
-            ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol(
-              symbol,
-              enclosingDeclaration,
-              meaning
-            )
-          );
-          return true;
-        }
-      }
-      function onEnterNewScope(node) {
-        return enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
-      }
-      function tryVisitSimpleTypeNode(node) {
-        const innerNode = skipTypeParentheses(node);
-        switch (innerNode.kind) {
-          case 183 /* TypeReference */:
-            return tryVisitTypeReference(innerNode);
-          case 186 /* TypeQuery */:
-            return tryVisitTypeQuery(innerNode);
-          case 199 /* IndexedAccessType */:
-            return tryVisitIndexedAccess(innerNode);
-          case 198 /* TypeOperator */:
-            const typeOperatorNode = innerNode;
-            if (typeOperatorNode.operator === 143 /* KeyOfKeyword */) {
-              return tryVisitKeyOf(typeOperatorNode);
-            }
-        }
-        return visitNode(node, visitExistingNodeTreeSymbols, isTypeNode);
-      }
-      function tryVisitIndexedAccess(node) {
-        const resultObjectType = tryVisitSimpleTypeNode(node.objectType);
-        if (resultObjectType === void 0) {
-          return void 0;
-        }
-        return factory.updateIndexedAccessTypeNode(node, resultObjectType, visitNode(node.indexType, visitExistingNodeTreeSymbols, isTypeNode));
-      }
-      function tryVisitKeyOf(node) {
-        Debug.assertEqual(node.operator, 143 /* KeyOfKeyword */);
-        const type = tryVisitSimpleTypeNode(node.type);
-        if (type === void 0) {
-          return void 0;
-        }
-        return factory.updateTypeOperatorNode(node, type);
-      }
-      function tryVisitTypeQuery(node) {
-        const { introducesError, node: exprName } = trackExistingEntityName(node.exprName, context);
-        if (!introducesError) {
-          return factory.updateTypeQueryNode(
-            node,
-            exprName,
-            visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode)
-          );
-        }
-        const serializedName = serializeTypeName(
-          context,
-          node.exprName,
-          /*isTypeOf*/
-          true
-        );
-        if (serializedName) {
-          return setTextRange2(context, serializedName, node.exprName);
-        }
-      }
-      function tryVisitTypeReference(node) {
-        if (canReuseTypeNode(context, node)) {
-          const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
-          const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
-          if (!introducesError) {
-            const updated = factory.updateTypeReferenceNode(
-              node,
-              newName,
-              typeArguments
-            );
-            return setTextRange2(context, updated, node);
-          } else {
-            const serializedName = serializeTypeName(
-              context,
-              node.typeName,
-              /*isTypeOf*/
-              false,
-              typeArguments
-            );
-            if (serializedName) {
-              return setTextRange2(context, serializedName, node.typeName);
-            }
-          }
-        }
-      }
-      function visitExistingNodeTreeSymbolsWorker(node) {
-        if (isJSDocTypeExpression(node)) {
-          return visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode);
-        }
-        if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
-          return factory.createKeywordTypeNode(133 /* AnyKeyword */);
-        }
-        if (isJSDocUnknownType(node)) {
-          return factory.createKeywordTypeNode(159 /* UnknownKeyword */);
-        }
-        if (isJSDocNullableType(node)) {
-          return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createLiteralTypeNode(factory.createNull())]);
-        }
-        if (isJSDocOptionalType(node)) {
-          return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
-        }
-        if (isJSDocNonNullableType(node)) {
-          return visitNode(node.type, visitExistingNodeTreeSymbols);
-        }
-        if (isJSDocVariadicType(node)) {
-          return factory.createArrayTypeNode(visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
-        }
-        if (isJSDocTypeLiteral(node)) {
-          return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => {
-            const name = visitNode(isIdentifier(t.name) ? t.name : t.name.right, visitExistingNodeTreeSymbols, isIdentifier);
-            const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode2(context, node), name.escapedText);
-            const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode2(context, t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
-            return factory.createPropertySignature(
-              /*modifiers*/
-              void 0,
-              name,
-              t.isBracketed || t.typeExpression && isJSDocOptionalType(t.typeExpression.type) ? factory.createToken(58 /* QuestionToken */) : void 0,
-              overrideTypeNode || t.typeExpression && visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */)
-            );
-          }));
-        }
-        if (isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "") {
-          return setOriginalNode(factory.createKeywordTypeNode(133 /* AnyKeyword */), node);
-        }
-        if ((isExpressionWithTypeArguments(node) || isTypeReferenceNode(node)) && isJSDocIndexSignature(node)) {
-          return factory.createTypeLiteralNode([factory.createIndexSignature(
-            /*modifiers*/
-            void 0,
-            [factory.createParameterDeclaration(
-              /*modifiers*/
-              void 0,
-              /*dotDotDotToken*/
-              void 0,
-              "x",
-              /*questionToken*/
-              void 0,
-              visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols, isTypeNode)
-            )],
-            visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols, isTypeNode)
-          )]);
-        }
-        if (isJSDocFunctionType(node)) {
-          if (isJSDocConstructSignature(node)) {
-            let newTypeNode;
-            return factory.createConstructorTypeNode(
-              /*modifiers*/
-              void 0,
-              visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration),
-              mapDefined(node.parameters, (p, i) => p.name && isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode = p.type, void 0) : factory.createParameterDeclaration(
-                /*modifiers*/
-                void 0,
-                getEffectiveDotDotDotForParameter(p),
-                setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
-                factory.cloneNode(p.questionToken),
-                visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
-                /*initializer*/
-                void 0
-              )),
-              visitNode(newTypeNode || node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */)
-            );
-          } else {
-            return factory.createFunctionTypeNode(
-              visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration),
-              map(node.parameters, (p, i) => factory.createParameterDeclaration(
-                /*modifiers*/
-                void 0,
-                getEffectiveDotDotDotForParameter(p),
-                setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
-                factory.cloneNode(p.questionToken),
-                visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
-                /*initializer*/
-                void 0
-              )),
-              visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */)
-            );
-          }
-        }
-        if (isThisTypeNode(node)) {
-          if (canReuseTypeNode(context, node)) {
-            return node;
-          }
-          hadError = true;
-          return node;
-        }
-        if (isTypeParameterDeclaration(node)) {
-          return factory.updateTypeParameterDeclaration(
-            node,
-            visitNodes2(node.modifiers, visitExistingNodeTreeSymbols, isModifier),
-            setTextRange2(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node),
-            visitNode(node.constraint, visitExistingNodeTreeSymbols, isTypeNode),
-            visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode)
-          );
-        }
-        if (isIndexedAccessTypeNode(node)) {
-          const result = tryVisitIndexedAccess(node);
-          if (!result) {
-            hadError = true;
-            return node;
-          }
-          return result;
-        }
-        if (isTypeReferenceNode(node)) {
-          const result = tryVisitTypeReference(node);
-          if (result) {
-            return result;
-          }
-          hadError = true;
-          return node;
-        }
-        if (isLiteralImportTypeNode(node)) {
-          const nodeSymbol = getNodeLinks(node).resolvedSymbol;
-          if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic
-          (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
-          !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
-            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode2(context, node), context), node);
-          }
-          return factory.updateImportTypeNode(
-            node,
-            factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)),
-            visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
-            visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
-            visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
-            node.isTypeOf
-          );
-        }
-        if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
-          if (!hasDynamicName(node)) {
-            return visitEachChild2(node, visitExistingNodeTreeSymbols);
-          }
-          if (!(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
-            return void 0;
-          }
-        }
-        if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
-          let visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
-          if (visited === node) {
-            visited = setTextRange2(context, factory.cloneNode(node), node);
-          }
-          visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
-          if (isParameter(node)) {
-            visited.modifiers = void 0;
-          }
-          return visited;
-        }
-        if (isTypeQueryNode(node)) {
-          const result = tryVisitTypeQuery(node);
-          if (!result) {
-            hadError = true;
-            return node;
-          }
-          return result;
-        }
-        if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) {
-          const { node: result, introducesError } = trackExistingEntityName(node.expression, context);
-          if (!introducesError) {
-            return factory.updateComputedPropertyName(node, result);
-          } else {
-            const type = getWidenedType(getRegularTypeOfExpression(node.expression));
-            const computedPropertyNameType = typeToTypeNodeHelper(type, context);
-            let literal;
-            if (isLiteralTypeNode(computedPropertyNameType)) {
-              literal = computedPropertyNameType.literal;
-            } else {
-              const evaluated = evaluateEntityNameExpression(node.expression);
-              const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral(
-                evaluated.value,
-                /*isSingleQuote*/
-                void 0
-              ) : typeof evaluated.value === "number" ? factory.createNumericLiteral(
-                evaluated.value,
-                /*numericLiteralFlags*/
-                0
-              ) : void 0;
-              if (!literalNode) {
-                if (isImportTypeNode(computedPropertyNameType)) {
-                  trackComputedName(node.expression, context.enclosingDeclaration, context);
-                }
-                return node;
-              }
-              literal = literalNode;
-            }
-            if (literal.kind === 11 /* StringLiteral */ && isIdentifierText(literal.text, getEmitScriptTarget(compilerOptions))) {
-              return factory.createIdentifier(literal.text);
-            }
-            if (literal.kind === 9 /* NumericLiteral */ && !literal.text.startsWith("-")) {
-              return literal;
-            }
-            return factory.updateComputedPropertyName(node, literal);
-          }
-        }
-        if (isTypePredicateNode(node)) {
-          let parameterName;
-          if (isIdentifier(node.parameterName)) {
-            const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
-            hadError = hadError || introducesError;
-            parameterName = result;
-          } else {
-            parameterName = factory.cloneNode(node.parameterName);
-          }
-          return factory.updateTypePredicateNode(node, factory.cloneNode(node.assertsModifier), parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
-        }
-        if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
-          const visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
-          const clone = setTextRange2(context, visited === node ? factory.cloneNode(node) : visited, node);
-          const flags = getEmitFlags(clone);
-          setEmitFlags(clone, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
-          return clone;
-        }
-        if (isStringLiteral(node) && !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */) && !node.singleQuote) {
-          const clone = factory.cloneNode(node);
-          clone.singleQuote = true;
-          return clone;
-        }
-        if (isConditionalTypeNode(node)) {
-          const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
-          const disposeScope = onEnterNewScope(node);
-          const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
-          const trueType2 = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
-          disposeScope();
-          const falseType2 = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode);
-          return factory.updateConditionalTypeNode(
-            node,
-            checkType,
-            extendType,
-            trueType2,
-            falseType2
-          );
-        }
-        if (isTypeOperatorNode(node)) {
-          if (node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) {
-            if (!canReuseTypeNode(context, node)) {
-              hadError = true;
-              return node;
-            }
-          } else if (node.operator === 143 /* KeyOfKeyword */) {
-            const result = tryVisitKeyOf(node);
-            if (!result) {
-              hadError = true;
-              return node;
-            }
-            return result;
-          }
-        }
-        return visitEachChild2(node, visitExistingNodeTreeSymbols);
-        function visitEachChild2(node2, visitor) {
-          const nonlocalNode = !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(node2);
-          return visitEachChild(
-            node2,
-            visitor,
-            /*context*/
-            void 0,
-            nonlocalNode ? visitNodesWithoutCopyingPositions : void 0
-          );
-        }
-        function visitNodesWithoutCopyingPositions(nodes, visitor, test, start, count) {
-          let result = visitNodes2(nodes, visitor, test, start, count);
-          if (result) {
-            if (result.pos !== -1 || result.end !== -1) {
-              if (result === nodes) {
-                result = factory.createNodeArray(nodes.slice(), nodes.hasTrailingComma);
-              }
-              setTextRangePosEnd(result, -1, -1);
-            }
-          }
-          return result;
-        }
-        function getEffectiveDotDotDotForParameter(p) {
-          return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0);
-        }
-        function getNameForJSDocFunctionParameter(p, index) {
-          return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
-        }
-        function rewriteModuleSpecifier2(parent, lit) {
-          if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
-            let name = lit.text;
-            const nodeSymbol = getNodeLinks(node).resolvedSymbol;
-            const meaning = parent.isTypeOf ? 111551 /* Value */ : 788968 /* Type */;
-            const parentSymbol = nodeSymbol && isSymbolAccessible(
-              nodeSymbol,
-              context.enclosingDeclaration,
-              meaning,
-              /*shouldComputeAliasesToMakeVisible*/
-              false
-            ).accessibility === 0 /* Accessible */ && lookupSymbolChain(
-              nodeSymbol,
-              context,
-              meaning,
-              /*yieldModuleSymbol*/
-              true
-            )[0];
-            if (parentSymbol && isExternalModuleSymbol(parentSymbol)) {
-              name = getSpecifierForModuleSymbol(parentSymbol, context);
-            } else {
-              const targetFile = getExternalModuleFileFromDeclaration(parent);
-              if (targetFile) {
-                name = getSpecifierForModuleSymbol(targetFile.symbol, context);
-              }
-            }
-            if (name.includes("/node_modules/")) {
-              context.encounteredError = true;
-              if (context.tracker.reportLikelyUnsafeImportRequiredError) {
-                context.tracker.reportLikelyUnsafeImportRequiredError(name);
-              }
-            }
-            if (name !== lit.text) {
-              return setOriginalNode(factory.createStringLiteral(name), lit);
-            }
-          }
-          return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
+      if (addUndefined && !someType(type, (t) => !!(t.flags & 32768 /* Undefined */)) && canReuseTypeNode(context, typeNode)) {
+        const clone = syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode);
+        if (clone) {
+          return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
         }
       }
+      return typeToTypeNodeHelper(type, context);
     }
     function symbolTableToDeclarationStatements(symbolTable, context) {
       var _a;
@@ -53433,13 +53129,7 @@ function createTypeChecker(host) {
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
-        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && tryReuseExistingNonParameterTypeNode(
-          context,
-          jsdocAliasDecl.typeExpression.type,
-          aliasType,
-          /*host*/
-          void 0
-        ) || typeToTypeNodeHelper(aliasType, context);
+        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && syntacticNodeBuilder.tryReuseExistingTypeNode(context, jsdocAliasDecl.typeExpression.type) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
             factory.createTypeAliasDeclaration(
@@ -53672,7 +53362,7 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode2(context, a)) || typeToTypeNodeHelper(getTypeFromTypeNode2(context, a), context))
+            map(e.typeArguments, (a) => syntacticNodeBuilder.tryReuseExistingTypeNode(context, a) || typeToTypeNodeHelper(getTypeFromTypeNode2(context, a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -54159,7 +53849,7 @@ function createTypeChecker(host) {
       }
       function makeSerializePropertySymbol(createProperty2, methodKind, useAccessors) {
         return function serializePropertySymbol(p, isStatic2, baseType) {
-          var _a2, _b, _c, _d, _e;
+          var _a2, _b, _c, _d, _e, _f;
           const modifierFlags = getDeclarationModifierFlagsFromSymbol(p);
           const isPrivate = !!(modifierFlags & 2 /* Private */);
           if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
@@ -54189,6 +53879,7 @@ function createTypeChecker(host) {
               });
               Debug.assert(!!setter);
               const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : void 0;
+              const setterDeclaration = (_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor);
               result.push(setTextRange2(
                 context,
                 factory.createSetAccessorDeclaration(
@@ -54202,39 +53893,28 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(
-                      context,
-                      /*declaration*/
-                      void 0,
-                      getWriteTypeOfSymbol(p),
-                      p
-                    )
+                    isPrivate ? void 0 : serializeTypeForDeclaration(context, setterDeclaration, getWriteTypeOfSymbol(p), p)
                   )],
                   /*body*/
                   void 0
                 ),
-                ((_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor)) || firstPropertyLikeDecl
+                setterDeclaration ?? firstPropertyLikeDecl
               ));
             }
             if (p.flags & 32768 /* GetAccessor */) {
               const isPrivate2 = modifierFlags & 2 /* Private */;
+              const getterDeclaration = (_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor);
               result.push(setTextRange2(
                 context,
                 factory.createGetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(
-                    context,
-                    /*declaration*/
-                    void 0,
-                    getTypeOfSymbol(p),
-                    p
-                  ),
+                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getterDeclaration, getTypeOfSymbol(p), p),
                   /*body*/
                   void 0
                 ),
-                ((_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor)) || firstPropertyLikeDecl
+                getterDeclaration ?? firstPropertyLikeDecl
               ));
             }
             return result;
@@ -54245,19 +53925,13 @@ function createTypeChecker(host) {
                 factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(
-                  context,
-                  /*declaration*/
-                  void 0,
-                  getWriteTypeOfSymbol(p),
-                  p
-                ),
+                isPrivate ? void 0 : serializeTypeForDeclaration(context, (_d = p.declarations) == null ? void 0 : _d.find(isSetAccessorDeclaration), getWriteTypeOfSymbol(p), p),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
                 void 0
               ),
-              ((_d = p.declarations) == null ? void 0 : _d.find(or(isPropertyDeclaration, isVariableDeclaration))) || firstPropertyLikeDecl
+              ((_e = p.declarations) == null ? void 0 : _e.find(or(isPropertyDeclaration, isVariableDeclaration))) || firstPropertyLikeDecl
             );
           }
           if (p.flags & (8192 /* Method */ | 16 /* Function */)) {
@@ -54275,7 +53949,7 @@ function createTypeChecker(host) {
                   /*initializer*/
                   void 0
                 ),
-                ((_e = p.declarations) == null ? void 0 : _e.find(isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0]
+                ((_f = p.declarations) == null ? void 0 : _f.find(isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0]
               );
             }
             const results2 = [];
@@ -54318,7 +53992,7 @@ function createTypeChecker(host) {
               return [];
             }
             if (baseSigs.length === signatures.length) {
-              let failed = false;
+              let failed2 = false;
               for (let i = 0; i < baseSigs.length; i++) {
                 if (!compareSignaturesIdentical(
                   signatures[i],
@@ -54331,11 +54005,11 @@ function createTypeChecker(host) {
                   true,
                   compareTypesIdentical
                 )) {
-                  failed = true;
+                  failed2 = true;
                   break;
                 }
               }
-              if (!failed) {
+              if (!failed2) {
                 return [];
               }
             }
@@ -55508,7 +55182,7 @@ function createTypeChecker(host) {
         /*reportErrors*/
         false
       ) : unknownType;
-      return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
+      return addOptionality(getWidenedLiteralTypeForInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
     }
     if (isBindingPattern(element.name)) {
       return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors2);
@@ -75647,12 +75321,12 @@ function createTypeChecker(host) {
       }
     }
     return result;
-    function addImplementationSuccessElaboration(failed, diagnostic) {
+    function addImplementationSuccessElaboration(failed2, diagnostic) {
       var _a, _b;
       const oldCandidatesForArgumentError = candidatesForArgumentError;
       const oldCandidateForArgumentArityError = candidateForArgumentArityError;
       const oldCandidateForTypeArgumentError = candidateForTypeArgumentError;
-      const failedSignatureDeclarations = ((_b = (_a = failed.declaration) == null ? void 0 : _a.symbol) == null ? void 0 : _b.declarations) || emptyArray;
+      const failedSignatureDeclarations = ((_b = (_a = failed2.declaration) == null ? void 0 : _a.symbol) == null ? void 0 : _b.declarations) || emptyArray;
       const isOverload = failedSignatureDeclarations.length > 1;
       const implDecl = isOverload ? find(failedSignatureDeclarations, (d) => isFunctionLikeDeclaration(d) && nodeIsPresent(d.body)) : void 0;
       if (implDecl) {
@@ -79571,7 +79245,7 @@ function createTypeChecker(host) {
     return createTupleType(elementTypes, elementFlags, type.target.readonly);
   }
   function widenTypeInferredFromInitializer(declaration, type) {
-    const widened = getCombinedNodeFlagsCached(declaration) & 6 /* Constant */ || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
+    const widened = getWidenedLiteralTypeForInitializer(declaration, type);
     if (isInJSFile(declaration)) {
       if (isEmptyLiteralType(widened)) {
         reportImplicitAny(declaration, anyType);
@@ -79583,6 +79257,9 @@ function createTypeChecker(host) {
     }
     return widened;
   }
+  function getWidenedLiteralTypeForInitializer(declaration, type) {
+    return getCombinedNodeFlagsCached(declaration) & 6 /* Constant */ || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
+  }
   function isLiteralOfContextualType(candidateType, contextualType) {
     if (contextualType) {
       if (contextualType.flags & 3145728 /* UnionOrIntersection */) {
@@ -86971,16 +86648,12 @@ function createTypeChecker(host) {
     }
   }
   function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
-    const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
+    const declaration = getParseTreeNode(declarationIn, hasInferredType);
     if (!declaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
-    const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
-  }
-  function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
-    return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
+    return nodeBuilder.serializeTypeForDeclaration(declaration, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
   function getAllAccessorDeclarationsForDeclaration(accessor) {
     accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
@@ -86997,52 +86670,19 @@ function createTypeChecker(host) {
       getAccessor
     };
   }
-  function getPossibleTypeNodeReuseExpression(declaration) {
-    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarationsForDeclaration(declaration.parent).getAccessor) : void 0;
-  }
-  function getSingleReturnExpression(declaration) {
-    let candidateExpr;
-    if (declaration && !nodeIsMissing(declaration.body)) {
-      if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0;
-      const body = declaration.body;
-      if (body && isBlock(body)) {
-        forEachReturnStatement(body, (s) => {
-          if (!candidateExpr) {
-            candidateExpr = s.expression;
-          } else {
-            candidateExpr = void 0;
-            return true;
-          }
-        });
-      } else {
-        candidateExpr = body;
-      }
-    }
-    return candidateExpr;
-  }
   function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
+    return nodeBuilder.serializeReturnTypeForSignature(signatureDeclaration, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
     if (!expr) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    const type = getWidenedType(getRegularTypeOfExpression(expr));
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      expr,
-      type,
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      internalFlags,
-      tracker
-    );
+    return nodeBuilder.serializeTypeForExpression(expr, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
   function hasGlobalName(name) {
     return globals.has(escapeLeadingUnderscores(name));
@@ -87193,22 +86833,6 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getNonlocalEffectiveReturnTypeAnnotationNode(node) {
-    const direct = getEffectiveReturnTypeNode(node);
-    if (direct) {
-      return direct;
-    }
-    if (node.kind === 177 /* GetAccessor */) {
-      const other = getAllAccessorDeclarationsForDeclaration(node).setAccessor;
-      if (other) {
-        const param = getSetAccessorValueParameter(other);
-        if (param) {
-          return getEffectiveTypeAnnotationNode(param);
-        }
-      }
-    }
-    return void 0;
-  }
   function createResolver() {
     return {
       getReferencedExportContainer,
@@ -89305,7 +88929,8 @@ var SymbolTrackerImpl = class _SymbolTrackerImpl {
   }
   reportInferenceFallback(node) {
     var _a;
-    if ((_a = this.inner) == null ? void 0 : _a.reportInferenceFallback) {
+    if (((_a = this.inner) == null ? void 0 : _a.reportInferenceFallback) && !this.context.suppressReportInferenceFallback) {
+      this.onDiagnosticReported();
       this.inner.reportInferenceFallback(node);
     }
   }
@@ -112375,8 +112000,8 @@ function createGetIsolatedDeclarationErrors(resolver) {
     [219 /* ArrowFunction */]: Diagnostics.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
     [174 /* MethodDeclaration */]: Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
     [180 /* ConstructSignature */]: Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
-    [177 /* GetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
-    [178 /* SetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations,
+    [177 /* GetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
+    [178 /* SetAccessor */]: Diagnostics.At_least_one_accessor_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
     [169 /* Parameter */]: Diagnostics.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
     [260 /* VariableDeclaration */]: Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
     [172 /* PropertyDeclaration */]: Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations,
@@ -112944,7 +112569,7 @@ function transformDeclarations(context) {
       );
     }
   }
-  function ensureParameter(p, modifierMask, type) {
+  function ensureParameter(p, modifierMask) {
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
       oldDiag = getSymbolAccessibilityDiagnostic;
@@ -112958,7 +112583,6 @@ function transformDeclarations(context) {
       resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(58 /* QuestionToken */) : void 0,
       ensureType(
         p,
-        type || p.type,
         /*ignorePrivate*/
         true
       ),
@@ -112983,44 +112607,34 @@ function transformDeclarations(context) {
     }
     return void 0;
   }
-  function ensureType(node, type, ignorePrivate) {
+  function ensureType(node, ignorePrivate) {
     if (!ignorePrivate && hasEffectiveModifier(node, 2 /* Private */)) {
       return;
     }
     if (shouldPrintWithInitializer(node)) {
       return;
     }
-    const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node, enclosingDeclaration);
-    if (type && !shouldAddImplicitUndefined) {
-      return visitNode(type, visitDeclarationSubtree, isTypeNode);
+    if (!isExportAssignment(node) && !isBindingElement(node) && node.type && (!isParameter(node) || !resolver.requiresAddingImplicitUndefined(node, enclosingDeclaration))) {
+      return visitNode(node.type, visitDeclarationSubtree, isTypeNode);
     }
+    const oldErrorNameNode = errorNameNode;
     errorNameNode = node.name;
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
       oldDiag = getSymbolAccessibilityDiagnostic;
-      getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
+      if (canProduceDiagnostics(node)) {
+        getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
+      }
     }
     let typeNode;
-    switch (node.kind) {
-      case 169 /* Parameter */:
-      case 171 /* PropertySignature */:
-      case 172 /* PropertyDeclaration */:
-      case 208 /* BindingElement */:
-      case 260 /* VariableDeclaration */:
-        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
-        break;
-      case 262 /* FunctionDeclaration */:
-      case 180 /* ConstructSignature */:
-      case 173 /* MethodSignature */:
-      case 174 /* MethodDeclaration */:
-      case 177 /* GetAccessor */:
-      case 179 /* CallSignature */:
-        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
-        break;
-      default:
-        Debug.assertNever(node);
+    if (hasInferredType(node)) {
+      typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+    } else if (isFunctionLike(node)) {
+      typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+    } else {
+      Debug.assertNever(node);
     }
-    errorNameNode = void 0;
+    errorNameNode = oldErrorNameNode;
     if (!suppressNewDiagnosticContexts) {
       getSymbolAccessibilityDiagnostic = oldDiag;
     }
@@ -113090,13 +112704,7 @@ function transformDeclarations(context) {
       if (!isPrivate) {
         const valueParameter = getSetAccessorValueParameter(input);
         if (valueParameter) {
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
-          newValueParameter = ensureParameter(
-            valueParameter,
-            /*modifierMask*/
-            void 0,
-            accessorType
-          );
+          newValueParameter = ensureParameter(valueParameter);
         }
       }
       if (!newValueParameter) {
@@ -113347,7 +112955,7 @@ function transformDeclarations(context) {
             input,
             ensureTypeParams(input, input.typeParameters),
             updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            ensureType(input)
           ));
         case 176 /* Constructor */: {
           const ctor = factory2.createConstructorDeclaration(
@@ -113374,7 +112982,7 @@ function transformDeclarations(context) {
             input.questionToken,
             ensureTypeParams(input, input.typeParameters),
             updateParamsList(input, input.parameters),
-            ensureType(input, input.type),
+            ensureType(input),
             /*body*/
             void 0
           );
@@ -113387,13 +112995,12 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           return cleanup(factory2.updateGetAccessorDeclaration(
             input,
             ensureModifiers(input),
             input.name,
             updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-            ensureType(input, accessorType),
+            ensureType(input),
             /*body*/
             void 0
           ));
@@ -113426,7 +113033,7 @@ function transformDeclarations(context) {
             ensureModifiers(input),
             input.name,
             input.questionToken,
-            ensureType(input, input.type),
+            ensureType(input),
             ensureNoInitializer(input)
           ));
         case 171 /* PropertySignature */:
@@ -113441,7 +113048,7 @@ function transformDeclarations(context) {
             ensureModifiers(input),
             input.name,
             input.questionToken,
-            ensureType(input, input.type)
+            ensureType(input)
           ));
         case 173 /* MethodSignature */: {
           if (isPrivateIdentifier(input.name)) {
@@ -113457,7 +113064,7 @@ function transformDeclarations(context) {
             input.questionToken,
             ensureTypeParams(input, input.typeParameters),
             updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            ensureType(input)
           ));
         }
         case 179 /* CallSignature */: {
@@ -113466,7 +113073,7 @@ function transformDeclarations(context) {
               input,
               ensureTypeParams(input, input.typeParameters),
               updateParamsList(input, input.parameters),
-              ensureType(input, input.type)
+              ensureType(input)
             )
           );
         }
@@ -113489,7 +113096,7 @@ function transformDeclarations(context) {
             input.name,
             /*exclamationToken*/
             void 0,
-            ensureType(input, input.type),
+            ensureType(input),
             ensureNoInitializer(input)
           ));
         }
@@ -113613,11 +113220,12 @@ function transformDeclarations(context) {
             errorNode: input
           });
           errorFallbackNode = input;
+          const type = ensureType(input);
           const varDecl = factory2.createVariableDeclaration(
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
+            type,
             /*initializer*/
             void 0
           );
@@ -113714,7 +113322,7 @@ function transformDeclarations(context) {
           input.name,
           ensureTypeParams(input, input.typeParameters),
           updateParamsList(input, input.parameters),
-          ensureType(input, input.type),
+          ensureType(input),
           /*body*/
           void 0
         ));
@@ -113882,7 +113490,7 @@ function transformDeclarations(context) {
                   ensureModifiers(param),
                   param.name,
                   param.questionToken,
-                  ensureType(param, param.type),
+                  ensureType(param),
                   ensureNoInitializer(param)
                 ),
                 param
@@ -113903,11 +113511,7 @@ function transformDeclarations(context) {
                   elem.name,
                   /*questionOrExclamationToken*/
                   void 0,
-                  ensureType(
-                    elem,
-                    /*type*/
-                    void 0
-                  ),
+                  ensureType(elem),
                   /*initializer*/
                   void 0
                 ));
@@ -114058,11 +113662,7 @@ function transformDeclarations(context) {
           e.name,
           /*exclamationToken*/
           void 0,
-          ensureType(
-            e,
-            /*type*/
-            void 0
-          ),
+          ensureType(e),
           /*initializer*/
           void 0
         );
@@ -114112,18 +113712,6 @@ function transformDeclarations(context) {
     }
     return maskModifierFlags(node, mask, additions);
   }
-  function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) {
-    let accessorType = getTypeAnnotationFromAccessor(node);
-    if (!accessorType && node !== accessors.firstAccessor) {
-      accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor);
-      getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.firstAccessor);
-    }
-    if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) {
-      accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor);
-      getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor);
-    }
-    return accessorType;
-  }
   function transformHeritageClauses(nodes) {
     return factory2.createNodeArray(filter(
       map(nodes, (clause) => factory2.updateHeritageClause(
@@ -114159,11 +113747,6 @@ function maskModifierFlags(node, modifierMask = 131071 /* All */ ^ 1 /* Public *
   }
   return flags;
 }
-function getTypeAnnotationFromAccessor(accessor) {
-  if (accessor) {
-    return accessor.kind === 177 /* GetAccessor */ ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : void 0;
-  }
-}
 function canHaveLiteralInitializer(node) {
   switch (node.kind) {
     case 172 /* PropertyDeclaration */:
@@ -120174,7 +119757,7 @@ function resolveTripleslashReference(moduleName, containingFile) {
 }
 function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) {
   let commonPathComponents;
-  const failed = forEach(fileNames, (sourceFile) => {
+  const failed2 = forEach(fileNames, (sourceFile) => {
     const sourcePathComponents = getNormalizedPathComponents(sourceFile, currentDirectory);
     sourcePathComponents.pop();
     if (!commonPathComponents) {
@@ -120195,7 +119778,7 @@ function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, ge
       commonPathComponents.length = sourcePathComponents.length;
     }
   });
-  if (failed) {
+  if (failed2) {
     return "";
   }
   if (!commonPathComponents) {
@@ -131427,39 +131010,518 @@ function writeConfigFile(sys2, reportDiagnostic, options, fileNames) {
 }
 
 // src/compiler/expressionToTypeNode.ts
+function syntacticResult(type, reportFallback = true) {
+  return { type, reportFallback };
+}
+var notImplemented2 = syntacticResult(
+  /*type*/
+  void 0,
+  /*reportFallback*/
+  false
+);
+var alreadyReported = syntacticResult(
+  /*type*/
+  void 0,
+  /*reportFallback*/
+  false
+);
+var failed = syntacticResult(
+  /*type*/
+  void 0,
+  /*reportFallback*/
+  true
+);
 function createSyntacticTypeNodeBuilder(options, resolver) {
   const strictNullChecks = getStrictOptionValue(options, "strictNullChecks");
   return {
-    typeFromExpression,
     serializeTypeOfDeclaration,
     serializeReturnTypeForSignature,
-    serializeTypeOfExpression
+    serializeTypeOfExpression,
+    serializeTypeOfAccessor,
+    tryReuseExistingTypeNode(context, existing) {
+      if (!resolver.canReuseTypeNode(context, existing)) {
+        return void 0;
+      }
+      return tryReuseExistingTypeNode(context, existing);
+    }
   };
-  function serializeExistingTypeAnnotation(type, addUndefined) {
-    return type !== void 0 && (!addUndefined || type && canAddUndefined(type)) ? true : void 0;
+  function reuseNode(context, node, range = node) {
+    return node === void 0 ? void 0 : resolver.markNodeReuse(context, node.flags & 16 /* Synthesized */ ? node : factory.cloneNode(node), range ?? node);
+  }
+  function tryReuseExistingTypeNode(context, existing) {
+    const { finalizeBoundary, startRecoveryScope, hadError, markError } = resolver.createRecoveryBoundary(context);
+    const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
+    if (!finalizeBoundary()) {
+      return void 0;
+    }
+    context.approximateLength += existing.end - existing.pos;
+    return transformed;
+    function visitExistingNodeTreeSymbols(node) {
+      if (hadError()) return node;
+      const recover = startRecoveryScope();
+      const onExitNewScope = isNewScopeNode(node) ? resolver.enterNewScope(context, node) : void 0;
+      const result = visitExistingNodeTreeSymbolsWorker(node);
+      onExitNewScope == null ? void 0 : onExitNewScope();
+      if (hadError()) {
+        if (isTypeNode(node) && !isTypePredicateNode(node)) {
+          recover();
+          return resolver.serializeExistingTypeNode(context, node);
+        }
+        return node;
+      }
+      return result ? resolver.markNodeReuse(context, result, node) : void 0;
+    }
+    function tryVisitSimpleTypeNode(node) {
+      const innerNode = skipTypeParentheses(node);
+      switch (innerNode.kind) {
+        case 183 /* TypeReference */:
+          return tryVisitTypeReference(innerNode);
+        case 186 /* TypeQuery */:
+          return tryVisitTypeQuery(innerNode);
+        case 199 /* IndexedAccessType */:
+          return tryVisitIndexedAccess(innerNode);
+        case 198 /* TypeOperator */:
+          const typeOperatorNode = innerNode;
+          if (typeOperatorNode.operator === 143 /* KeyOfKeyword */) {
+            return tryVisitKeyOf(typeOperatorNode);
+          }
+      }
+      return visitNode(node, visitExistingNodeTreeSymbols, isTypeNode);
+    }
+    function tryVisitIndexedAccess(node) {
+      const resultObjectType = tryVisitSimpleTypeNode(node.objectType);
+      if (resultObjectType === void 0) {
+        return void 0;
+      }
+      return factory.updateIndexedAccessTypeNode(node, resultObjectType, visitNode(node.indexType, visitExistingNodeTreeSymbols, isTypeNode));
+    }
+    function tryVisitKeyOf(node) {
+      Debug.assertEqual(node.operator, 143 /* KeyOfKeyword */);
+      const type = tryVisitSimpleTypeNode(node.type);
+      if (type === void 0) {
+        return void 0;
+      }
+      return factory.updateTypeOperatorNode(node, type);
+    }
+    function tryVisitTypeQuery(node) {
+      const { introducesError, node: exprName } = resolver.trackExistingEntityName(context, node.exprName);
+      if (!introducesError) {
+        return factory.updateTypeQueryNode(
+          node,
+          exprName,
+          visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode)
+        );
+      }
+      const serializedName = resolver.serializeTypeName(
+        context,
+        node.exprName,
+        /*isTypeOf*/
+        true
+      );
+      if (serializedName) {
+        return resolver.markNodeReuse(context, serializedName, node.exprName);
+      }
+    }
+    function tryVisitTypeReference(node) {
+      if (resolver.canReuseTypeNode(context, node)) {
+        const { introducesError, node: newName } = resolver.trackExistingEntityName(context, node.typeName);
+        const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
+        if (!introducesError) {
+          const updated = factory.updateTypeReferenceNode(
+            node,
+            newName,
+            typeArguments
+          );
+          return resolver.markNodeReuse(context, updated, node);
+        } else {
+          const serializedName = resolver.serializeTypeName(
+            context,
+            node.typeName,
+            /*isTypeOf*/
+            false,
+            typeArguments
+          );
+          if (serializedName) {
+            return resolver.markNodeReuse(context, serializedName, node.typeName);
+          }
+        }
+      }
+    }
+    function visitExistingNodeTreeSymbolsWorker(node) {
+      var _a;
+      if (isJSDocTypeExpression(node)) {
+        return visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode);
+      }
+      if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
+        return factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      }
+      if (isJSDocUnknownType(node)) {
+        return factory.createKeywordTypeNode(159 /* UnknownKeyword */);
+      }
+      if (isJSDocNullableType(node)) {
+        return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createLiteralTypeNode(factory.createNull())]);
+      }
+      if (isJSDocOptionalType(node)) {
+        return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode), factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
+      }
+      if (isJSDocNonNullableType(node)) {
+        return visitNode(node.type, visitExistingNodeTreeSymbols);
+      }
+      if (isJSDocVariadicType(node)) {
+        return factory.createArrayTypeNode(visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
+      }
+      if (isJSDocTypeLiteral(node)) {
+        return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => {
+          const name = visitNode(isIdentifier(t.name) ? t.name : t.name.right, visitExistingNodeTreeSymbols, isIdentifier);
+          const overrideTypeNode = resolver.getJsDocPropertyOverride(context, node, t);
+          return factory.createPropertySignature(
+            /*modifiers*/
+            void 0,
+            name,
+            t.isBracketed || t.typeExpression && isJSDocOptionalType(t.typeExpression.type) ? factory.createToken(58 /* QuestionToken */) : void 0,
+            overrideTypeNode || t.typeExpression && visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */)
+          );
+        }));
+      }
+      if (isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "") {
+        return setOriginalNode(factory.createKeywordTypeNode(133 /* AnyKeyword */), node);
+      }
+      if ((isExpressionWithTypeArguments(node) || isTypeReferenceNode(node)) && isJSDocIndexSignature(node)) {
+        return factory.createTypeLiteralNode([factory.createIndexSignature(
+          /*modifiers*/
+          void 0,
+          [factory.createParameterDeclaration(
+            /*modifiers*/
+            void 0,
+            /*dotDotDotToken*/
+            void 0,
+            "x",
+            /*questionToken*/
+            void 0,
+            visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols, isTypeNode)
+          )],
+          visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols, isTypeNode)
+        )]);
+      }
+      if (isJSDocFunctionType(node)) {
+        if (isJSDocConstructSignature(node)) {
+          let newTypeNode;
+          return factory.createConstructorTypeNode(
+            /*modifiers*/
+            void 0,
+            visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration),
+            mapDefined(node.parameters, (p, i) => p.name && isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode = p.type, void 0) : factory.createParameterDeclaration(
+              /*modifiers*/
+              void 0,
+              getEffectiveDotDotDotForParameter(p),
+              resolver.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
+              factory.cloneNode(p.questionToken),
+              visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
+              /*initializer*/
+              void 0
+            )),
+            visitNode(newTypeNode || node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */)
+          );
+        } else {
+          return factory.createFunctionTypeNode(
+            visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols, isTypeParameterDeclaration),
+            map(node.parameters, (p, i) => factory.createParameterDeclaration(
+              /*modifiers*/
+              void 0,
+              getEffectiveDotDotDotForParameter(p),
+              resolver.markNodeReuse(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
+              factory.cloneNode(p.questionToken),
+              visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
+              /*initializer*/
+              void 0
+            )),
+            visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode) || factory.createKeywordTypeNode(133 /* AnyKeyword */)
+          );
+        }
+      }
+      if (isThisTypeNode(node)) {
+        if (resolver.canReuseTypeNode(context, node)) {
+          return node;
+        }
+        markError();
+        return node;
+      }
+      if (isTypeParameterDeclaration(node)) {
+        const { node: newName } = resolver.trackExistingEntityName(context, node.name);
+        return factory.updateTypeParameterDeclaration(
+          node,
+          visitNodes2(node.modifiers, visitExistingNodeTreeSymbols, isModifier),
+          // resolver.markNodeReuse(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node),
+          newName,
+          visitNode(node.constraint, visitExistingNodeTreeSymbols, isTypeNode),
+          visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode)
+        );
+      }
+      if (isIndexedAccessTypeNode(node)) {
+        const result = tryVisitIndexedAccess(node);
+        if (!result) {
+          markError();
+          return node;
+        }
+        return result;
+      }
+      if (isTypeReferenceNode(node)) {
+        const result = tryVisitTypeReference(node);
+        if (result) {
+          return result;
+        }
+        markError();
+        return node;
+      }
+      if (isLiteralImportTypeNode(node)) {
+        if (((_a = node.attributes) == null ? void 0 : _a.token) === 132 /* AssertKeyword */) {
+          markError();
+          return node;
+        }
+        if (!resolver.canReuseTypeNode(context, node)) {
+          return resolver.serializeExistingTypeNode(context, node);
+        }
+        return factory.updateImportTypeNode(
+          node,
+          factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)),
+          visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
+          visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
+          visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
+          node.isTypeOf
+        );
+      }
+      if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !resolver.hasLateBindableName(node)) {
+        if (!hasDynamicName(node)) {
+          return visitEachChild2(node, visitExistingNodeTreeSymbols);
+        }
+        if (resolver.shouldRemoveDeclaration(context, node)) {
+          return void 0;
+        }
+      }
+      if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
+        let visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
+        if (visited === node) {
+          visited = resolver.markNodeReuse(context, factory.cloneNode(node), node);
+        }
+        visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+        if (isParameter(node)) {
+          visited.modifiers = void 0;
+        }
+        return visited;
+      }
+      if (isTypeQueryNode(node)) {
+        const result = tryVisitTypeQuery(node);
+        if (!result) {
+          markError();
+          return node;
+        }
+        return result;
+      }
+      if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) {
+        const { node: result, introducesError } = resolver.trackExistingEntityName(context, node.expression);
+        if (!introducesError) {
+          return factory.updateComputedPropertyName(node, result);
+        } else {
+          const computedPropertyNameType = resolver.serializeTypeOfExpression(context, node.expression);
+          let literal;
+          if (isLiteralTypeNode(computedPropertyNameType)) {
+            literal = computedPropertyNameType.literal;
+          } else {
+            const evaluated = resolver.evaluateEntityNameExpression(node.expression);
+            const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral(
+              evaluated.value,
+              /*isSingleQuote*/
+              void 0
+            ) : typeof evaluated.value === "number" ? factory.createNumericLiteral(
+              evaluated.value,
+              /*numericLiteralFlags*/
+              0
+            ) : void 0;
+            if (!literalNode) {
+              if (isImportTypeNode(computedPropertyNameType)) {
+                resolver.trackComputedName(context, node.expression);
+              }
+              return node;
+            }
+            literal = literalNode;
+          }
+          if (literal.kind === 11 /* StringLiteral */ && isIdentifierText(literal.text, getEmitScriptTarget(options))) {
+            return factory.createIdentifier(literal.text);
+          }
+          if (literal.kind === 9 /* NumericLiteral */ && !literal.text.startsWith("-")) {
+            return literal;
+          }
+          return factory.updateComputedPropertyName(node, literal);
+        }
+      }
+      if (isTypePredicateNode(node)) {
+        let parameterName;
+        if (isIdentifier(node.parameterName)) {
+          const { node: result, introducesError } = resolver.trackExistingEntityName(context, node.parameterName);
+          if (introducesError) markError();
+          parameterName = result;
+        } else {
+          parameterName = factory.cloneNode(node.parameterName);
+        }
+        return factory.updateTypePredicateNode(node, factory.cloneNode(node.assertsModifier), parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
+      }
+      if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
+        const visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
+        const clone = resolver.markNodeReuse(context, visited === node ? factory.cloneNode(node) : visited, node);
+        const flags = getEmitFlags(clone);
+        setEmitFlags(clone, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
+        return clone;
+      }
+      if (isStringLiteral(node) && !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */) && !node.singleQuote) {
+        const clone = factory.cloneNode(node);
+        clone.singleQuote = true;
+        return clone;
+      }
+      if (isConditionalTypeNode(node)) {
+        const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
+        const disposeScope = resolver.enterNewScope(context, node);
+        const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
+        const trueType = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
+        disposeScope();
+        const falseType = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode);
+        return factory.updateConditionalTypeNode(
+          node,
+          checkType,
+          extendType,
+          trueType,
+          falseType
+        );
+      }
+      if (isTypeOperatorNode(node)) {
+        if (node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) {
+          if (!resolver.canReuseTypeNode(context, node)) {
+            markError();
+            return node;
+          }
+        } else if (node.operator === 143 /* KeyOfKeyword */) {
+          const result = tryVisitKeyOf(node);
+          if (!result) {
+            markError();
+            return node;
+          }
+          return result;
+        }
+      }
+      return visitEachChild2(node, visitExistingNodeTreeSymbols);
+      function visitEachChild2(node2, visitor) {
+        const nonlocalNode = !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(node2);
+        return visitEachChild(
+          node2,
+          visitor,
+          /*context*/
+          void 0,
+          nonlocalNode ? visitNodesWithoutCopyingPositions : void 0
+        );
+      }
+      function visitNodesWithoutCopyingPositions(nodes, visitor, test, start, count) {
+        let result = visitNodes2(nodes, visitor, test, start, count);
+        if (result) {
+          if (result.pos !== -1 || result.end !== -1) {
+            if (result === nodes) {
+              result = factory.createNodeArray(nodes.slice(), nodes.hasTrailingComma);
+            }
+            setTextRangePosEnd(result, -1, -1);
+          }
+        }
+        return result;
+      }
+      function getEffectiveDotDotDotForParameter(p) {
+        return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0);
+      }
+      function getNameForJSDocFunctionParameter(p, index) {
+        return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
+      }
+      function rewriteModuleSpecifier2(parent, lit) {
+        const newName = resolver.getModuleSpecifierOverride(context, parent, lit);
+        if (newName) {
+          return setOriginalNode(factory.createStringLiteral(newName), lit);
+        }
+        return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
+      }
+    }
+  }
+  function serializeExistingTypeNode(typeNode, context, addUndefined) {
+    if (!typeNode) return void 0;
+    let result;
+    if ((!addUndefined || canAddUndefined(typeNode)) && resolver.canReuseTypeNode(context, typeNode)) {
+      result = tryReuseExistingTypeNode(context, typeNode);
+      if (result !== void 0) {
+        result = addUndefinedIfNeeded(
+          result,
+          addUndefined,
+          /*owner*/
+          void 0,
+          context
+        );
+      }
+    }
+    return result;
+  }
+  function serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, requiresAddingUndefined, useFallback = requiresAddingUndefined !== void 0) {
+    if (!declaredType) return void 0;
+    if (!resolver.canReuseTypeNodeAnnotation(context, node, declaredType, symbol, requiresAddingUndefined)) {
+      if (!requiresAddingUndefined || !resolver.canReuseTypeNodeAnnotation(
+        context,
+        node,
+        declaredType,
+        symbol,
+        /*requiresAddingUndefined*/
+        false
+      )) {
+        return void 0;
+      }
+    }
+    let result;
+    if (!requiresAddingUndefined || canAddUndefined(declaredType)) {
+      result = serializeExistingTypeNode(declaredType, context, requiresAddingUndefined);
+    }
+    if (result !== void 0 || !useFallback) {
+      return result;
+    }
+    context.tracker.reportInferenceFallback(node);
+    return resolver.serializeExistingTypeNode(context, declaredType, requiresAddingUndefined) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
+  }
+  function serializeExistingTypeNodeWithFallback(typeNode, context, addUndefined, targetNode) {
+    if (!typeNode) return void 0;
+    const result = serializeExistingTypeNode(typeNode, context, addUndefined);
+    if (result !== void 0) {
+      return result;
+    }
+    context.tracker.reportInferenceFallback(targetNode ?? typeNode);
+    return resolver.serializeExistingTypeNode(context, typeNode, addUndefined) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
+  }
+  function serializeTypeOfAccessor(accessor, symbol, context) {
+    return typeFromAccessor(accessor, symbol, context) ?? inferAccessorType(accessor, resolver.getAllAccessorDeclarations(accessor), context, symbol);
   }
   function serializeTypeOfExpression(expr, context, addUndefined, preserveLiterals) {
-    return typeFromExpression(
+    const result = typeFromExpression(
       expr,
       context,
       /*isConstContext*/
       false,
       addUndefined,
       preserveLiterals
-    ) ?? inferExpressionType(expr, context);
+    );
+    return result.type !== void 0 ? result.type : inferExpressionType(expr, context, result.reportFallback);
   }
-  function serializeTypeOfDeclaration(node, context) {
+  function serializeTypeOfDeclaration(node, symbol, context) {
     switch (node.kind) {
-      case 171 /* PropertySignature */:
-        return serializeExistingTypeAnnotation(getEffectiveTypeAnnotationNode(node));
       case 169 /* Parameter */:
-        return typeFromParameter(node, context);
+      case 341 /* JSDocParameterTag */:
+        return typeFromParameter(node, symbol, context);
       case 260 /* VariableDeclaration */:
-        return typeFromVariable(node, context);
+        return typeFromVariable(node, symbol, context);
+      case 171 /* PropertySignature */:
+      case 348 /* JSDocPropertyTag */:
       case 172 /* PropertyDeclaration */:
-        return typeFromProperty(node, context);
+        return typeFromProperty(node, symbol, context);
       case 208 /* BindingElement */:
-        return inferTypeOfDeclaration(node, context);
+        return inferTypeOfDeclaration(node, symbol, context);
       case 277 /* ExportAssignment */:
         return serializeTypeOfExpression(
           node.expression,
@@ -131472,17 +131534,39 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       case 211 /* PropertyAccessExpression */:
       case 212 /* ElementAccessExpression */:
       case 226 /* BinaryExpression */:
-        return serializeExistingTypeAnnotation(getEffectiveTypeAnnotationNode(node)) || inferTypeOfDeclaration(node, context);
+        return typeFromExpandoProperty(node, symbol, context);
       case 303 /* PropertyAssignment */:
-        return typeFromExpression(node.initializer, context) || inferTypeOfDeclaration(node, context);
+      case 304 /* ShorthandPropertyAssignment */:
+        return typeFromPropertyAssignment(node, symbol, context);
       default:
         Debug.assertNever(node, `Node needs to be an inferrable node, found ${Debug.formatSyntaxKind(node.kind)}`);
     }
   }
-  function serializeReturnTypeForSignature(node, context) {
+  function typeFromPropertyAssignment(node, symbol, context) {
+    const typeAnnotation = getEffectiveTypeAnnotationNode(node);
+    let result;
+    if (typeAnnotation && resolver.canReuseTypeNodeAnnotation(context, node, typeAnnotation, symbol)) {
+      result = serializeExistingTypeNode(typeAnnotation, context);
+    }
+    if (!result && node.kind === 303 /* PropertyAssignment */) {
+      const initializer = node.initializer;
+      const type = isJSDocTypeAssertion(initializer) ? getJSDocTypeAssertionType(initializer) : initializer.kind === 234 /* AsExpression */ || initializer.kind === 216 /* TypeAssertionExpression */ ? initializer.type : void 0;
+      if (type && !isConstTypeReference(type)) {
+        result = serializeExistingTypeNode(type, context);
+      }
+    }
+    return result ?? inferTypeOfDeclaration(
+      node,
+      symbol,
+      context,
+      /*reportFallback*/
+      false
+    );
+  }
+  function serializeReturnTypeForSignature(node, symbol, context) {
     switch (node.kind) {
       case 177 /* GetAccessor */:
-        return typeFromAccessor(node, context);
+        return serializeTypeOfAccessor(node, symbol, context);
       case 174 /* MethodDeclaration */:
       case 262 /* FunctionDeclaration */:
       case 180 /* ConstructSignature */:
@@ -131497,45 +131581,50 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       case 219 /* ArrowFunction */:
       case 317 /* JSDocFunctionType */:
       case 323 /* JSDocSignature */:
-        return createReturnFromSignature(node, context);
+        return createReturnFromSignature(node, symbol, context);
       default:
         Debug.assertNever(node, `Node needs to be an inferrable node, found ${Debug.formatSyntaxKind(node.kind)}`);
     }
   }
-  function getTypeAnnotationFromAccessor2(accessor) {
+  function getTypeAnnotationFromAccessor(accessor) {
     if (accessor) {
-      return accessor.kind === 177 /* GetAccessor */ ? getEffectiveReturnTypeNode(accessor) : accessor.parameters.length > 0 ? getEffectiveTypeAnnotationNode(accessor.parameters[0]) : void 0;
+      return accessor.kind === 177 /* GetAccessor */ ? isInJSFile(accessor) && getJSDocType(accessor) || getEffectiveReturnTypeNode(accessor) : getEffectiveSetAccessorTypeAnnotationNode(accessor);
     }
   }
   function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) {
-    let accessorType = getTypeAnnotationFromAccessor2(node);
+    let accessorType = getTypeAnnotationFromAccessor(node);
     if (!accessorType && node !== accessors.firstAccessor) {
-      accessorType = getTypeAnnotationFromAccessor2(accessors.firstAccessor);
+      accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor);
     }
     if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) {
-      accessorType = getTypeAnnotationFromAccessor2(accessors.secondAccessor);
+      accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor);
     }
     return accessorType;
   }
-  function typeFromAccessor(node, context) {
+  function typeFromAccessor(node, symbol, context) {
     const accessorDeclarations = resolver.getAllAccessorDeclarations(node);
     const accessorType = getTypeAnnotationFromAllAccessorDeclarations(node, accessorDeclarations);
-    if (accessorType) {
-      return serializeExistingTypeAnnotation(accessorType);
+    if (accessorType && !isTypePredicateNode(accessorType)) {
+      return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context));
     }
     if (accessorDeclarations.getAccessor) {
-      return createReturnFromSignature(accessorDeclarations.getAccessor, context);
+      return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(
+        accessorDeclarations.getAccessor,
+        /*symbol*/
+        void 0,
+        context
+      ));
     }
-    return false;
+    return void 0;
   }
-  function typeFromVariable(node, context) {
+  function typeFromVariable(node, symbol, context) {
+    var _a;
     const declaredType = getEffectiveTypeAnnotationNode(node);
+    let resultType = failed;
     if (declaredType) {
-      return serializeExistingTypeAnnotation(declaredType);
-    }
-    let resultType;
-    if (node.initializer) {
-      if (!resolver.isExpandoFunctionDeclaration(node)) {
+      resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol));
+    } else if (node.initializer && (((_a = symbol.declarations) == null ? void 0 : _a.length) === 1 || countWhere(symbol.declarations, isVariableDeclaration) === 1)) {
+      if (!resolver.isExpandoFunctionDeclaration(node) && !isContextuallyTyped(node)) {
         resultType = typeFromExpression(
           node.initializer,
           context,
@@ -131547,71 +131636,119 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
         );
       }
     }
-    return resultType ?? inferTypeOfDeclaration(node, context);
+    return resultType.type !== void 0 ? resultType.type : inferTypeOfDeclaration(node, symbol, context, resultType.reportFallback);
   }
-  function typeFromParameter(node, context) {
+  function typeFromParameter(node, symbol, context) {
     const parent = node.parent;
     if (parent.kind === 178 /* SetAccessor */) {
-      return typeFromAccessor(parent, context);
+      return serializeTypeOfAccessor(
+        parent,
+        /*symbol*/
+        void 0,
+        context
+      );
     }
     const declaredType = getEffectiveTypeAnnotationNode(node);
-    const addUndefined = resolver.requiresAddingImplicitUndefined(node, context.enclosingDeclaration);
-    let resultType;
+    const addUndefined = resolver.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration);
+    let resultType = failed;
     if (declaredType) {
-      resultType = serializeExistingTypeAnnotation(declaredType, addUndefined);
+      resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, addUndefined));
+    } else if (isParameter(node) && node.initializer && isIdentifier(node.name) && !isContextuallyTyped(node)) {
+      resultType = typeFromExpression(
+        node.initializer,
+        context,
+        /*isConstContext*/
+        void 0,
+        addUndefined
+      );
+    }
+    return resultType.type !== void 0 ? resultType.type : inferTypeOfDeclaration(node, symbol, context, resultType.reportFallback);
+  }
+  function typeFromExpandoProperty(node, symbol, context) {
+    const declaredType = getEffectiveTypeAnnotationNode(node);
+    let result;
+    if (declaredType) {
+      result = serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol);
+    }
+    const oldSuppressReportInferenceFallback = context.suppressReportInferenceFallback;
+    context.suppressReportInferenceFallback = true;
+    const resultType = result ?? inferTypeOfDeclaration(
+      node,
+      symbol,
+      context,
+      /*reportFallback*/
+      false
+    );
+    context.suppressReportInferenceFallback = oldSuppressReportInferenceFallback;
+    return resultType;
+  }
+  function typeFromProperty(node, symbol, context) {
+    const declaredType = getEffectiveTypeAnnotationNode(node);
+    const requiresAddingUndefined = resolver.requiresAddingImplicitUndefined(node, symbol, context.enclosingDeclaration);
+    let resultType = failed;
+    if (declaredType) {
+      resultType = syntacticResult(serializeTypeAnnotationOfDeclaration(declaredType, context, node, symbol, requiresAddingUndefined));
     } else {
-      if (node.initializer && isIdentifier(node.name)) {
+      const initializer = isPropertyDeclaration(node) ? node.initializer : void 0;
+      if (initializer && !isContextuallyTyped(node)) {
+        const isReadonly = isDeclarationReadonly(node);
         resultType = typeFromExpression(
-          node.initializer,
+          initializer,
           context,
           /*isConstContext*/
           void 0,
-          addUndefined
+          requiresAddingUndefined,
+          isReadonly
         );
       }
     }
-    return resultType ?? inferTypeOfDeclaration(node, context);
+    return resultType.type !== void 0 ? resultType.type : inferTypeOfDeclaration(node, symbol, context, resultType.reportFallback);
   }
-  function typeFromProperty(node, context) {
-    const declaredType = getEffectiveTypeAnnotationNode(node);
-    if (declaredType) {
-      return serializeExistingTypeAnnotation(declaredType);
+  function inferTypeOfDeclaration(node, symbol, context, reportFallback = true) {
+    if (reportFallback) {
+      context.tracker.reportInferenceFallback(node);
     }
-    let resultType;
-    if (node.initializer) {
-      const isReadonly = isDeclarationReadonly(node);
-      resultType = typeFromExpression(
-        node.initializer,
-        context,
-        /*isConstContext*/
-        void 0,
-        /*requiresAddingUndefined*/
-        void 0,
-        isReadonly
-      );
+    if (context.noInferenceFallback === true) {
+      return factory.createKeywordTypeNode(133 /* AnyKeyword */);
     }
-    return resultType ?? inferTypeOfDeclaration(node, context);
+    return resolver.serializeTypeOfDeclaration(context, node, symbol);
   }
-  function inferTypeOfDeclaration(node, context) {
-    context.tracker.reportInferenceFallback(node);
-    return false;
-  }
-  function inferExpressionType(node, context) {
-    context.tracker.reportInferenceFallback(node);
-    return false;
+  function inferExpressionType(node, context, reportFallback = true, requiresAddingUndefined) {
+    Debug.assert(!requiresAddingUndefined);
+    if (reportFallback) {
+      context.tracker.reportInferenceFallback(node);
+    }
+    if (context.noInferenceFallback === true) {
+      return factory.createKeywordTypeNode(133 /* AnyKeyword */);
+    }
+    return resolver.serializeTypeOfExpression(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
   }
-  function inferReturnTypeOfSignatureSignature(node, context) {
-    context.tracker.reportInferenceFallback(node);
-    return false;
+  function inferReturnTypeOfSignatureSignature(node, context, reportFallback) {
+    if (reportFallback) {
+      context.tracker.reportInferenceFallback(node);
+    }
+    if (context.noInferenceFallback === true) {
+      return factory.createKeywordTypeNode(133 /* AnyKeyword */);
+    }
+    return resolver.serializeReturnTypeForSignature(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
   }
-  function inferAccessorType(node, allAccessors, context) {
+  function inferAccessorType(node, allAccessors, context, symbol, reportFallback = true) {
     if (node.kind === 177 /* GetAccessor */) {
-      return createReturnFromSignature(node, context);
+      return createReturnFromSignature(node, symbol, context, reportFallback);
     } else {
-      context.tracker.reportInferenceFallback(node);
-      return false;
+      if (reportFallback) {
+        context.tracker.reportInferenceFallback(node);
+      }
+      const result = allAccessors.getAccessor && createReturnFromSignature(allAccessors.getAccessor, symbol, context, reportFallback);
+      return result ?? resolver.serializeTypeOfDeclaration(context, node, symbol) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
     }
   }
+  function withNewScope(context, node, fn) {
+    const cleanup = resolver.enterNewScope(context, node);
+    const result = fn();
+    cleanup();
+    return result;
+  }
   function typeFromTypeAssertion(expression, type, context, requiresAddingUndefined) {
     if (isConstTypeReference(type)) {
       return typeFromExpression(
@@ -131622,10 +131759,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
         requiresAddingUndefined
       );
     }
-    if (requiresAddingUndefined && !canAddUndefined(type)) {
-      context.tracker.reportInferenceFallback(type);
-    }
-    return serializeExistingTypeAnnotation(type);
+    return syntacticResult(serializeExistingTypeNodeWithFallback(type, context, requiresAddingUndefined));
   }
   function typeFromExpression(node, context, isConstContext = false, requiresAddingUndefined = false, preserveLiterals = false) {
     switch (node.kind) {
@@ -131636,14 +131770,19 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
         return typeFromExpression(node.expression, context, isConstContext, requiresAddingUndefined);
       case 80 /* Identifier */:
         if (resolver.isUndefinedIdentifierExpression(node)) {
-          return true;
+          return syntacticResult(createUndefinedTypeNode());
         }
         break;
       case 106 /* NullKeyword */:
-        return true;
+        if (strictNullChecks) {
+          return syntacticResult(addUndefinedIfNeeded(factory.createLiteralTypeNode(factory.createNull()), requiresAddingUndefined, node, context));
+        } else {
+          return syntacticResult(factory.createKeywordTypeNode(133 /* AnyKeyword */));
+        }
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
-        return typeFromFunctionLikeExpression(node, context);
+        Debug.type(node);
+        return withNewScope(context, node, () => typeFromFunctionLikeExpression(node, context));
       case 216 /* TypeAssertionExpression */:
       case 234 /* AsExpression */:
         const asExpression = node;
@@ -131651,43 +131790,73 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       case 224 /* PrefixUnaryExpression */:
         const unaryExpression = node;
         if (isPrimitiveLiteralValue(unaryExpression)) {
-          if (unaryExpression.operand.kind === 10 /* BigIntLiteral */) {
-            return typeFromPrimitiveLiteral();
-          }
-          if (unaryExpression.operand.kind === 9 /* NumericLiteral */) {
-            return typeFromPrimitiveLiteral();
-          }
+          return typeFromPrimitiveLiteral(
+            unaryExpression.operator === 40 /* PlusToken */ ? unaryExpression.operand : unaryExpression,
+            unaryExpression.operand.kind === 10 /* BigIntLiteral */ ? 163 /* BigIntKeyword */ : 150 /* NumberKeyword */,
+            context,
+            isConstContext || preserveLiterals,
+            requiresAddingUndefined
+          );
         }
         break;
-      case 9 /* NumericLiteral */:
-        return typeFromPrimitiveLiteral();
+      case 209 /* ArrayLiteralExpression */:
+        return typeFromArrayLiteral(node, context, isConstContext, requiresAddingUndefined);
+      case 210 /* ObjectLiteralExpression */:
+        return typeFromObjectLiteral(node, context, isConstContext, requiresAddingUndefined);
+      case 231 /* ClassExpression */:
+        return syntacticResult(inferExpressionType(
+          node,
+          context,
+          /*reportFallback*/
+          true,
+          requiresAddingUndefined
+        ));
       case 228 /* TemplateExpression */:
         if (!isConstContext && !preserveLiterals) {
-          return true;
+          return syntacticResult(factory.createKeywordTypeNode(154 /* StringKeyword */));
         }
         break;
-      case 15 /* NoSubstitutionTemplateLiteral */:
-      case 11 /* StringLiteral */:
-        return typeFromPrimitiveLiteral();
-      case 10 /* BigIntLiteral */:
-        return typeFromPrimitiveLiteral();
-      case 112 /* TrueKeyword */:
-      case 97 /* FalseKeyword */:
-        return typeFromPrimitiveLiteral();
-      case 209 /* ArrayLiteralExpression */:
-        return typeFromArrayLiteral(node, context, isConstContext);
-      case 210 /* ObjectLiteralExpression */:
-        return typeFromObjectLiteral(node, context, isConstContext);
-      case 231 /* ClassExpression */:
-        return inferExpressionType(node, context);
+      default:
+        let typeKind;
+        let primitiveNode = node;
+        switch (node.kind) {
+          case 9 /* NumericLiteral */:
+            typeKind = 150 /* NumberKeyword */;
+            break;
+          case 15 /* NoSubstitutionTemplateLiteral */:
+            primitiveNode = factory.createStringLiteral(node.text);
+            typeKind = 154 /* StringKeyword */;
+            break;
+          case 11 /* StringLiteral */:
+            typeKind = 154 /* StringKeyword */;
+            break;
+          case 10 /* BigIntLiteral */:
+            typeKind = 163 /* BigIntKeyword */;
+            break;
+          case 112 /* TrueKeyword */:
+          case 97 /* FalseKeyword */:
+            typeKind = 136 /* BooleanKeyword */;
+            break;
+        }
+        if (typeKind) {
+          return typeFromPrimitiveLiteral(primitiveNode, typeKind, context, isConstContext || preserveLiterals, requiresAddingUndefined);
+        }
     }
-    return void 0;
+    return failed;
   }
   function typeFromFunctionLikeExpression(fnNode, context) {
-    const returnType = serializeExistingTypeAnnotation(fnNode.type) ?? createReturnFromSignature(fnNode, context);
-    const typeParameters = reuseTypeParameters(fnNode.typeParameters);
-    const parameters = fnNode.parameters.every((p) => ensureParameter(p, context));
-    return returnType && typeParameters && parameters;
+    const oldNoInferenceFallback = context.noInferenceFallback;
+    context.noInferenceFallback = true;
+    createReturnFromSignature(
+      fnNode,
+      /*symbol*/
+      void 0,
+      context
+    );
+    reuseTypeParameters(fnNode.typeParameters, context);
+    fnNode.parameters.map((p) => ensureParameter(p, context));
+    context.noInferenceFallback = oldNoInferenceFallback;
+    return notImplemented2;
   }
   function canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext) {
     if (!isConstContext) {
@@ -131702,18 +131871,38 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     }
     return true;
   }
-  function typeFromArrayLiteral(arrayLiteral, context, isConstContext) {
+  function typeFromArrayLiteral(arrayLiteral, context, isConstContext, requiresAddingUndefined) {
     if (!canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext)) {
-      return false;
+      if (requiresAddingUndefined || isDeclaration(walkUpParenthesizedExpressions(arrayLiteral).parent)) {
+        return alreadyReported;
+      }
+      return syntacticResult(inferExpressionType(
+        arrayLiteral,
+        context,
+        /*reportFallback*/
+        false,
+        requiresAddingUndefined
+      ));
     }
-    let canInferArray = true;
+    const oldNoInferenceFallback = context.noInferenceFallback;
+    context.noInferenceFallback = true;
+    const elementTypesInfo = [];
     for (const element of arrayLiteral.elements) {
       Debug.assert(element.kind !== 230 /* SpreadElement */);
-      if (element.kind !== 232 /* OmittedExpression */) {
-        canInferArray = (typeFromExpression(element, context, isConstContext) ?? inferExpressionType(element, context)) && canInferArray;
+      if (element.kind === 232 /* OmittedExpression */) {
+        elementTypesInfo.push(
+          createUndefinedTypeNode()
+        );
+      } else {
+        const expressionType = typeFromExpression(element, context, isConstContext);
+        const elementType = expressionType.type !== void 0 ? expressionType.type : inferExpressionType(element, context, expressionType.reportFallback);
+        elementTypesInfo.push(elementType);
       }
     }
-    return true;
+    const tupleType = factory.createTupleTypeNode(elementTypesInfo);
+    tupleType.emitNode = { flags: 1, autoGenerate: void 0, internalFlags: 0 };
+    context.noInferenceFallback = oldNoInferenceFallback;
+    return notImplemented2;
   }
   function canGetTypeFromObjectLiteral(objectLiteral, context) {
     let result = true;
@@ -131744,64 +131933,214 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     }
     return result;
   }
-  function typeFromObjectLiteral(objectLiteral, context, isConstContext) {
-    if (!canGetTypeFromObjectLiteral(objectLiteral, context)) return false;
-    let canInferObjectLiteral = true;
+  function typeFromObjectLiteral(objectLiteral, context, isConstContext, requiresAddingUndefined) {
+    if (!canGetTypeFromObjectLiteral(objectLiteral, context)) {
+      if (requiresAddingUndefined || isDeclaration(walkUpParenthesizedExpressions(objectLiteral).parent)) {
+        return alreadyReported;
+      }
+      return syntacticResult(inferExpressionType(
+        objectLiteral,
+        context,
+        /*reportFallback*/
+        false,
+        requiresAddingUndefined
+      ));
+    }
+    const oldNoInferenceFallback = context.noInferenceFallback;
+    context.noInferenceFallback = true;
+    const properties = [];
+    const oldFlags = context.flags;
+    context.flags |= 4194304 /* InObjectTypeLiteral */;
     for (const prop of objectLiteral.properties) {
       Debug.assert(!isShorthandPropertyAssignment(prop) && !isSpreadAssignment(prop));
       const name = prop.name;
+      let newProp;
       switch (prop.kind) {
         case 174 /* MethodDeclaration */:
-          canInferObjectLiteral = !!typeFromObjectLiteralMethod(prop, name, context) && canInferObjectLiteral;
+          newProp = withNewScope(context, prop, () => typeFromObjectLiteralMethod(prop, name, context, isConstContext));
           break;
         case 303 /* PropertyAssignment */:
-          canInferObjectLiteral = !!typeFromObjectLiteralPropertyAssignment(prop, name, context, isConstContext) && canInferObjectLiteral;
+          newProp = typeFromObjectLiteralPropertyAssignment(prop, name, context, isConstContext);
           break;
         case 178 /* SetAccessor */:
         case 177 /* GetAccessor */:
-          canInferObjectLiteral = !!typeFromObjectLiteralAccessor(prop, name, context) && canInferObjectLiteral;
+          newProp = typeFromObjectLiteralAccessor(prop, name, context);
           break;
       }
+      if (newProp) {
+        setCommentRange(newProp, prop);
+        properties.push(newProp);
+      }
     }
-    return canInferObjectLiteral;
+    context.flags = oldFlags;
+    const typeNode = factory.createTypeLiteralNode(properties);
+    if (!(context.flags & 1024 /* MultilineObjectLiterals */)) {
+      setEmitFlags(typeNode, 1 /* SingleLine */);
+    }
+    context.noInferenceFallback = oldNoInferenceFallback;
+    return notImplemented2;
   }
   function typeFromObjectLiteralPropertyAssignment(prop, name, context, isConstContext) {
-    return typeFromExpression(prop.initializer, context, isConstContext) ?? inferTypeOfDeclaration(prop, context);
+    const modifiers = isConstContext ? [factory.createModifier(148 /* ReadonlyKeyword */)] : [];
+    const expressionResult = typeFromExpression(prop.initializer, context, isConstContext);
+    const typeNode = expressionResult.type !== void 0 ? expressionResult.type : inferTypeOfDeclaration(
+      prop,
+      /*symbol*/
+      void 0,
+      context,
+      expressionResult.reportFallback
+    );
+    return factory.createPropertySignature(
+      modifiers,
+      reuseNode(context, name),
+      /*questionToken*/
+      void 0,
+      typeNode
+    );
   }
   function ensureParameter(p, context) {
-    return typeFromParameter(p, context);
+    return factory.updateParameterDeclaration(
+      p,
+      [],
+      reuseNode(context, p.dotDotDotToken),
+      resolver.serializeNameOfParameter(context, p),
+      resolver.isOptionalParameter(p) ? factory.createToken(58 /* QuestionToken */) : void 0,
+      typeFromParameter(
+        p,
+        /*symbol*/
+        void 0,
+        context
+      ),
+      // Ignore private param props, since this type is going straight back into a param
+      /*initializer*/
+      void 0
+    );
   }
-  function reuseTypeParameters(typeParameters) {
-    return (typeParameters == null ? void 0 : typeParameters.every(
-      (tp) => serializeExistingTypeAnnotation(tp.constraint) && serializeExistingTypeAnnotation(tp.default)
-    )) ?? true;
+  function reuseTypeParameters(typeParameters, context) {
+    return typeParameters == null ? void 0 : typeParameters.map(
+      (tp) => {
+        var _a;
+        return factory.updateTypeParameterDeclaration(
+          tp,
+          (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
+          reuseNode(context, tp.name),
+          serializeExistingTypeNodeWithFallback(tp.constraint, context),
+          serializeExistingTypeNodeWithFallback(tp.default, context)
+        );
+      }
+    );
   }
-  function typeFromObjectLiteralMethod(method, name, context) {
-    const returnType = createReturnFromSignature(method, context);
-    const typeParameters = reuseTypeParameters(method.typeParameters);
-    const parameters = method.parameters.every((p) => ensureParameter(p, context));
-    return returnType && typeParameters && parameters;
+  function typeFromObjectLiteralMethod(method, name, context, isConstContext) {
+    const returnType = createReturnFromSignature(
+      method,
+      /*symbol*/
+      void 0,
+      context
+    );
+    const typeParameters = reuseTypeParameters(method.typeParameters, context);
+    const parameters = method.parameters.map((p) => ensureParameter(p, context));
+    if (isConstContext) {
+      return factory.createPropertySignature(
+        [factory.createModifier(148 /* ReadonlyKeyword */)],
+        reuseNode(context, name),
+        reuseNode(context, method.questionToken),
+        factory.createFunctionTypeNode(
+          typeParameters,
+          parameters,
+          returnType
+        )
+      );
+    } else {
+      if (isIdentifier(name) && name.escapedText === "new") {
+        name = factory.createStringLiteral("new");
+      }
+      return factory.createMethodSignature(
+        [],
+        reuseNode(context, name),
+        reuseNode(context, method.questionToken),
+        typeParameters,
+        parameters,
+        returnType
+      );
+    }
   }
   function typeFromObjectLiteralAccessor(accessor, name, context) {
     const allAccessors = resolver.getAllAccessorDeclarations(accessor);
-    const getAccessorType = allAccessors.getAccessor && getTypeAnnotationFromAccessor2(allAccessors.getAccessor);
-    const setAccessorType = allAccessors.setAccessor && getTypeAnnotationFromAccessor2(allAccessors.setAccessor);
+    const getAccessorType = allAccessors.getAccessor && getTypeAnnotationFromAccessor(allAccessors.getAccessor);
+    const setAccessorType = allAccessors.setAccessor && getTypeAnnotationFromAccessor(allAccessors.setAccessor);
     if (getAccessorType !== void 0 && setAccessorType !== void 0) {
-      const parameters = accessor.parameters.every((p) => ensureParameter(p, context));
-      if (isGetAccessor(accessor)) {
-        return parameters && serializeExistingTypeAnnotation(getAccessorType);
-      } else {
-        return parameters;
-      }
+      return withNewScope(context, accessor, () => {
+        const parameters = accessor.parameters.map((p) => ensureParameter(p, context));
+        if (isGetAccessor(accessor)) {
+          return factory.updateGetAccessorDeclaration(
+            accessor,
+            [],
+            reuseNode(context, name),
+            parameters,
+            serializeExistingTypeNodeWithFallback(getAccessorType, context),
+            /*body*/
+            void 0
+          );
+        } else {
+          return factory.updateSetAccessorDeclaration(
+            accessor,
+            [],
+            reuseNode(context, name),
+            parameters,
+            /*body*/
+            void 0
+          );
+        }
+      });
     } else if (allAccessors.firstAccessor === accessor) {
-      const foundType = getAccessorType ?? setAccessorType;
-      const propertyType = foundType ? serializeExistingTypeAnnotation(foundType) : inferAccessorType(accessor, allAccessors, context);
-      return propertyType;
+      const foundType = getAccessorType ? withNewScope(context, allAccessors.getAccessor, () => serializeExistingTypeNodeWithFallback(getAccessorType, context)) : setAccessorType ? withNewScope(context, allAccessors.setAccessor, () => serializeExistingTypeNodeWithFallback(setAccessorType, context)) : void 0;
+      const propertyType = foundType ?? inferAccessorType(
+        accessor,
+        allAccessors,
+        context,
+        /*symbol*/
+        void 0
+      );
+      const propertySignature = factory.createPropertySignature(
+        allAccessors.setAccessor === void 0 ? [factory.createModifier(148 /* ReadonlyKeyword */)] : [],
+        reuseNode(context, name),
+        /*questionToken*/
+        void 0,
+        propertyType
+      );
+      return propertySignature;
     }
-    return false;
   }
-  function typeFromPrimitiveLiteral() {
-    return true;
+  function createUndefinedTypeNode() {
+    if (strictNullChecks) {
+      return factory.createKeywordTypeNode(157 /* UndefinedKeyword */);
+    } else {
+      return factory.createKeywordTypeNode(133 /* AnyKeyword */);
+    }
+  }
+  function typeFromPrimitiveLiteral(node, baseType, context, preserveLiterals, requiresAddingUndefined) {
+    let result;
+    if (preserveLiterals) {
+      if (node.kind === 224 /* PrefixUnaryExpression */ && node.operator === 40 /* PlusToken */) {
+        result = factory.createLiteralTypeNode(reuseNode(context, node.operand));
+      }
+      result = factory.createLiteralTypeNode(reuseNode(context, node));
+    } else {
+      result = factory.createKeywordTypeNode(baseType);
+    }
+    return syntacticResult(addUndefinedIfNeeded(result, requiresAddingUndefined, node, context));
+  }
+  function addUndefinedIfNeeded(node, addUndefined, owner, context) {
+    const parentDeclaration = owner && walkUpParenthesizedExpressions(owner).parent;
+    const optionalDeclaration = parentDeclaration && isDeclaration(parentDeclaration) && isOptionalDeclaration(parentDeclaration);
+    if (!strictNullChecks || !(addUndefined || optionalDeclaration)) return node;
+    if (!canAddUndefined(node)) {
+      context.tracker.reportInferenceFallback(node);
+    }
+    if (isUnionTypeNode(node)) {
+      return factory.createUnionTypeNode([...node.types, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
+    }
+    return factory.createUnionTypeNode([node, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
   }
   function canAddUndefined(node) {
     if (!strictNullChecks) return true;
@@ -131816,24 +132155,28 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     }
     return false;
   }
-  function createReturnFromSignature(fn, context) {
-    let returnType;
-    const returnTypeNode = getEffectiveReturnTypeNode(fn);
+  function createReturnFromSignature(fn, symbol, context, reportFallback = true) {
+    let returnType = failed;
+    const returnTypeNode = isJSDocConstructSignature(fn) ? getEffectiveTypeAnnotationNode(fn.parameters[0]) : getEffectiveReturnTypeNode(fn);
     if (returnTypeNode) {
-      returnType = serializeExistingTypeAnnotation(returnTypeNode);
-    }
-    if (!returnType && isValueSignatureDeclaration(fn)) {
+      returnType = syntacticResult(serializeTypeAnnotationOfDeclaration(returnTypeNode, context, fn, symbol));
+    } else if (isValueSignatureDeclaration(fn)) {
       returnType = typeFromSingleReturnExpression(fn, context);
     }
-    return returnType ?? inferReturnTypeOfSignatureSignature(fn, context);
+    return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, reportFallback && returnType.reportFallback && !returnTypeNode);
   }
   function typeFromSingleReturnExpression(declaration, context) {
     let candidateExpr;
     if (declaration && !nodeIsMissing(declaration.body)) {
-      if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0;
+      const flags = getFunctionFlags(declaration);
+      if (flags & 3 /* AsyncGenerator */) return failed;
       const body = declaration.body;
       if (body && isBlock(body)) {
         forEachReturnStatement(body, (s) => {
+          if (s.parent !== body) {
+            candidateExpr = void 0;
+            return true;
+          }
           if (!candidateExpr) {
             candidateExpr = s.expression;
           } else {
@@ -131846,9 +132189,21 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       }
     }
     if (candidateExpr) {
-      return typeFromExpression(candidateExpr, context);
+      if (isContextuallyTyped(candidateExpr)) {
+        const type = isJSDocTypeAssertion(candidateExpr) ? getJSDocTypeAssertionType(candidateExpr) : isAsExpression(candidateExpr) || isTypeAssertionExpression(candidateExpr) ? candidateExpr.type : void 0;
+        if (type && !isConstTypeReference(type)) {
+          return syntacticResult(serializeExistingTypeNode(type, context));
+        }
+      } else {
+        return typeFromExpression(candidateExpr, context);
+      }
     }
-    return void 0;
+    return failed;
+  }
+  function isContextuallyTyped(node) {
+    return findAncestor(node.parent, (n) => {
+      return isCallExpression(n) || !isFunctionLikeDeclaration(n) && !!getEffectiveTypeAnnotationNode(n) || isJsxElement(n) || isJsxExpression(n);
+    });
   }
 }