@spyglassmc/mcdoc 0.3.0 → 0.3.2

package/lib/binder/index.js

@@ -1,14 +1,18 @@
-import { AsyncBinder, atArray, Dev, Range, ResourceLocationNode, SymbolUtil, traversePreOrder } from '@spyglassmc/core';
+import { AsyncBinder, atArray, Dev, Range, ResourceLocationNode, SymbolUtil, traversePreOrder, } from '@spyglassmc/core';
 import { localeQuote, localize } from '@spyglassmc/locales';
-import { AttributeNode, AttributeTreeNamedValuesNode, AttributeTreeNode, AttributeTreePosValuesNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, DynamicIndexNode, EnumBlockNode, EnumFieldNode, EnumInjectionNode, EnumNode, FloatRangeNode, IndexBodyNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StaticIndexNode, StringTypeNode, StructBlockNode, StructMapKeyNode, StructNode, StructPairFieldNode, StructSpreadFieldNode, TopLevelNode, TupleTypeNode, TypeAliasNode, TypeBaseNode, TypedNumberNode, TypeParamBlockNode, TypeParamNode, UnionTypeNode, UseStatementNode } from '../node/index.js';
+import { AttributeNode, AttributeTreeNamedValuesNode, AttributeTreeNode, AttributeTreePosValuesNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, DynamicIndexNode, EnumBlockNode, EnumFieldNode, EnumInjectionNode, EnumNode, FloatRangeNode, IndexBodyNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StaticIndexNode, StringTypeNode, StructBlockNode, StructMapKeyNode, StructNode, StructPairFieldNode, StructSpreadFieldNode, TopLevelNode, TupleTypeNode, TypeAliasNode, TypeArgBlockNode, TypeBaseNode, TypedNumberNode, TypeParamBlockNode, TypeParamNode, UnionTypeNode, UseStatementNode, } from '../node/index.js';
 const ModuleSymbolData = Object.freeze({
     is(data) {
-        return !!data && typeof data === 'object' && typeof data.nextAnonymousIndex === 'number';
+        return (!!data &&
+            typeof data === 'object' &&
+            typeof data.nextAnonymousIndex === 'number');
     },
 });
