typedoc 0.25.3 → 0.25.5

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,19 +114,8 @@ function convertSymbol(context, symbol, exportSymbol) {
         // { methodProperty() {} }
         flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Property);
     }
-    // A default exported function with no associated variable is a property, but
-    // we should really convert it as a variable for documentation purposes
-    // export default () => {}
-    // export default 123
-    if (flags === typescript_1.default.SymbolFlags.Property &&
-        symbol.name === "default" &&
-        context.scope.kindOf(models_1.ReflectionKind.Module | models_1.ReflectionKind.Project)) {
-        flags = typescript_1.default.SymbolFlags.BlockScopedVariable;
-    }
-    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.
@@ -269,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) {
@@ -285,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
@@ -359,8 +352,15 @@ 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 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.VariableContainer)) {
+        return convertVariable(context, symbol, exportSymbol);
+    }
     const declarations = symbol.getDeclarations() ?? [];
     // Don't do anything if we inherited this property and it is private.
     if (isInherited(context, symbol) &&
@@ -384,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;
@@ -415,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");
@@ -466,9 +473,10 @@ function createAlias(target, context, symbol, exportSymbol) {
 }
 function convertVariable(context, symbol, exportSymbol) {
     const declaration = symbol.getDeclarations()?.[0];
-    (0, assert_1.default)(declaration);
     const comment = context.getComment(symbol, models_1.ReflectionKind.Variable);
-    const type = context.checker.getTypeOfSymbolAtLocation(symbol, declaration);
+    const type = declaration
+        ? context.checker.getTypeOfSymbolAtLocation(symbol, declaration)
+        : context.checker.getTypeOfSymbol(symbol);
     if (isEnumLike(context.checker, type, declaration) &&
         comment?.hasModifier("@enum")) {
         return convertVariableAsEnum(context, symbol, exportSymbol);
@@ -479,9 +487,11 @@ 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 (typescript_1.default.isVariableDeclaration(declaration)) {
+    if (declaration && typescript_1.default.isVariableDeclaration(declaration)) {
         // Otherwise we might have destructuring
         typeNode = declaration.type;
     }
@@ -492,7 +502,7 @@ function convertVariable(context, symbol, exportSymbol) {
     return typescript_1.default.SymbolFlags.Property;
 }
 function isEnumLike(checker, type, location) {
-    if (!(0, enum_1.hasAllFlags)(type.flags, typescript_1.default.TypeFlags.Object)) {
+    if (!location || !(0, enum_1.hasAllFlags)(type.flags, typescript_1.default.TypeFlags.Object)) {
         return false;
     }
     return type.getProperties().every((prop) => {
@@ -536,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);
@@ -545,7 +557,23 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     for (const signature of type.getCallSignatures()) {
         (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, signature, symbol);
     }
-    return typescript_1.default.SymbolFlags.Property;
+    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.hasAllFlags)(symbol.flags, nsFlags) ||
+            !(0, enum_1.hasAnyFlag)(symbol.flags, nsFlags))) {
+        convertSymbols(context, type.getProperties());
+    }
 }
 function convertAccessor(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Accessor, symbol, exportSymbol);

package/dist/lib/converter/types.js

@@ -83,6 +83,14 @@ 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
+    if (typeOrNode.isUnion() &&
+        typeOrNode.origin &&
+        !typeOrNode.origin.isUnion()) {
+        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.
@@ -402,12 +410,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 +635,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 +650,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/converter/utils/repository.js

@@ -29,7 +29,7 @@ class AssumedRepository {
             path: fileName.substring(this.path.length + 1),
             line,
         };
-        return this.sourceLinkTemplate.replace(/\{(path|line)\}/g, (_, key) => replacements[key]);
+        return this.sourceLinkTemplate.replace(/\{(gitRevision|path|line)\}/g, (_, key) => replacements[key]);
     }
 }
 exports.AssumedRepository = AssumedRepository;
@@ -117,9 +117,9 @@ exports.GitRepository = GitRepository;
 // 3. project
 const repoExpressions = [
     /(github(?!.us)(?:\.[a-z]+)*\.[a-z]{2,})[:/]([^/]+)\/(.*)/,
-    /(\w+\.githubprivate.com)[:/]([^/]+)\/(.*)/,
-    /(\w+\.ghe.com)[:/]([^/]+)\/(.*)/,
-    /(\w+\.github.us)[:/]([^/]+)\/(.*)/,
+    /(\w+\.githubprivate.com)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(\w+\.ghe.com)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(\w+\.github.us)[:/]([^/]+)\/(.*)/, // GitHub enterprise
     /(bitbucket.org)[:/]([^/]+)\/(.*)/,
     /(gitlab.com)[:/]([^/]+)\/(.*)/,
 ];

package/dist/lib/converter/utils/symbols.js

@@ -6,8 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAliasedSymbol = void 0;
 const typescript_1 = __importDefault(require("typescript"));
 function resolveAliasedSymbol(symbol, checker) {
+    const seen = new Set();
     while (typescript_1.default.SymbolFlags.Alias & symbol.flags) {
         symbol = checker.getAliasedSymbol(symbol);
+        // #2438, with declaration files, we might have an aliased symbol which eventually points to itself.
+        if (seen.has(symbol))
+            return symbol;
+        seen.add(symbol);
     }
     return symbol;
 }

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;

package/dist/lib/models/comments/comment.js

@@ -273,7 +273,6 @@ 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) {

package/dist/lib/models/reflections/ReflectionSymbolId.d.ts

@@ -17,8 +17,16 @@ export declare class ReflectionSymbolId {
     /**
      * Note: This is **not** serialized. It exists for sorting by declaration order, but
      * should not be needed when deserializing from JSON.
+     * Will be set to `Infinity` if the ID was deserialized from JSON.
      */
     pos: number;
+    /**
+     * Note: This is **not** serialized. It exists to support detection of the differences between
+     * symbols which share declarations, but are instantiated with different type parameters.
+     * This will be `NaN` if the symbol reference is not transient.
+     * Note: This can only be non-NaN if {@link pos} is finite.
+     */
+    transientId: number;
     constructor(symbol: ts.Symbol, declaration?: ts.Declaration);
     constructor(json: JSONOutput.ReflectionSymbolId);
     getStableKey(): ReflectionSymbolIdString;

package/dist/lib/models/reflections/ReflectionSymbolId.js

@@ -8,9 +8,11 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const typescript_1 = __importDefault(require("typescript"));
 const fs_2 = require("../../utils/fs");
+const paths_1 = require("../../utils/paths");
 const tsutils_1 = require("../../utils/tsutils");
 const validation_1 = require("../../utils/validation");
-const paths_1 = require("../../utils/paths");
+let transientCount = 0;
+const transientIds = new WeakMap();
 /**
  * This exists so that TypeDoc can store a unique identifier for a `ts.Symbol` without
  * keeping a reference to the `ts.Symbol` itself. This identifier should be stable across
@@ -28,16 +30,24 @@ class ReflectionSymbolId {
                 this.qualifiedName = (0, tsutils_1.getQualifiedName)(symbol, symbol.name);
             }
             this.pos = declaration?.pos ?? Infinity;
+            if (symbol.flags & typescript_1.default.SymbolFlags.Transient) {
+                this.transientId = transientIds.get(symbol) ?? ++transientCount;
+                transientIds.set(symbol, this.transientId);
+            }
+            else {
+                this.transientId = NaN;
+            }
         }
         else {
             this.fileName = symbol.sourceFileName;
             this.qualifiedName = symbol.qualifiedName;
             this.pos = Infinity;
+            this.transientId = NaN;
         }
     }
     getStableKey() {
         if (Number.isFinite(this.pos)) {
-            return `${this.fileName}\0${this.qualifiedName}\0${this.pos}`;
+            return `${this.fileName}\0${this.qualifiedName}\0${this.pos}\0${this.transientId}`;
         }
         else {
             return `${this.fileName}\0${this.qualifiedName}`;
@@ -95,7 +105,7 @@ function addInferredDeclarationMapPaths(opts, files) {
     const rootDir = opts.rootDir || (0, fs_2.getCommonDirectory)(files);
     const declDir = opts.declarationDir || opts.outDir || rootDir;
     for (const file of files) {
-        const mapFile = (0, path_1.resolve)(declDir, (0, path_1.relative)(rootDir, file)).replace(/\.([cm]?[tj]s)x?$/, ".d.$1");
+        const mapFile = (0, paths_1.normalizePath)((0, path_1.resolve)(declDir, (0, path_1.relative)(rootDir, file)).replace(/\.([cm]?[tj]s)x?$/, ".d.$1"));
         declarationMapCache.set(mapFile, file);
     }
 }

package/dist/lib/models/reflections/abstract.d.ts

@@ -194,7 +194,7 @@ export declare abstract class Reflection {
     /**
      * Return a child by its name.
      *
-     * @param names The name hierarchy of the child to look for.
+     * @param arg The name hierarchy of the child to look for.
      * @returns The found child or undefined.
      */
     getChildByName(arg: string | string[]): Reflection | undefined;
@@ -227,6 +227,8 @@ export declare abstract class Reflection {
     /**
      * Return a string representation of this reflection and all of its children.
      *
+     * Note: This is intended as a debug tool only, output may change between patch versions.
+     *
      * @param indent  Used internally to indent child reflections.
      */
     toStringHierarchy(indent?: string): string;

package/dist/lib/models/reflections/abstract.js

@@ -366,7 +366,7 @@ let Reflection = (() => {
             /**
              * Return a child by its name.
              *
-             * @param names The name hierarchy of the child to look for.
+             * @param arg The name hierarchy of the child to look for.
              * @returns The found child or undefined.
              */
             getChildByName(arg) {
@@ -405,7 +405,7 @@ let Reflection = (() => {
                 let signaturesDeprecated = false;
                 this.visit({
                     declaration(decl) {
-                        if (decl.signatures &&
+                        if (decl.signatures?.length &&
                             decl.signatures.every((sig) => sig.comment?.getTag("@deprecated"))) {
                             signaturesDeprecated = true;
                         }
@@ -428,6 +428,8 @@ let Reflection = (() => {
             /**
              * Return a string representation of this reflection and all of its children.
              *
+             * Note: This is intended as a debug tool only, output may change between patch versions.
+             *
              * @param indent  Used internally to indent child reflections.
              */
             toStringHierarchy(indent = "") {

package/dist/lib/models/reflections/declaration.js

@@ -104,7 +104,7 @@ class DeclarationReflection extends container_1.ContainerReflection {
             result += "<" + parameters.join(", ") + ">";
         }
         if (this.type) {
-            result += ":" + this.type.toString();
+            result += ": " + this.type.toString();
         }
         return result;
     }

package/dist/lib/models/reflections/kind.d.ts

@@ -58,11 +58,17 @@ export declare namespace ReflectionKind {
     const Inheritable: number;
     /** @internal */
     const ContainsCallSignatures: number;
+    /** @internal */
+    const TypeReferenceTarget: number;
+    /** @internal */
+    const ValueReferenceTarget: number;
     /**
      * Note: This does not include Class/Interface, even though they technically could contain index signatures
      * @internal
      */
     const SignatureContainer: number;
+    const VariableContainer: number;
+    const MethodContainer: number;
     function singularString(kind: ReflectionKind): string;
     function pluralString(kind: ReflectionKind): string;
     function classString(kind: ReflectionKind): string;

package/dist/lib/models/reflections/kind.js

@@ -87,11 +87,28 @@ var ReflectionKind;
     ReflectionKind.ContainsCallSignatures = ReflectionKind.Constructor |
         ReflectionKind.Function |
         ReflectionKind.Method;
+    // The differences between Type/Value here only really matter for
+    // possibly merged declarations where we have multiple reflections.
+    /** @internal */
+    ReflectionKind.TypeReferenceTarget = ReflectionKind.Interface |
+        ReflectionKind.TypeAlias |
+        ReflectionKind.Class |
+        ReflectionKind.Enum;
+    /** @internal */
+    ReflectionKind.ValueReferenceTarget = ReflectionKind.Module |
+        ReflectionKind.Namespace |
+        ReflectionKind.Variable |
+        ReflectionKind.Function;
     /**
      * Note: This does not include Class/Interface, even though they technically could contain index signatures
      * @internal
      */
     ReflectionKind.SignatureContainer = ReflectionKind.ContainsCallSignatures | ReflectionKind.Accessor;
+    ReflectionKind.VariableContainer = ReflectionKind.SomeModule | ReflectionKind.Project;
+    ReflectionKind.MethodContainer = ReflectionKind.ClassOrInterface |
+        ReflectionKind.VariableOrProperty |
+        ReflectionKind.FunctionOrMethod |
+        ReflectionKind.TypeLiteral;
     const SINGULARS = {
         [ReflectionKind.Enum]: "Enumeration",
         [ReflectionKind.EnumMember]: "Enumeration Member",

package/dist/lib/models/reflections/parameter.js

@@ -22,7 +22,7 @@ class ParameterReflection extends abstract_1.Reflection {
      * Return a string representation of this reflection.
      */
     toString() {
-        return super.toString() + (this.type ? ":" + this.type.toString() : "");
+        return (super.toString() + (this.type ? ": " + this.type.toString() : ""));
     }
     toObject(serializer) {
         return {

package/dist/lib/models/reflections/project.d.ts

@@ -81,10 +81,13 @@ export declare class ProjectReflection extends ContainerReflection {
     getReflectionFromSymbol(symbol: ts.Symbol): Reflection | undefined;
     /**
      * Gets the reflection associated with the given symbol id, if it exists.
+     * If there are multiple reflections associated with this symbol, gets the first one.
      * @internal
      */
     getReflectionFromSymbolId(symbolId: ReflectionSymbolId): Reflection | undefined;
     /** @internal */
+    getReflectionsFromSymbolId(symbolId: ReflectionSymbolId): Reflection[];
+    /** @internal */
     getSymbolIdFromReflection(reflection: Reflection): ReflectionSymbolId | undefined;
     /** @internal */
     registerSymbolId(reflection: Reflection, id: ReflectionSymbolId): void;

package/dist/lib/models/reflections/project.js

@@ -65,10 +65,27 @@ class ProjectReflection extends container_1.ContainerReflection {
         }
         this.reflections[reflection.id] = reflection;
         if (symbol) {
-            const id = new ReflectionSymbolId_1.ReflectionSymbolId(symbol);
-            this.symbolToReflectionIdMap.set(id, this.symbolToReflectionIdMap.get(id) ?? reflection.id);
-            this.reflectionIdToSymbolIdMap.set(reflection.id, id);
             this.reflectionIdToSymbolMap.set(reflection.id, symbol);
+            const id = new ReflectionSymbolId_1.ReflectionSymbolId(symbol);
+            this.registerSymbolId(reflection, id);
+            // #2466
+            // If we just registered a member of a class or interface, then we need to check if
+            // we've registered this symbol before under the wrong parent reflection.
+            // This can happen because the compiler API will use non-dependently-typed symbols
+            // for properties of classes/interfaces which inherit them, so we can't rely on the
+            // property being unique for each class.
+            if (reflection.parent?.kindOf(kind_1.ReflectionKind.ClassOrInterface) &&
+                reflection.kindOf(kind_1.ReflectionKind.SomeMember)) {
+                const saved = this.symbolToReflectionIdMap.get(id);
+                const parentSymbolReflection = symbol.parent &&
+                    this.getReflectionFromSymbol(symbol.parent);
+                if (typeof saved === "object" &&
+                    saved.length > 1 &&
+                    parentSymbolReflection) {
+                    (0, utils_1.removeIf)(saved, (item) => this.getReflectionById(item)?.parent !==
+                        parentSymbolReflection);
+                }
+            }
         }
     }
     /**
@@ -91,6 +108,9 @@ class ProjectReflection extends container_1.ContainerReflection {
             }
             if (property === abstract_1.TraverseProperty.Children) {
                 (0, utils_1.removeIfPresent)(parent.children, reflection);
+                if (!parent.children?.length) {
+                    delete parent.children;
+                }
             }
             else if (property === abstract_1.TraverseProperty.GetSignature) {
                 delete parent.getSignature;
@@ -100,18 +120,29 @@ class ProjectReflection extends container_1.ContainerReflection {
             }
             else if (property === abstract_1.TraverseProperty.Parameters) {
                 (0, utils_1.removeIfPresent)(reflection.parent.parameters, reflection);
+                if (!reflection.parent.parameters
+                    ?.length) {
+                    delete reflection.parent
+                        .parameters;
+                }
             }
             else if (property === abstract_1.TraverseProperty.SetSignature) {
                 delete parent.setSignature;
             }
             else if (property === abstract_1.TraverseProperty.Signatures) {
                 (0, utils_1.removeIfPresent)(parent.signatures, reflection);
+                if (!parent.signatures?.length) {
+                    delete parent.signatures;
+                }
             }
             else if (property === abstract_1.TraverseProperty.TypeLiteral) {
                 parent.type = new types_1.IntrinsicType("Object");
             }
             else if (property === abstract_1.TraverseProperty.TypeParameter) {
                 (0, utils_1.removeIfPresent)(parent.typeParameters, reflection);
+                if (!parent.typeParameters?.length) {
+                    delete parent.typeParameters;
+                }
             }
             return false; // Stop iteration
         });
@@ -144,9 +175,13 @@ class ProjectReflection extends container_1.ContainerReflection {
         const symbol = this.reflectionIdToSymbolMap.get(reflection.id);
         if (symbol) {
             const id = new ReflectionSymbolId_1.ReflectionSymbolId(symbol);
-            if (this.symbolToReflectionIdMap.get(id) === reflection.id) {
+            const saved = this.symbolToReflectionIdMap.get(id);
+            if (saved === reflection.id) {
                 this.symbolToReflectionIdMap.delete(id);
             }
+            else if (typeof saved === "object") {
+                (0, utils_1.removeIfPresent)(saved, reflection.id);
+            }
         }
         this.reflectionIdToSymbolIdMap.delete(reflection.id);
         delete this.reflections[reflection.id];
@@ -167,13 +202,22 @@ class ProjectReflection extends container_1.ContainerReflection {
     }
     /**
      * Gets the reflection associated with the given symbol id, if it exists.
+     * If there are multiple reflections associated with this symbol, gets the first one.
      * @internal
      */
     getReflectionFromSymbolId(symbolId) {
+        return this.getReflectionsFromSymbolId(symbolId)[0];
+    }
+    /** @internal */
+    getReflectionsFromSymbolId(symbolId) {
         const id = this.symbolToReflectionIdMap.get(symbolId);
         if (typeof id === "number") {
-            return this.getReflectionById(id);
+            return [this.getReflectionById(id)];
+        }
+        else if (typeof id === "object") {
+            return id.map((id) => this.getReflectionById(id));
         }
+        return [];
     }
     /** @internal */
     getSymbolIdFromReflection(reflection) {
@@ -182,7 +226,16 @@ class ProjectReflection extends container_1.ContainerReflection {
     /** @internal */
     registerSymbolId(reflection, id) {
         this.reflectionIdToSymbolIdMap.set(reflection.id, id);
-        if (!this.symbolToReflectionIdMap.has(id)) {
+        const previous = this.symbolToReflectionIdMap.get(id);
+        if (previous) {
+            if (typeof previous === "number") {
+                this.symbolToReflectionIdMap.set(id, [previous, reflection.id]);
+            }
+            else {
+                previous.push(reflection.id);
+            }
+        }
+        else {
             this.symbolToReflectionIdMap.set(id, reflection.id);
         }
     }

package/dist/lib/models/reflections/signature.js

@@ -39,7 +39,7 @@ class SignatureReflection extends abstract_1.Reflection {
             result += "<" + parameters.join(", ") + ">";
         }
         if (this.type) {
-            result += ":" + this.type.toString();
+            result += ": " + this.type.toString();
         }
         return result;
     }

package/dist/lib/models/sources/file.d.ts

@@ -16,7 +16,7 @@ export declare class SourceReference {
      */
     fullFileName: string;
     /**
-     * The number of the line that emitted the declaration.
+     * The one based number of the line that emitted the declaration.
      */
     line: number;
     /**

package/dist/lib/models/types.d.ts

@@ -365,6 +365,11 @@ export declare class ReferenceType extends Type {
      * be registered on the project.
      */
     refersToTypeParameter: boolean;
+    /**
+     * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
+     * values rather than those which represent types.
+     */
+    preferValues: boolean;
     private _target;
     private _project;
     private constructor();