Progress

Author: jakebailey

src/compiler/checker.ts

@@ -5882,6 +5882,8 @@ namespace ts {
                     typeParameters = signature.typeParameters && signature.typeParameters.map(parameter => typeParameterToDeclaration(parameter, context));
                 }
 
+                const expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
+
                 // For regular function/method declarations, the enclosing declaration will already be signature.declaration,
                 // so this is a no-op, but for arrow functions and function expressions, the enclosing declaration will be
                 // the declaration that the arrow function / function expression is assigned to.
@@ -5902,12 +5904,11 @@ namespace ts {
                 if (saveEnclosingDeclaration && originalDeclaration && originalDeclaration !== saveEnclosingDeclaration && !isInJSFile(originalDeclaration)) {
                     // Debug.assert(!isJSDocSignature(originalDeclaration));
                     const clone = parseNodeFactory.cloneNode(originalDeclaration);
-                    // setTextRange(clone, originalDeclaration); // TODO(jakebailey): Is this needed?
-                    setParent(clone, saveEnclosingDeclaration); // TODO(jakebailey): we can chain these if we want.
-                    context.enclosingDeclaration = clone;
+                    clone.locals = createSymbolTable(expandedParams); // We only care about the parameters, not type parameters.
+                    setParent(clone, saveEnclosingDeclaration);
+                    context.enclosingDeclaration = clone; // TODO(jakebailey): HERE
                 }
 
-                const expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 const parameters = (some(expandedParams, p => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & CheckFlags.RestParameter)) ? signature.parameters : expandedParams).map(parameter => symbolToParameterDeclaration(parameter, context, kind === SyntaxKind.Constructor, options?.privateSymbolVisitor, options?.bundledImports));
                 const thisParameter = context.flags & NodeBuilderFlags.OmitThisParameter ? undefined : tryGetThisParameterDeclaration(signature, context);
@@ -6482,6 +6483,7 @@ namespace ts {
                     return factory.createIdentifier("(Missing type parameter)");
                 }
                 if (context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams) {
+                    // TODO(jakebailey): these casts would be better flipped.
                     const rawtext = result.escapedText as string;
                     let i = context.typeParameterNamesByTextNextNameCount?.get(rawtext) || 0;
                     let text = rawtext;
@@ -6651,22 +6653,8 @@ namespace ts {
                 return initial;
             }
 
-            function isChildOfEnclosingDeclaration(enclosingDeclaration: Node | undefined, node: Node): boolean {
-                return !!findAncestor(node, n => isEnclosingDeclarationOrOriginal(n));
-                // If our enclosing declaration was created via cloning, then the enclosing declaration won't be
-                // an ancestor of say, a parameter declaration, but an original node may be.
-                function isEnclosingDeclarationOrOriginal(n: Node): boolean {
-                    for (let e = enclosingDeclaration; e; e = e.original) {
-                        if (e === n) {
-                            return true;
-                        }
-                    }
-                    return false;
-                }
-            }
-
             function getDeclarationWithTypeAnnotation(symbol: Symbol, enclosingDeclaration: Node | undefined) {
-                return symbol.declarations && find(symbol.declarations, s => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || isChildOfEnclosingDeclaration(enclosingDeclaration, s)));
+                return symbol.declarations && find(symbol.declarations, s => !!getEffectiveTypeAnnotationNode(s) && !!findAncestor(s, n => n === enclosingDeclaration));
             }
 
             function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing: TypeNode, type: Type) {
@@ -6692,7 +6680,7 @@ namespace ts {
                     }
                 }
                 const oldFlags = context.flags;
-                if (type.flags & TypeFlags.UniqueESSymbol &&
+                if (type.flags & TypeFlags.UniqueESSymbol && // TODO(jakebailey): isChildOfEnclosingDeclaration?
                     type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, d => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration!)))) {
                     context.flags |= NodeBuilderFlags.AllowUniqueESSymbolType;
                 }
@@ -6715,7 +6703,7 @@ namespace ts {
             function serializeReturnTypeForSignature(context: NodeBuilderContext, type: Type, signature: Signature, includePrivateSymbol?: (s: Symbol) => void, bundled?: boolean) {
                 if (!isErrorType(type) && context.enclosingDeclaration) {
                     const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
-                    if (annotation && isChildOfEnclosingDeclaration(context.enclosingDeclaration, annotation)) { // TODO(jakebailey): this also needs to check original; move to helper
+                    if (annotation && findAncestor(annotation, n => n === context.enclosingDeclaration)) {
                         const annotated = getTypeFromTypeNode(annotation);
                         const thisInstantiated = annotated.flags & TypeFlags.TypeParameter && (annotated as TypeParameter).isThisType ? instantiateType(annotated, signature.mapper) : annotated;
                         if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
@@ -7179,7 +7167,7 @@ namespace ts {
                     visitedSymbols.add(getSymbolId(visitedSym));
                     // Only actually serialize symbols within the correct enclosing declaration, otherwise do nothing with the out-of-context symbol
                     const skipMembershipCheck = !isPrivate; // We only call this on exported symbols when we know they're in the correct scope
-                    if (skipMembershipCheck || (!!length(symbol.declarations) && some(symbol.declarations, d => isChildOfEnclosingDeclaration(enclosingDeclaration, d)))) {
+                    if (skipMembershipCheck || (!!length(symbol.declarations) && some(symbol.declarations, d => !!findAncestor(d, n => n === enclosingDeclaration)))) {
                         const oldContext = context;
                         context = cloneNodeBuilderContext(context);
                         serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);