typedoc 0.25.4 → 0.25.6

package/dist/lib/converter/comments/discovery.js

@@ -294,7 +294,7 @@ function declarationToCommentNode(node) {
     if (node.kind === typescript_1.default.SyntaxKind.ExportSpecifier) {
         return node.parent.parent;
     }
-    if ([typescript_1.default.SyntaxKind.NamespaceExport, typescript_1.default.SyntaxKind.FunctionType].includes(node.kind)) {
+    if (typescript_1.default.SyntaxKind.NamespaceExport === node.kind) {
         return node.parent;
     }
     return node;

package/dist/lib/converter/context.d.ts

@@ -82,8 +82,5 @@ export declare class Context {
     getFileComment(node: ts.SourceFile): import("../models/index").Comment | undefined;
     getJsDocComment(declaration: ts.JSDocPropertyLikeTag | ts.JSDocCallbackTag | ts.JSDocTypedefTag | ts.JSDocTemplateTag | ts.JSDocEnumTag): import("../models/index").Comment | undefined;
     getSignatureComment(declaration: ts.SignatureDeclaration | ts.JSDocSignature): import("../models/index").Comment | undefined;
-    /**
-     * @param callback  The callback function that should be executed with the changed context.
-     */
     withScope(scope: Reflection): Context;
 }

package/dist/lib/converter/context.js

@@ -184,9 +184,6 @@ class Context {
     getSignatureComment(declaration) {
         return (0, comments_1.getSignatureComment)(declaration, this.converter.config, this.logger, this.converter.commentStyle, this.converter.useTsLinkResolution ? this.checker : undefined);
     }
-    /**
-     * @param callback  The callback function that should be executed with the changed context.
-     */
     withScope(scope) {
         const context = new Context(this.converter, this.programs, this.project, scope);
         context.convertingTypeNode = this.convertingTypeNode;

package/dist/lib/converter/converter.d.ts

@@ -117,7 +117,6 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * Convert the given TypeScript type into its TypeDoc type reflection.
      *
      * @param context  The context object describing the current state the converter is in.
-     * @param referenceTarget The target to be used to attempt to resolve reference types
      * @returns The TypeDoc type reflection representing the given node and type.
      * @internal
      */

package/dist/lib/converter/converter.js

@@ -203,7 +203,6 @@ let Converter = (() => {
          * Convert the given TypeScript type into its TypeDoc type reflection.
          *
          * @param context  The context object describing the current state the converter is in.
-         * @param referenceTarget The target to be used to attempt to resolve reference types
          * @returns The TypeDoc type reflection representing the given node and type.
          * @internal
          */

package/dist/lib/converter/factories/signature.js

@@ -47,6 +47,9 @@ function createSignature(context, kind, signature, symbol, declaration) {
     else if (kind == models_1.ReflectionKind.SetSignature) {
         sigRef.type = new models_1.IntrinsicType("void");
     }
+    else if (declaration?.type?.kind === typescript_1.default.SyntaxKind.ThisType) {
+        sigRef.type = new models_1.IntrinsicType("this");
+    }
     else {
         sigRef.type = context.converter.convertType(sigRefCtx, (declaration?.kind === typescript_1.default.SyntaxKind.FunctionDeclaration &&
             declaration.type) ||
@@ -89,7 +92,14 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
         else {
             type = param.type;
         }
-        paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type);
+        if (declaration &&
+            typescript_1.default.isParameter(declaration) &&
+            declaration.type?.kind === typescript_1.default.SyntaxKind.ThisType) {
+            paramRefl.type = new models_1.IntrinsicType("this");
+        }
+        else {
+            paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type);
+        }
         let isOptional = false;
         if (declaration) {
             isOptional = typescript_1.default.isParameter(declaration)
@@ -114,6 +124,7 @@ function convertParameters(context, sigRef, parameters, parameterNodes) {
                     typescript_1.default.isJSDocVariadicType(declaration.typeExpression.type);
         }
         paramRefl.setFlag(models_1.ReflectionFlag.Rest, isRest);
+        checkForDestructuredParameterDefaults(paramRefl, parameterNodes?.[i]);
         return paramRefl;
     });
 }
@@ -140,10 +151,27 @@ function convertParameterNodes(context, sigRef, parameters) {
             ? !!param.dotDotDotToken
             : !!param.typeExpression &&
                 typescript_1.default.isJSDocVariadicType(param.typeExpression.type));
+        checkForDestructuredParameterDefaults(paramRefl, param);
         return paramRefl;
     });
 }
 exports.convertParameterNodes = convertParameterNodes;
+function checkForDestructuredParameterDefaults(param, decl) {
+    if (!decl || !typescript_1.default.isParameter(decl))
+        return;
+    if (param.name !== "__namedParameters")
+        return;
+    if (!typescript_1.default.isObjectBindingPattern(decl.name))
+        return;
+    if (param.type?.type !== "reflection")
+        return;
+    for (const child of param.type.declaration.children || []) {
+        const tsChild = decl.name.elements.find((el) => (el.propertyName || el.name).getText() === child.name);
+        if (tsChild) {
+            child.defaultValue = (0, convert_expression_1.convertDefaultValue)(tsChild);
+        }
+    }
+}
 function convertTypeParameters(context, parent, parameters) {
     return parameters?.map((param) => {
         const constraintT = param.getConstraint();
@@ -218,8 +246,6 @@ function convertTemplateParameterNodes(context, nodes) {
             return paramRefl;
         });
     });
-    const params = (nodes ?? []).flatMap((tag) => tag.typeParameters);
-    return convertTypeParameterNodes(context, params);
 }
 exports.convertTemplateParameterNodes = convertTemplateParameterNodes;
 function getVariance(modifiers) {

package/dist/lib/converter/plugins/CategoryPlugin.d.ts

@@ -22,13 +22,6 @@ export declare class CategoryPlugin extends ConverterComponent {
      * Triggered when the converter begins converting a project.
      */
     private onBegin;
-    /**
-     * Triggered when the converter resolves a reflection.
-     *
-     * @param context  The context object describing the current state the converter is in.
-     * @param reflection  The reflection that is currently resolved.
-     */
-    private onResolve;
     /**
      * Triggered when the converter has finished resolving a project.
      *

package/dist/lib/converter/plugins/CategoryPlugin.js

@@ -100,7 +100,6 @@ let CategoryPlugin = (() => {
         initialize() {
             this.listenTo(this.owner, {
                 [converter_1.Converter.EVENT_BEGIN]: this.onBegin,
-                [converter_1.Converter.EVENT_RESOLVE]: this.onResolve,
                 [converter_1.Converter.EVENT_RESOLVE_END]: this.onEndResolve,
             }, undefined, -200);
         }
@@ -117,17 +116,6 @@ let CategoryPlugin = (() => {
                 CategoryPlugin.WEIGHTS = this.categoryOrder;
             }
         }
-        /**
-         * Triggered when the converter resolves a reflection.
-         *
-         * @param context  The context object describing the current state the converter is in.
-         * @param reflection  The reflection that is currently resolved.
-         */
-        onResolve(_context, reflection) {
-            if (reflection instanceof models_1.ContainerReflection) {
-                this.categorize(reflection);
-            }
-        }
         /**
          * Triggered when the converter has finished resolving a project.
          *
@@ -136,6 +124,12 @@ let CategoryPlugin = (() => {
         onEndResolve(context) {
             const project = context.project;
             this.categorize(project);
+            for (const id in project.reflections) {
+                const reflection = project.reflections[id];
+                if (reflection instanceof models_1.ContainerReflection) {
+                    this.categorize(reflection);
+                }
+            }
             const unusedBoosts = new Set(Object.keys(this.boosts));
             for (const boost of this.usedBoosts) {
                 unusedBoosts.delete(boost);

package/dist/lib/converter/plugins/CommentPlugin.d.ts

@@ -121,4 +121,5 @@ export declare class CommentPlugin extends ConverterComponent {
      */
     private isHidden;
     private excludedByCategory;
+    private validateParamTags;
 }

package/dist/lib/converter/plugins/CommentPlugin.js

@@ -382,13 +382,8 @@ let CommentPlugin = (() => {
             const comment = reflection.kindOf(models_1.ReflectionKind.ClassOrInterface)
                 ? undefined
                 : reflection.comment;
-            // Since this reflection has signatures, remove the comment from the parent
-            // reflection. This is important so that in type aliases we don't end up with
-            // a comment rendered twice.
-            if (!reflection.kindOf(models_1.ReflectionKind.ClassOrInterface)) {
-                delete reflection.comment;
-            }
             for (const signature of signatures) {
+                const signatureHadOwnComment = !!signature.comment;
                 const childComment = (signature.comment ||= comment?.clone());
                 if (!childComment)
                     continue;
@@ -400,7 +395,6 @@ let CommentPlugin = (() => {
                             parameter.name = commentParams[index].name;
                         }
                     }
-                    moveNestedParamTags(childComment, parameter);
                     const tag = childComment.getIdentifiedTag(parameter.name, "@param");
                     if (tag) {
                         parameter.comment = new models_1.Comment(models_1.Comment.cloneDisplayParts(tag.content));
@@ -414,10 +408,26 @@ let CommentPlugin = (() => {
                         parameter.comment = new models_1.Comment(models_1.Comment.cloneDisplayParts(tag.content));
                     }
                 }
+                this.validateParamTags(signature, childComment, signature.parameters || [], signatureHadOwnComment);
                 childComment?.removeTags("@param");
                 childComment?.removeTags("@typeParam");
                 childComment?.removeTags("@template");
             }
+            // Since this reflection has signatures, we need to remove the comment from the non-primary
+            // declaration location. For functions, this means removing it from the Function reflection.
+            // For type aliases, this means removing it from reflection.type.declaration.
+            // This is important so that in type aliases we don't end up with a comment rendered twice.
+            if (reflection.kindOf(models_1.ReflectionKind.FunctionOrMethod | models_1.ReflectionKind.Constructor)) {
+                delete reflection.comment;
+            }
+            if (reflection.kindOf(models_1.ReflectionKind.TypeAlias)) {
+                reflection.comment?.removeTags("@param");
+                reflection.comment?.removeTags("@typeParam");
+                reflection.comment?.removeTags("@template");
+                for (const sig of signatures) {
+                    delete sig.comment;
+                }
+            }
         }
         removeExcludedTags(comment) {
             for (const tag of NEVER_RENDERED) {
@@ -512,6 +522,16 @@ let CommentPlugin = (() => {
             }
             return excludeCategories.some((cat) => categories.has(cat));
         }
+        validateParamTags(signature, comment, params, signatureHadOwnComment) {
+            const paramTags = comment.blockTags.filter((tag) => tag.tag === "@param");
+            (0, utils_1.removeIf)(paramTags, (tag) => params.some((param) => param.name === tag.name));
+            moveNestedParamTags(/* in-out */ paramTags, params);
+            if (signatureHadOwnComment && paramTags.length) {
+                for (const tag of paramTags) {
+                    this.application.logger.warn(`The signature ${signature.getFriendlyFullName()} has an @param with name "${tag.name}", which was not used.`);
+                }
+            }
+        }
     };
     _CommentPlugin_excludeTags_accessor_storage = new WeakMap();
     _CommentPlugin_excludeInternal_accessor_storage = new WeakMap();
@@ -555,29 +575,39 @@ function inTypeLiteral(refl) {
     return false;
 }
 // Moves tags like `@param foo.bar docs for bar` into the `bar` property of the `foo` parameter.
-function moveNestedParamTags(comment, parameter) {
-    const visitor = {
-        reflection(target) {
-            const tags = comment.blockTags.filter((t) => t.tag === "@param" &&
-                t.name?.startsWith(`${parameter.name}.`));
-            for (const tag of tags) {
-                const path = tag.name.split(".");
-                path.shift();
-                const child = target.declaration.getChildByName(path);
-                if (child && !child.comment) {
-                    child.comment = new models_1.Comment(models_1.Comment.cloneDisplayParts(tag.content));
+function moveNestedParamTags(
+/* in-out */ paramTags, parameters) {
+    const used = new Set();
+    for (const param of parameters) {
+        const visitor = {
+            reflection(target) {
+                const tags = paramTags.filter((t) => t.name?.startsWith(`${param.name}.`));
+                for (const tag of tags) {
+                    const path = tag.name.split(".");
+                    path.shift();
+                    const child = target.declaration.getChildByName(path);
+                    if (child && !child.comment) {
+                        child.comment = new models_1.Comment(models_1.Comment.cloneDisplayParts(tag.content));
+                        used.add(paramTags.indexOf(tag));
+                    }
                 }
-            }
-        },
-        // #1876, also do this for unions/intersections.
-        union(u) {
-            u.types.forEach((t) => t.visit(visitor));
-        },
-        intersection(i) {
-            i.types.forEach((t) => t.visit(visitor));
-        },
-    };
-    parameter.type?.visit(visitor);
+            },
+            // #1876, also do this for unions/intersections.
+            union(u) {
+                u.types.forEach((t) => t.visit(visitor));
+            },
+            intersection(i) {
+                i.types.forEach((t) => t.visit(visitor));
+            },
+        };
+        param.type?.visit(visitor);
+    }
+    const toRemove = Array.from(used)
+        .sort((a, b) => a - b)
+        .reverse();
+    for (const index of toRemove) {
+        paramTags.splice(index, 1);
+    }
 }
 function movePropertyTags(comment, container) {
     const propTags = comment.blockTags.filter((tag) => tag.tag === "@prop" || tag.tag === "@property");

package/dist/lib/converter/plugins/GroupPlugin.d.ts

@@ -17,13 +17,6 @@ export declare class GroupPlugin extends ConverterComponent {
      * Create a new GroupPlugin instance.
      */
     initialize(): void;
-    /**
-     * Triggered when the converter resolves a reflection.
-     *
-     * @param context  The context object describing the current state the converter is in.
-     * @param reflection  The reflection that is currently resolved.
-     */
-    private onResolve;
     /**
      * Triggered when the converter has finished resolving a project.
      *

package/dist/lib/converter/plugins/GroupPlugin.js

@@ -100,20 +100,8 @@ let GroupPlugin = (() => {
                     this.sortFunction = (0, sort_1.getSortFunction)(this.application.options);
                     GroupPlugin.WEIGHTS = this.groupOrder;
                 },
-                [converter_1.Converter.EVENT_RESOLVE]: this.onResolve,
                 [converter_1.Converter.EVENT_RESOLVE_END]: this.onEndResolve,
-            });
-        }
-        /**
-         * Triggered when the converter resolves a reflection.
-         *
-         * @param context  The context object describing the current state the converter is in.
-         * @param reflection  The reflection that is currently resolved.
-         */
-        onResolve(_context, reflection) {
-            if (reflection instanceof index_1.ContainerReflection) {
-                this.group(reflection);
-            }
+            }, undefined, -100);
         }
         /**
          * Triggered when the converter has finished resolving a project.
@@ -122,6 +110,12 @@ let GroupPlugin = (() => {
          */
         onEndResolve(context) {
             this.group(context.project);
+            for (const id in context.project.reflections) {
+                const reflection = context.project.reflections[id];
+                if (reflection instanceof index_1.ContainerReflection) {
+                    this.group(reflection);
+                }
+            }
             const unusedBoosts = new Set(Object.keys(this.boosts));
             for (const boost of this.usedBoosts) {
                 unusedBoosts.delete(boost);

package/dist/lib/converter/plugins/SourcePlugin.js

@@ -196,6 +196,9 @@ let SourcePlugin = (() => {
                     refl instanceof index_1.SignatureReflection)) {
                     continue;
                 }
+                if (replaceSourcesWithParentSources(refl)) {
+                    refl.sources = refl.parent.sources;
+                }
                 for (const source of refl.sources || []) {
                     if (this.disableGit || (0, repository_1.gitIsInstalled)()) {
                         const repo = this.getRepository(basePath, source.fullFileName);
@@ -273,3 +276,23 @@ function getLocationNode(node) {
         return node.name;
     return node;
 }
+function replaceSourcesWithParentSources(refl) {
+    if (refl instanceof index_1.DeclarationReflection || !refl.sources) {
+        return false;
+    }
+    const symbol = refl.project.getSymbolFromReflection(refl.parent);
+    if (!symbol?.declarations) {
+        return false;
+    }
+    for (const decl of symbol.declarations) {
+        const file = decl.getSourceFile();
+        const pos = file.getLineAndCharacterOfPosition(decl.pos);
+        const end = file.getLineAndCharacterOfPosition(decl.end);
+        if (refl.sources.some((src) => src.fullFileName === file.fileName &&
+            pos.line <= src.line - 1 &&
+            src.line - 1 <= end.line)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/lib/converter/symbols.js

@@ -48,7 +48,7 @@ const conversionOrder = [
     typescript_1.default.SymbolFlags.FunctionScopedVariable,
     typescript_1.default.SymbolFlags.ExportValue,
     typescript_1.default.SymbolFlags.TypeAlias,
-    typescript_1.default.SymbolFlags.Function,
+    typescript_1.default.SymbolFlags.Function, // Before NamespaceModule
     typescript_1.default.SymbolFlags.Method,
     typescript_1.default.SymbolFlags.Interface,
     typescript_1.default.SymbolFlags.Property,
@@ -100,6 +100,10 @@ function convertSymbol(context, symbol, exportSymbol) {
     }
     if ((0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.NamespaceModule)) {
         // This might be here if a namespace is declared several times.
+        // Or if it's a namespace-like thing defined on a function
+        // In the function case, it's important to remove ValueModule so that
+        // if we convert the children as properties of the function rather than as
+        // a separate namespace, we skip creating the namespace.
         flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.ValueModule);
     }
     if ((0, enum_1.hasAnyFlag)(symbol.flags, typescript_1.default.SymbolFlags.Method |
@@ -110,10 +114,8 @@ function convertSymbol(context, symbol, exportSymbol) {
         // { methodProperty() {} }
         flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Property);
     }
-    for (const flag of (0, enum_1.getEnumFlags)(flags ^ allConverterFlags)) {
-        if (!(flag & allConverterFlags)) {
-            context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${typescript_1.default.SymbolFlags[flag]}`);
-        }
+    for (const flag of (0, enum_1.getEnumFlags)(flags & ~allConverterFlags)) {
+        context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${typescript_1.default.SymbolFlags[flag]}`);
     }
     // Note: This method does not allow skipping earlier converters.
     // For now, this is fine... might not be flexible enough in the future.
@@ -260,9 +262,7 @@ function convertFunctionOrMethod(context, symbol, exportSymbol) {
     // Need to get the non nullable type because interface methods might be declared
     // with a question token. See GH1490.
     const signatures = type.getNonNullableType().getCallSignatures();
-    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.ClassOrInterface |
-        models_1.ReflectionKind.VariableOrProperty |
-        models_1.ReflectionKind.TypeLiteral)
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.MethodContainer)
         ? models_1.ReflectionKind.Method
         : models_1.ReflectionKind.Function, symbol, exportSymbol, void 0);
     if (symbol.declarations?.length && isMethod) {
@@ -276,6 +276,8 @@ function convertFunctionOrMethod(context, symbol, exportSymbol) {
     for (const sig of signatures) {
         (0, signature_1.createSignature)(scope, models_1.ReflectionKind.CallSignature, sig, symbol);
     }
+    convertFunctionProperties(scope, symbol, type);
+    return typescript_1.default.SymbolFlags.NamespaceModule;
 }
 // getDeclaredTypeOfSymbol gets the INSTANCE type
 // getTypeOfSymbolAtLocation gets the STATIC type
@@ -350,13 +352,13 @@ function convertClassOrInterface(context, symbol, exportSymbol) {
     convertConstructSignatures(reflectionContext, symbol);
     // And finally, index signatures
     (0, index_signature_1.convertIndexSignature)(reflectionContext, symbol);
-    // Normally this shouldn't matter, unless someone did something with skipLibCheck off.
+    // Normally this shouldn't matter, unless someone did something with skipLibCheck on.
     return typescript_1.default.SymbolFlags.Alias;
 }
 function convertProperty(context, symbol, exportSymbol) {
     // This might happen if we're converting a function-module created with Object.assign
     // or `export default () => {}`
-    if (context.scope.kindOf(models_1.ReflectionKind.SomeModule | models_1.ReflectionKind.Project)) {
+    if (context.scope.kindOf(models_1.ReflectionKind.VariableContainer)) {
         return convertVariable(context, symbol, exportSymbol);
     }
     const declarations = symbol.getDeclarations() ?? [];
@@ -382,7 +384,7 @@ function convertProperty(context, symbol, exportSymbol) {
             return convertArrowAsMethod(context, symbol, declaration.initializer, exportSymbol);
         }
     }
-    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.Namespace)
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.VariableContainer)
         ? models_1.ReflectionKind.Variable
         : models_1.ReflectionKind.Property, symbol, exportSymbol);
     reflection.conversionFlags |= models_1.ConversionFlags.VariableOrPropertySource;
@@ -413,9 +415,16 @@ function convertArrowAsMethod(context, symbol, arrow, exportSymbol) {
     setModifiers(symbol, arrow.parent, reflection);
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
-    const signature = context.checker.getSignatureFromDeclaration(arrow);
-    (0, assert_1.default)(signature);
-    (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signature, symbol, arrow);
+    const locationDeclaration = symbol.parent
+        ?.getDeclarations()
+        ?.find((d) => typescript_1.default.isClassDeclaration(d) || typescript_1.default.isInterfaceDeclaration(d)) ??
+        symbol.parent?.getDeclarations()?.[0]?.getSourceFile() ??
+        symbol.getDeclarations()?.[0]?.getSourceFile();
+    (0, assert_1.default)(locationDeclaration, "Missing declaration context");
+    const type = context.checker.getTypeOfSymbolAtLocation(symbol, locationDeclaration);
+    const signatures = type.getNonNullableType().getCallSignatures();
+    (0, assert_1.default)(signatures.length, "Missing signatures");
+    (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signatures[0], symbol, arrow);
 }
 function convertConstructor(context, symbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Constructor, symbol, void 0, "constructor");
@@ -478,7 +487,9 @@ function convertVariable(context, symbol, exportSymbol) {
     if (type.getCallSignatures().length) {
         return convertVariableAsFunction(context, symbol, exportSymbol);
     }
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Variable, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.VariableContainer)
+        ? models_1.ReflectionKind.Variable
+        : models_1.ReflectionKind.Property, symbol, exportSymbol);
     let typeNode;
     if (declaration && typescript_1.default.isVariableDeclaration(declaration)) {
         // Otherwise we might have destructuring
@@ -535,7 +546,9 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     const type = accessDeclaration
         ? context.checker.getTypeOfSymbolAtLocation(symbol, accessDeclaration)
         : context.checker.getDeclaredTypeOfSymbol(symbol);
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Function, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.MethodContainer)
+        ? models_1.ReflectionKind.Method
+        : models_1.ReflectionKind.Function, symbol, exportSymbol);
     setModifiers(symbol, accessDeclaration, reflection);
     reflection.conversionFlags |= models_1.ConversionFlags.VariableOrPropertySource;
     context.finalizeDeclarationReflection(reflection);
@@ -544,15 +557,23 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     for (const signature of type.getCallSignatures()) {
         (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, signature, symbol);
     }
-    // #2436: Functions created with Object.assign on a function won't have a namespace flag
-    // but likely have properties that we should put into a namespace.
+    convertFunctionProperties(context.withScope(reflection), symbol, type);
+    return typescript_1.default.SymbolFlags.Property | typescript_1.default.SymbolFlags.NamespaceModule;
+}
+function convertFunctionProperties(context, symbol, type) {
+    // #2436/#2461: Functions created with Object.assign on a function likely have properties
+    // that we should document. We also add properties to the function if they are defined like:
+    //   function f() {}
+    //   f.x = 123;
+    // rather than creating a separate namespace.
+    // In the expando case, we'll have both namespace flags.
+    // In the Object.assign case, we'll have no namespace flags.
+    const nsFlags = typescript_1.default.SymbolFlags.ValueModule | typescript_1.default.SymbolFlags.NamespaceModule;
     if (type.getProperties().length &&
-        !(0, enum_1.hasAnyFlag)(symbol.flags, typescript_1.default.SymbolFlags.NamespaceModule | typescript_1.default.SymbolFlags.ValueModule)) {
-        const ns = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
-        context.finalizeDeclarationReflection(ns);
-        convertSymbols(context.withScope(ns), type.getProperties());
+        ((0, enum_1.hasAllFlags)(symbol.flags, nsFlags) ||
+            !(0, enum_1.hasAnyFlag)(symbol.flags, nsFlags))) {
+        convertSymbols(context, type.getProperties());
     }
-    return typescript_1.default.SymbolFlags.Property;
 }
 function convertAccessor(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Accessor, symbol, exportSymbol);

package/dist/lib/converter/types.js

@@ -64,7 +64,7 @@ function loadConverters() {
 exports.loadConverters = loadConverters;
 // This ought not be necessary, but we need some way to discover recursively
 // typed symbols which do not have type nodes. See the `recursive` symbol in the variables test.
-const seenTypeSymbols = new Set();
+const seenTypes = new Set();
 function maybeConvertType(context, typeOrNode) {
     if (!typeOrNode) {
         return;
@@ -83,19 +83,23 @@ function convertType(context, typeOrNode) {
         }
         return requestBugReport(context, typeOrNode);
     }
+    // TS 4.2 added this to enable better tracking of type aliases.
+    // We need to check it here, not just in the union checker, because typeToTypeNode
+    // will use the origin when serializing
+    // aliasSymbol check is important - #2468
+    if (typeOrNode.isUnion() &&
+        typeOrNode.origin &&
+        !typeOrNode.origin.isUnion() &&
+        !typeOrNode.aliasSymbol) {
+        return convertType(context, typeOrNode.origin);
+    }
     // IgnoreErrors is important, without it, we can't assert that we will get a node.
     const node = context.checker.typeToTypeNode(typeOrNode, void 0, typescript_1.default.NodeBuilderFlags.IgnoreErrors);
     (0, assert_1.default)(node); // According to the TS source of typeToString, this is a bug if it does not hold.
-    const symbol = typeOrNode.getSymbol();
-    if (symbol) {
-        if (node.kind !== typescript_1.default.SyntaxKind.TypeReference &&
-            node.kind !== typescript_1.default.SyntaxKind.ArrayType &&
-            seenTypeSymbols.has(symbol)) {
-            const typeString = context.checker.typeToString(typeOrNode);
-            context.logger.verbose(`Refusing to recurse when converting type: ${typeString}`);
-            return new models_1.UnknownType(typeString);
-        }
-        seenTypeSymbols.add(symbol);
+    if (seenTypes.has(typeOrNode.id)) {
+        const typeString = context.checker.typeToString(typeOrNode);
+        context.logger.verbose(`Refusing to recurse when converting type: ${typeString}`);
+        return new models_1.UnknownType(typeString);
     }
     let converter = converters.get(node.kind);
     if (converter) {
@@ -104,9 +108,9 @@ function convertType(context, typeOrNode) {
             !typeOrNode.isIntersection()) {
             converter = typeLiteralConverter;
         }
+        seenTypes.add(typeOrNode.id);
         const result = converter.convertType(context, typeOrNode, node);
-        if (symbol)
-            seenTypeSymbols.delete(symbol);
+        seenTypes.delete(typeOrNode.id);
         return result;
     }
     return requestBugReport(context, typeOrNode);
@@ -402,12 +406,16 @@ const queryConverter = {
             // on a variable typed as `any` with a name that doesn't exist.
             return new models_1.QueryType(models_1.ReferenceType.createBrokenReference(node.exprName.getText(), context.project));
         }
-        return new models_1.QueryType(models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText()));
+        const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
+        ref.preferValues = true;
+        return new models_1.QueryType(ref);
     },
     convertType(context, type, node) {
         const symbol = type.getSymbol() || context.getSymbolAtLocation(node.exprName);
         (0, assert_1.default)(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
-        return new models_1.QueryType(models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context));
+        const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context);
+        ref.preferValues = true;
+        return new models_1.QueryType(ref);
     },
 };
 const referenceConverter = {
@@ -623,10 +631,6 @@ const typeOperatorConverter = {
         // keyof will only show up with generic functions, otherwise it gets eagerly
         // resolved to a union of strings.
         if (node.operator === typescript_1.default.SyntaxKind.KeyOfKeyword) {
-            // TS 4.2 added this to enable better tracking of type aliases.
-            if (type.isUnion() && type.origin) {
-                return convertType(context, type.origin);
-            }
             // There's probably an interface for this somewhere... I couldn't find it.
             const targetType = type.type;
             return new models_1.TypeOperatorType(convertType(context, targetType), "keyof");
@@ -642,10 +646,6 @@ const unionConverter = {
         return new models_1.UnionType(node.types.map((type) => convertType(context, type)));
     },
     convertType(context, type) {
-        // TS 4.2 added this to enable better tracking of type aliases.
-        if (type.origin) {
-            return convertType(context, type.origin);
-        }
         return new models_1.UnionType(type.types.map((type) => convertType(context, type)));
     },
 };

package/dist/lib/models/comments/comment.d.ts

@@ -140,7 +140,6 @@ export declare class Comment {
      * Return the first tag with the given name.
      *
      * @param tagName  The name of the tag to look for.
-     * @param paramName  An optional parameter name to look for.
      * @returns The found tag or undefined.
      */
     getTag(tagName: `@${string}`): CommentTag | undefined;