-const TypeDefSymbolData = Object.freeze({
+export const TypeDefSymbolData = Object.freeze({
     is(data) {
-        return !!data && typeof data === 'object' && typeof data.typeDef === 'object';
+        return (!!data &&
+            typeof data === 'object' &&
+            typeof data.typeDef === 'object');
     },
 });
 export const fileModule = AsyncBinder.create(async (node, ctx) => {
@@ -56,7 +60,7 @@ export async function module_(node, ctx) {
  * Hoist enums, structs, type aliases, and use statements under the module scope.
  */
 function hoist(node, ctx) {
-    traversePreOrder(node, () => true, TopLevelNode.is, child => {
+    traversePreOrder(node, () => true, TopLevelNode.is, (child) => {
         switch (child.type) {
             case 'mcdoc:enum':
                 hoistEnum(child);
@@ -73,18 +77,27 @@ function hoist(node, ctx) {
         }
     });
     function hoistEnum(node) {
-        hoistFor('enum', node, EnumNode.destruct, n => ({ typeDef: convertEnum(n, ctx) }));
+        hoistFor('enum', node, EnumNode.destruct, (n) => ({
+            typeDef: convertEnum(n, ctx),
+        }));
     }
     function hoistStruct(node) {
-        hoistFor('struct', node, StructNode.destruct, n => ({ typeDef: convertStruct(n, ctx) }));
+        hoistFor('struct', node, StructNode.destruct, (n) => ({
+            typeDef: convertStruct(n, ctx),
+        }));
     }
     function hoistTypeAlias(node) {
-        hoistFor('type_alias', node, TypeAliasNode.destruct, n => {
-            const { rhs } = TypeAliasNode.destruct(n);
+        hoistFor('type_alias', node, TypeAliasNode.destruct, (n) => {
+            const { attributes, rhs, typeParams } = TypeAliasNode.destruct(n);
             if (!rhs) {
                 return undefined;
             }
-            return { typeDef: convertType(rhs, ctx) };
+            const ans = { typeDef: convertType(rhs, ctx) };
+            if (typeParams) {
+                bindTypeParamBlock(node, typeParams, ans, ctx);
+            }
+            ans.typeDef = attributeType(ans.typeDef, attributes, ctx);
+            return ans;
         });
     }
     function hoistUseStatement(node) {
@@ -103,23 +116,34 @@ function hoist(node, ctx) {
         // they will go to the definition in the imported file.
         ctx.symbols
             .query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${identifier.value}`)
-            .ifDeclared(symbol => reportDuplicatedDeclaration(ctx, symbol, identifier))
+            .ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, identifier))
             .elseEnter({
-            data: { subcategory: 'use_statement_binding', visibility: 1 /* SymbolVisibility.File */ },
+            data: {
+                subcategory: 'use_statement_binding',
+                visibility: 1 /* SymbolVisibility.File */,
+            },
             usage: { type: 'definition', node: identifier, fullRange: node },
         });
     }
     function hoistFor(subcategory, node, destructor, getData) {
-        const { docComments, identifier } = destructor(node);
+        const { docComments, identifier, keyword } = destructor(node);
         const name = identifier?.value ?? nextAnonymousIdentifier(node, ctx);
         ctx.symbols
             .query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${name}`)
-            .ifDeclared(symbol => reportDuplicatedDeclaration(ctx, symbol, identifier ?? node))
+            .ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, identifier ?? node))
             .elseEnter({
-            data: { data: getData(node), desc: DocCommentsNode.asText(docComments), subcategory },
+            data: {
+                data: getData(node),
+                desc: DocCommentsNode.asText(docComments),
+                subcategory,
+            },
             // If the current syntax structure is named, then the identifier node is entered as a definition;
-            // otherwise, an anonymous identifier is generated for the symbol and the whole syntax structure node is entered as a definition.
-            usage: { type: 'definition', node: identifier ?? node, fullRange: identifier && node },
+            // otherwise, an anonymous identifier is generated for the symbol and the keyword node is entered as a definition.
+            usage: {
+                type: 'definition',
+                node: identifier ?? keyword,
+                fullRange: identifier && node,
+            },
         });
     }
     function nextAnonymousIndex(node, ctx) {
@@ -135,41 +159,83 @@ function hoist(node, ctx) {
         return `<anonymous ${nextAnonymousIndex(node, ctx)}>`;
     }
 }
+/**
+ * Bind the type param block of a parent node, and modifies the `data` argument in-place to change its `typeDef` to be of template kind.
+ */
+function bindTypeParamBlock(node, typeParams, data, ctx) {
+    // Type parameters are added as local symbols on the type alias AST node.
+    // Thus we create a new local scope on the type alias statement node first.
+    node.locals = Object.create(null);
+    // They are also added to the type definition.
+    data.typeDef = {
+        kind: 'template',
+        child: data.typeDef,
+        typeParams: [],
+    };
+    const { params } = TypeParamBlockNode.destruct(typeParams);
+    for (const param of params) {
+        const { identifier: paramIdentifier } = TypeParamNode.destruct(param);
+        if (paramIdentifier.value) {
+            // Add the type parameter as a local symbol.
+            const paramPath = `${ctx.moduleIdentifier}::${paramIdentifier.value}`;
+            ctx.symbols
+                .query({ doc: ctx.doc, node }, 'mcdoc', paramPath)
+                .ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, paramIdentifier))
+                .elseEnter({
+                data: { visibility: 0 /* SymbolVisibility.Block */ },
+                usage: {
+                    type: 'declaration',
+                    node: paramIdentifier,
+                    fullRange: param,
+                },
+            });
+            // Also add it to the type definition.
+            data.typeDef.typeParams.push({ path: paramPath });
+        }
+        // if (constraint) {
+        // 	await bindPath(constraint, ctx)
+        // }
+    }
+}
 async function bindDispatchStatement(node, ctx) {
-    const { attributes, location, index, target } = DispatchStatementNode.destruct(node);
+    const { attributes, location, index, target, typeParams } = DispatchStatementNode.destruct(node);
     if (!(location && index && target)) {
         return;
     }
     const locationStr = ResourceLocationNode.toString(location, 'full');
-    ctx.symbols
-        .query(ctx.doc, 'mcdoc/dispatcher', locationStr)
-        .enter({
+    ctx.symbols.query(ctx.doc, 'mcdoc/dispatcher', locationStr).enter({
         usage: { type: 'reference', node: location, fullRange: node },
     });
     const { parallelIndices } = IndexBodyNode.destruct(index);
-    for (const key of parallelIndices) {
-        if (DynamicIndexNode.is(key)) {
-            // Ignore dynamic indices in dispatch statements.
-            continue;
+    if (parallelIndices.length) {
+        const data = {
+            typeDef: convertType(target, ctx),
+        };
+        if (typeParams) {
+            bindTypeParamBlock(node, typeParams, data, ctx);
+        }
+        data.typeDef = attributeType(data.typeDef, attributes, ctx);
+        for (const key of parallelIndices) {
+            if (DynamicIndexNode.is(key)) {
+                // Ignore dynamic indices in dispatch statements.
+                continue;
+            }
+            ctx.symbols
+                .query(ctx.doc, 'mcdoc/dispatcher', locationStr, asString(key))
+                .ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, key, {
+                localeString: 'mcdoc.binder.dispatcher-statement.duplicated-key',
+            }))
+                .elseEnter({
+                data: { data },
+                usage: { type: 'definition', node: key, fullRange: node },
+            });
         }
-        ctx.symbols
-            .query(ctx.doc, 'mcdoc/dispatcher', locationStr, asString(key))
-            .ifDeclared(symbol => reportDuplicatedDeclaration(ctx, symbol, key, { localeString: 'mcdoc.binder.dispatcher-statement.duplicated-key.related' }))
-            .elseEnter({
-            data: {
-                data: {
-                    attributes: convertAttributes(attributes, ctx),
-                    typeDef: convertType(target, ctx),
-                },
-            },
-            usage: { type: 'definition', node: key, fullRange: node },
-        });
     }
     await bindType(target, ctx);
 }
 async function bindType(node, ctx) {
     if (DispatcherTypeNode.is(node)) {
-        bindDispatcherType(node, ctx);
+        await bindDispatcherType(node, ctx);
     }
     else if (EnumNode.is(node)) {
         bindEnum(node, ctx);
@@ -179,11 +245,8 @@ async function bindType(node, ctx) {
         await bindType(item, ctx);
     }
     else if (ReferenceTypeNode.is(node)) {
-        const { path, typeParameters } = ReferenceTypeNode.destruct(node);
+        const { path } = ReferenceTypeNode.destruct(node);
         await bindPath(path, ctx);
-        for (const param of typeParameters) {
-            await bindType(param, ctx);
-        }
     }
     else if (StructNode.is(node)) {
         await bindStruct(node, ctx);
@@ -200,10 +263,22 @@ async function bindType(node, ctx) {
             await bindType(member, ctx);
         }
     }
+    const { appendixes } = TypeBaseNode.destruct(node);
+    for (const appendix of appendixes) {
+        if (TypeArgBlockNode.is(appendix)) {
+            const { args } = TypeArgBlockNode.destruct(appendix);
+            for (const arg of args) {
+                await bindType(arg, ctx);
+            }
+        }
+    }
 }
-function bindDispatcherType(node, ctx) {
+async function bindDispatcherType(node, ctx) {
     const { index, location } = DispatcherTypeNode.destruct(node);
     const locationStr = ResourceLocationNode.toString(location, 'full');
+    ctx.symbols
+        .query(ctx.doc, 'mcdoc/dispatcher', locationStr)
+        .enter({ usage: { type: 'reference', node: location, fullRange: node } });
     const { parallelIndices } = IndexBodyNode.destruct(index);
     for (const key of parallelIndices) {
         if (DynamicIndexNode.is(key)) {
@@ -226,7 +301,7 @@ async function bindPath(node, ctx) {
             const referencedModuleFile = pathArrayToString(identifiers);
             const referencedModuleUri = identifierToUri(referencedModuleFile, ctx);
             if (!referencedModuleUri) {
-                ctx.err.report(localize('mcdoc.binder.path.unknown-module', localeQuote(referencedModuleFile)), node);
+                ctx.err.report(localize('mcdoc.binder.path.unknown-module', localeQuote(referencedModuleFile)), node, 2 /* ErrorSeverity.Warning */);
                 return;
             }
             await ctx.ensureBindingStarted(referencedModuleUri);
@@ -234,18 +309,23 @@ async function bindPath(node, ctx) {
         ctx.symbols
             .query({ doc: ctx.doc, node: identNode }, 'mcdoc', pathArrayToString(identifiers))
             .ifDeclared((_, query) => query.enter({
-            usage: { type: 'reference', node: identNode, fullRange: node, skipRenaming: LiteralNode.is(identNode) },
+            usage: {
+                type: 'reference',
+                node: identNode,
+                fullRange: node,
+                skipRenaming: LiteralNode.is(identNode),
+            },
         }))
             .else(() => {
             if (indexRight === 0) {
-                ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(atArray(identifiers, -1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node);
+                ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(atArray(identifiers, -1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node, 2 /* ErrorSeverity.Warning */);
             }
         });
     }
 }
 function bindEnum(node, ctx) {
-    const { block, identifier } = EnumNode.destruct(node);
-    const symbol = identifier?.symbol ?? node.symbol;
+    const { block, identifier, keyword } = EnumNode.destruct(node);
+    const symbol = identifier?.symbol ?? keyword.symbol;
     if (symbol?.subcategory !== 'enum') {
         return;
     }
@@ -257,9 +337,11 @@ function bindEnumBlock(node, ctx, query, options = {}) {
     const { fields } = EnumBlockNode.destruct(node);
     for (const field of fields) {
         const { identifier } = EnumFieldNode.destruct(field);
-        query.member(identifier.value, fieldQuery => fieldQuery
-            .ifDeclared(symbol => reportDuplicatedDeclaration(ctx, symbol, identifier))
-            .elseEnter({ usage: { type: 'definition', node: identifier, fullRange: field } }));
+        query.member(identifier.value, (fieldQuery) => fieldQuery
+            .ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, identifier))
+            .elseEnter({
+            usage: { type: 'definition', node: identifier, fullRange: field },
+        }));
     }
 }
 async function bindInjection(node, ctx) {
@@ -271,8 +353,8 @@ async function bindInjection(node, ctx) {
     }
 }
 async function bindStruct(node, ctx) {
-    const { block, identifier } = StructNode.destruct(node);
-    const symbol = identifier?.symbol ?? node.symbol;
+    const { block, identifier, keyword } = StructNode.destruct(node);
+    const symbol = identifier?.symbol ?? keyword.symbol;
     if (symbol?.subcategory !== 'struct') {
         return;
     }
@@ -286,9 +368,11 @@ async function bindStructBlock(node, ctx, query, options = {}) {
         if (StructPairFieldNode.is(field)) {
             const { key, type } = StructPairFieldNode.destruct(field);
             if (!StructMapKeyNode.is(key)) {
-                query.member(key.value, fieldQuery => fieldQuery
-                    .ifDeclared(symbol => reportDuplicatedDeclaration(ctx, symbol, key))
-                    .elseEnter({ usage: { type: 'definition', node: key, fullRange: field } }));
+                query.member(key.value, (fieldQuery) => fieldQuery
+                    .ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, key))
+                    .elseEnter({
+                    usage: { type: 'definition', node: key, fullRange: field },
+                }));
             }
             await bindType(type, ctx);
         }
@@ -303,39 +387,6 @@ async function bindTypeAlias(node, ctx) {
     if (!identifier?.value) {
         return;
     }
-    if (typeParams) {
-        // Type parameters are added as local symbols on the type alias AST node.
-        node.locals = Object.create(null);
-        const { params } = TypeParamBlockNode.destruct(typeParams);
-        const query = ctx.symbols.query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${identifier.value}`);
-        if (query.symbol?.subcategory === 'type_alias') {
-            // Type parameters are also added to the symbol data.
-            const oldData = query.symbol.data;
-            if (!TypeDefSymbolData.is(oldData)) {
-                throw new Error('Failed to locate the typeDef data associated with a supposedly hoisted type alias symbol');
-            }
-            const data = {
-                ...oldData,
-                typeParams: [],
-            };
-            query.symbol.data = data;
-            for (const param of params) {
-                const { identifier: paramIdentifier } = TypeParamNode.destruct(param);
-                if (paramIdentifier.value) {
-                    // Add the type parameter as a local symbol.
-                    ctx.symbols
-                        .query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${paramIdentifier.value}`)
-                        .ifDeclared(symbol => reportDuplicatedDeclaration(ctx, symbol, paramIdentifier))
-                        .elseEnter({ data: { visibility: 0 /* SymbolVisibility.Block */ }, usage: { type: 'declaration', node: paramIdentifier, fullRange: param } });
-                    // Also add it to the symbol data.
-                    data.typeParams.push({ identifier: paramIdentifier.value });
-                }
-                // if (constraint) {
-                // 	await bindPath(constraint, ctx)
-                // }
-            }
-        }
-    }
     if (rhs) {
         await bindType(rhs, ctx);
     }
@@ -352,10 +403,12 @@ export function registerMcdocBinders(meta) {
 }
 function reportDuplicatedDeclaration(ctx, symbol, range, options = { localeString: 'mcdoc.binder.duplicated-declaration' }) {
     ctx.err.report(localize(options.localeString, localeQuote(symbol.identifier)), range, 2 /* ErrorSeverity.Warning */, {
-        related: [{
+        related: [
+            {
                 location: SymbolUtil.getDeclaredLocation(symbol),
                 message: localize(`${options.localeString}.related`, localeQuote(symbol.identifier)),
-            }],
+            },
+        ],
     });
 }
 function* resolvePathByStep(path, ctx, options = {}) {
@@ -381,7 +434,12 @@ function* resolvePathByStep(path, ctx, options = {}) {
             default:
                 Dev.assertNever(child);
         }
-        yield { identifiers, node: child, index: i, indexRight: children.length - 1 - i };
+        yield {
+            identifiers,
+            node: child,
+            index: i,
+            indexRight: children.length - 1 - i,
+        };
     }
 }
 function resolvePath(path, ctx, options = {}) {
@@ -391,43 +449,84 @@ function identifierToUri(module, ctx) {
     return ctx.symbols.global.mcdoc?.[module]?.definition?.[0]?.uri;
 }
 function uriToIdentifier(uri, ctx) {
-    return Object
-        .values(ctx.symbols.global.mcdoc ?? {})
-        .find(symbol => {
-        return symbol.subcategory === 'module' && symbol.definition?.some(loc => loc.uri === uri);
-    })
-        ?.identifier;
+    return Object.values(ctx.symbols.global.mcdoc ?? {}).find((symbol) => {
+        return (symbol.subcategory === 'module' &&
+            symbol.definition?.some((loc) => loc.uri === uri));
+    })?.identifier;
 }
 function pathArrayToString(path) {
     return path ? `::${path.join('::')}` : undefined;
 }
 function convertType(node, ctx) {
     switch (node.type) {
-        case 'mcdoc:enum': return convertEnum(node, ctx);
-        case 'mcdoc:struct': return convertStruct(node, ctx);
-        case 'mcdoc:type/any': return convertAny(node, ctx);
-        case 'mcdoc:type/boolean': return convertBoolean(node, ctx);
-        case 'mcdoc:type/dispatcher': return convertDispatcher(node, ctx);
-        case 'mcdoc:type/list': return convertList(node, ctx);
-        case 'mcdoc:type/literal': return convertLiteral(node, ctx);
-        case 'mcdoc:type/numeric_type': return convertNumericType(node, ctx);
-        case 'mcdoc:type/primitive_array': return convertPrimitiveArray(node, ctx);
-        case 'mcdoc:type/string': return convertString(node, ctx);
-        case 'mcdoc:type/reference': return convertReference(node, ctx);
-        case 'mcdoc:type/tuple': return convertTuple(node, ctx);
-        case 'mcdoc:type/union': return convertUnion(node, ctx);
-        default: return Dev.assertNever(node);
-    }
-}
-function convertBase(node, ctx, options = {}) {
-    const { attributes, indices } = TypeBaseNode.destruct(node);
-    return {
-        attributes: convertAttributes(attributes, ctx),
-        indices: convertIndexBodies(options.skipFirstIndexBody ? indices.slice(1) : indices, ctx),
-    };
+        case 'mcdoc:enum':
+            return convertEnum(node, ctx);
+        case 'mcdoc:struct':
+            return convertStruct(node, ctx);
+        case 'mcdoc:type/any':
+            return convertAny(node, ctx);
+        case 'mcdoc:type/boolean':
+            return convertBoolean(node, ctx);
+        case 'mcdoc:type/dispatcher':
+            return convertDispatcher(node, ctx);
+        case 'mcdoc:type/list':
+            return convertList(node, ctx);
+        case 'mcdoc:type/literal':
+            return convertLiteral(node, ctx);
+        case 'mcdoc:type/numeric_type':
+            return convertNumericType(node, ctx);
+        case 'mcdoc:type/primitive_array':
+            return convertPrimitiveArray(node, ctx);
+        case 'mcdoc:type/string':
+            return convertString(node, ctx);
+        case 'mcdoc:type/reference':
+            return convertReference(node, ctx);
+        case 'mcdoc:type/tuple':
+            return convertTuple(node, ctx);
+        case 'mcdoc:type/union':
+            return convertUnion(node, ctx);
+        default:
+            return Dev.assertNever(node);
+    }
+}
+function wrapType(node, type, ctx, options = {}) {
+    const { attributes, appendixes } = TypeBaseNode.destruct(node);
+    let ans = type;
+    for (const appendix of appendixes) {
+        if (IndexBodyNode.is(appendix)) {
+            if (options.skipFirstIndexBody) {
+                options.skipFirstIndexBody = false;
+                continue;
+            }
+            ans = {
+                kind: 'indexed',
+                child: ans,
+                parallelIndices: convertIndexBody(appendix, ctx),
+            };
+        }
+        else {
+            ans = {
+                kind: 'concrete',
+                child: ans,
+                typeArgs: convertTypeArgBlock(appendix, ctx),
+            };
+        }
+    }
+    ans = attributeType(ans, attributes, ctx);
+    return ans;
+}
+function attributeType(type, attributes, ctx) {
+    for (const attribute of attributes) {
+        type = {
+            kind: 'attributed',
+            attribute: convertAttribute(attribute, ctx),
+            child: type,
+        };
+    }
+    return type;
 }
 function convertAttributes(nodes, ctx) {
-    return undefineEmptyArray(nodes.map(n => convertAttribute(n, ctx)));
+    return undefineEmptyArray(nodes.map((n) => convertAttribute(n, ctx)));
 }
 function undefineEmptyArray(array) {
     return array.length ? array : undefined;
@@ -468,11 +567,11 @@ function convertAttributeTree(node, ctx) {
     return ans;
 }
 function convertIndexBodies(nodes, ctx) {
-    return undefineEmptyArray(nodes.map(n => convertIndexBody(n, ctx)));
+    return undefineEmptyArray(nodes.map((n) => convertIndexBody(n, ctx)));
 }
 function convertIndexBody(node, ctx) {
     const { parallelIndices } = IndexBodyNode.destruct(node);
-    return parallelIndices.map(n => convertIndex(n, ctx));
+    return parallelIndices.map((n) => convertIndex(n, ctx));
 }
 function convertIndex(node, ctx) {
     return StaticIndexNode.is(node)
@@ -492,23 +591,28 @@ function convertDynamicIndex(node, ctx) {
         accessor: keys.map(asString),
     };
 }
+function convertTypeArgBlock(node, ctx) {
+    const { args } = TypeArgBlockNode.destruct(node);
+    return args.map((a) => convertType(a, ctx));
+}
 function convertEnum(node, ctx) {
     const { block, enumKind, identifier } = EnumNode.destruct(node);
     // Shortcut if the typeDef has been added to the enum symbol.
     const symbol = identifier?.symbol ?? node.symbol;
-    if (symbol && TypeDefSymbolData.is(symbol.data) && symbol.data.typeDef.kind === 'enum') {
+    if (symbol &&
+        TypeDefSymbolData.is(symbol.data) &&
+        symbol.data.typeDef.kind === 'enum') {
         return symbol.data.typeDef;
     }
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'enum',
         enumKind,
         values: convertEnumBlock(block, ctx),
-    };
+    }, ctx);
 }
 function convertEnumBlock(node, ctx) {
     const { fields } = EnumBlockNode.destruct(node);
-    return fields.map(n => convertEnumField(n, ctx));
+    return fields.map((n) => convertEnumField(n, ctx));
 }
 function convertEnumField(node, ctx) {
     const { attributes, identifier, value } = EnumFieldNode.destruct(node);
@@ -529,18 +633,19 @@ function convertStruct(node, ctx) {
     const { block, identifier } = StructNode.destruct(node);
     // Shortcut if the typeDef has been added to the struct symbol.
     const symbol = identifier?.symbol ?? node.symbol;
-    if (symbol && TypeDefSymbolData.is(symbol.data) && symbol.data.typeDef.kind === 'struct') {
+    if (symbol &&
+        TypeDefSymbolData.is(symbol.data) &&
+        symbol.data.typeDef.kind === 'struct') {
         return symbol.data.typeDef;
     }
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'struct',
         fields: convertStructBlock(block, ctx),
-    };
+    }, ctx);
 }
 function convertStructBlock(node, ctx) {
     const { fields } = StructBlockNode.destruct(node);
-    return fields.map(n => convertStructField(n, ctx));
+    return fields.map((n) => convertStructField(n, ctx));
 }
 function convertStructField(node, ctx) {
     return StructPairFieldNode.is(node)
@@ -575,51 +680,46 @@ function convertStructSpreadField(node, ctx) {
     };
 }
 function convertAny(node, ctx) {
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'any',
-    };
+    }, ctx);
 }
 function convertBoolean(node, ctx) {
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'boolean',
-    };
+    }, ctx);
 }
 function convertDispatcher(node, ctx) {
     const { index, location } = DispatcherTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx, {
-            skipFirstIndexBody: true,
-        }),
+    return wrapType(node, {
         kind: 'dispatcher',
-        index: convertIndexBody(index, ctx),
+        parallelIndices: convertIndexBody(index, ctx),
         registry: ResourceLocationNode.toString(location, 'full'),
-    };
+    }, ctx, { skipFirstIndexBody: true });
 }
 function convertList(node, ctx) {
     const { item, lengthRange } = ListTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'list',
         item: convertType(item, ctx),
         lengthRange: convertRange(lengthRange, ctx),
-    };
+    }, ctx);
 }
 function convertRange(node, ctx) {
     if (!node) {
         return undefined;
     }
-    const { kind, min, max } = FloatRangeNode.is(node) ? FloatRangeNode.destruct(node) : IntRangeNode.destruct(node);
+    const { kind, min, max } = FloatRangeNode.is(node)
+        ? FloatRangeNode.destruct(node)
+        : IntRangeNode.destruct(node);
     return { kind, min: min?.value, max: max?.value };
 }
 function convertLiteral(node, ctx) {
     const { value } = LiteralTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'literal',
         value: convertLiteralValue(value, ctx),
-    };
+    }, ctx);
 }
 function convertLiteralValue(node, ctx) {
     if (LiteralNode.is(node)) {
@@ -649,53 +749,46 @@ function convertLiteralNumberSuffix(node, ctx) {
 }
 function convertNumericType(node, ctx) {
     const { numericKind, valueRange } = NumericTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: numericKind.value,
         valueRange: convertRange(valueRange, ctx),
-    };
+    }, ctx);
 }
 function convertPrimitiveArray(node, ctx) {
     const { arrayKind, lengthRange, valueRange } = PrimitiveArrayTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: `${arrayKind.value}_array`,
         lengthRange: convertRange(lengthRange, ctx),
         valueRange: convertRange(valueRange, ctx),
-    };
+    }, ctx);
 }
 function convertString(node, ctx) {
     const { lengthRange } = StringTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'string',
         lengthRange: convertRange(lengthRange, ctx),
-    };
+    }, ctx);
 }
 function convertReference(node, ctx) {
-    const { path, typeParameters } = ReferenceTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    const { path } = ReferenceTypeNode.destruct(node);
+    return wrapType(node, {
         kind: 'reference',
         path: pathArrayToString(resolvePath(path, ctx)),
-        typeParameters: undefineEmptyArray(typeParameters.map(n => convertType(n, ctx))),
-    };
+    }, ctx);
 }
 function convertTuple(node, ctx) {
     const { items } = TupleTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'tuple',
-        items: items.map(n => convertType(n, ctx)),
-    };
+        items: items.map((n) => convertType(n, ctx)),
+    }, ctx);
 }
 function convertUnion(node, ctx) {
     const { members } = UnionTypeNode.destruct(node);
-    return {
-        ...convertBase(node, ctx),
+    return wrapType(node, {
         kind: 'union',
-        members: members.map(n => convertType(n, ctx)),
-    };
+        members: members.map((n) => convertType(n, ctx)),
+    }, ctx);
 }
 function asString(node) {
     if (ResourceLocationNode.is(node)) {