@spyglassmc/mcdoc 0.3.7 → 0.3.9

package/lib/binder/index.js

@@ -4,18 +4,18 @@ import { AttributeNode, AttributeTreeNamedValuesNode, AttributeTreeNode, Attribu
 var ModuleSymbolData;
 (function (ModuleSymbolData) {
     function is(data) {
-        return (!!data &&
-            typeof data === 'object' &&
-            typeof data.nextAnonymousIndex === 'number');
+        return (!!data
+            && typeof data === 'object'
+            && typeof data.nextAnonymousIndex === 'number');
     }
     ModuleSymbolData.is = is;
 })(ModuleSymbolData || (ModuleSymbolData = {}));
 export var TypeDefSymbolData;
 (function (TypeDefSymbolData) {
     function is(data) {
-        return (!!data &&
-            typeof data === 'object' &&
-            typeof data.typeDef === 'object');
+        return (!!data
+            && typeof data === 'object'
+            && typeof data.typeDef === 'object');
     }
     TypeDefSymbolData.is = is;
 })(TypeDefSymbolData || (TypeDefSymbolData = {}));
@@ -25,17 +25,14 @@ export const fileModule = AsyncBinder.create(async (node, ctx) => {
         ctx.err.report(localize('mcdoc.binder.out-of-root', localeQuote(ctx.doc.uri)), Range.Beginning, 0 /* ErrorSeverity.Hint */);
         return;
     }
-    const mcdocCtx = {
-        ...ctx,
-        moduleIdentifier,
-    };
+    const mcdocCtx = { ...ctx, moduleIdentifier };
     return module_(node, mcdocCtx);
 });
 export async function module_(node, ctx) {
     const data = { nextAnonymousIndex: 0 };
-    ctx.symbols
-        .query({ doc: ctx.doc, node }, 'mcdoc', ctx.moduleIdentifier)
-        .amend({ data: { data } });
+    ctx.symbols.query({ doc: ctx.doc, node }, 'mcdoc', ctx.moduleIdentifier).amend({
+        data: { data },
+    });
     hoist(node, ctx);
     for (const child of node.children) {
         switch (child.type) {
@@ -81,14 +78,10 @@ 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) => {
@@ -100,7 +93,7 @@ function hoist(node, ctx) {
             if (typeParams) {
                 bindTypeParamBlock(node, typeParams, ans, ctx);
             }
-            ans.typeDef = attributeType(ans.typeDef, attributes, ctx);
+            appendAttributes(ans.typeDef, attributes, ctx);
             return ans;
         });
     }
@@ -115,16 +108,15 @@ function hoist(node, ctx) {
             return;
         }
         // hoistUseStatement associates the AST node with the binding definition in the file symbol table,
-        // which may get overridden by bindUseStatement in the later stage as an reference to the imported symbol in the global symbol table.
+        // which will get overridden by bindUseStatement in the later stage as an reference to the imported symbol in the global symbol table.
         // This way when the user tries to go to definition on the path in the use statement,
         // 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))
-            .elseEnter({
+        const target = resolvePath(path, ctx);
+        ctx.symbols.query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${identifier.value}`).ifDeclared((symbol) => reportDuplicatedDeclaration(ctx, symbol, identifier)).elseEnter({
             data: {
                 subcategory: 'use_statement_binding',
                 visibility: 1 /* SymbolVisibility.File */,
+                data: target ? { target } : undefined,
             },
             usage: { type: 'definition', node: identifier, fullRange: node },
         });
@@ -132,15 +124,10 @@ function hoist(node, ctx) {
     function hoistFor(subcategory, node, destructor, getData) {
         const { docComments, identifier, keyword } = destructor(node);
         const name = identifier?.value ?? nextAnonymousIdentifier(node, ctx);
-        ctx.symbols
-            .query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${name}`)
+        ctx.symbols.query({ doc: ctx.doc, node }, 'mcdoc', `${ctx.moduleIdentifier}::${name}`)
             .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 keyword node is entered as a definition.
             usage: {
@@ -151,9 +138,7 @@ function hoist(node, ctx) {
         });
     }
     function nextAnonymousIndex(node, ctx) {
-        const data = ctx.symbols
-            .query({ doc: ctx.doc, node }, 'mcdoc', ctx.moduleIdentifier)
-            .getData(ModuleSymbolData.is);
+        const data = ctx.symbols.query({ doc: ctx.doc, node }, 'mcdoc', ctx.moduleIdentifier).getData(ModuleSymbolData.is);
         if (!data) {
             throw new Error(`No symbol data for module '${ctx.moduleIdentifier}'`);
         }
@@ -171,27 +156,16 @@ function bindTypeParamBlock(node, typeParams, data, ctx) {
     // 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: [],
-    };
+    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({
+            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,
-                },
+                usage: { type: 'declaration', node: paramIdentifier, fullRange: param },
             });
             // Also add it to the type definition.
             data.typeDef.typeParams.push({ path: paramPath });
@@ -212,27 +186,19 @@ async function bindDispatchStatement(node, ctx) {
     });
     const { parallelIndices } = IndexBodyNode.destruct(index);
     if (parallelIndices.length) {
-        const data = {
-            typeDef: convertType(target, ctx),
-        };
+        const data = { typeDef: convertType(target, ctx) };
         if (typeParams) {
             bindTypeParamBlock(node, typeParams, data, ctx);
         }
-        data.typeDef = attributeType(data.typeDef, attributes, ctx);
+        appendAttributes(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, {
+            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 },
-            });
+            })).elseEnter({ data: { data }, usage: { type: 'definition', node: key, fullRange: node } });
         }
     }
     await bindType(target, ctx);
@@ -280,9 +246,9 @@ async function bindType(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 } });
+    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)) {
@@ -290,13 +256,15 @@ async function bindDispatcherType(node, ctx) {
             // of struct keys, it is rather complicated to do so. We will ignore them for now.
             continue;
         }
-        ctx.symbols
-            .query(ctx.doc, 'mcdoc/dispatcher', locationStr, asString(key))
-            .enter({ usage: { type: 'reference', node: key, fullRange: node } });
+        ctx.symbols.query(ctx.doc, 'mcdoc/dispatcher', locationStr, asString(key)).enter({
+            usage: { type: 'reference', node: key, fullRange: node },
+        });
     }
 }
 async function bindPath(node, ctx) {
-    for (const { identifiers, node: identNode, indexRight } of resolvePathByStep(node, ctx, { reportErrors: true })) {
+    for (const { identifiers, node: identNode, indexRight } of resolvePathByStep(node, ctx, {
+        reportErrors: true,
+    })) {
         if (!identifiers?.length) {
             continue;
         }
@@ -310,8 +278,7 @@ async function bindPath(node, ctx) {
             }
             await ctx.ensureBindingStarted(referencedModuleUri);
         }
-        ctx.symbols
-            .query({ doc: ctx.doc, node: identNode }, 'mcdoc', pathArrayToString(identifiers))
+        ctx.symbols.query({ doc: ctx.doc, node: identNode }, 'mcdoc', pathArrayToString(identifiers))
             .ifDeclared((_, query) => query.enter({
             usage: {
                 type: 'reference',
@@ -319,8 +286,7 @@ async function bindPath(node, ctx) {
                 fullRange: node,
                 skipRenaming: LiteralNode.is(identNode),
             },
-        }))
-            .else(() => {
+        })).else(() => {
             if (indexRight === 0) {
                 ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(atArray(identifiers, -1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node, 2 /* ErrorSeverity.Warning */);
             }
@@ -341,15 +307,8 @@ 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) {
@@ -376,11 +335,8 @@ 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);
         }
@@ -411,23 +367,34 @@ 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 = {}) {
     const { children, isAbsolute } = PathNode.destruct(path);
-    const identifiers = isAbsolute
-        ? []
-        : ctx.moduleIdentifier.slice(2).split('::');
+    let identifiers = isAbsolute ? [] : pathStringToArray(ctx.moduleIdentifier);
     for (const [i, child] of children.entries()) {
+        const indexRight = children.length - 1 - i;
         switch (child.type) {
             case 'mcdoc:identifier':
+                // For a path node with `n` children, the first `n-1` child nodes specify
+                // the path of the module that contains the symbol. They will be pushed
+                // to the `identifiers` array and yielded as-is. The last node, however,
+                // may be created by a use statement and points to a global symbol
+                // in a different file. We will query the symbol table and rewrite
+                // the `identifiers` array to be the target path if needed.
                 identifiers.push(child.value);
+                if (indexRight === 0) {
+                    ctx.symbols.query({ doc: ctx.doc, node: child }, 'mcdoc', pathArrayToString(identifiers)).ifDeclared((symbol) => {
+                        const data = symbol.data;
+                        if (data?.target) {
+                            identifiers = [...data.target];
+                        }
+                    });
+                }
                 break;
             case 'mcdoc:literal':
                 // super
@@ -442,12 +409,7 @@ 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 };
     }
 }
 function resolvePath(path, ctx, options = {}) {
@@ -458,13 +420,18 @@ function identifierToUri(module, ctx) {
 }
 function uriToIdentifier(uri, ctx) {
     return Object.values(ctx.symbols.global.mcdoc ?? {}).find((symbol) => {
-        return (symbol.subcategory === 'module' &&
-            symbol.definition?.some((loc) => loc.uri === uri));
+        return (symbol.subcategory === 'module' && symbol.definition?.some((loc) => loc.uri === uri));
     })?.identifier;
 }
 function pathArrayToString(path) {
     return path ? `::${path.join('::')}` : undefined;
 }
+function pathStringToArray(path) {
+    if (!path.startsWith('::')) {
+        throw new Error('Only absolute paths are supported');
+    }
+    return path.slice(2).split('::');
+}
 function convertType(node, ctx) {
     switch (node.type) {
         case 'mcdoc:enum':
@@ -506,32 +473,25 @@ function wrapType(node, type, ctx, options = {}) {
                 options.skipFirstIndexBody = false;
                 continue;
             }
-            ans = {
-                kind: 'indexed',
-                child: ans,
-                parallelIndices: convertIndexBody(appendix, ctx),
-            };
+            ans = { kind: 'indexed', child: ans, parallelIndices: convertIndexBody(appendix, ctx) };
         }
         else {
-            ans = {
-                kind: 'concrete',
-                child: ans,
-                typeArgs: convertTypeArgBlock(appendix, ctx),
-            };
+            ans = { kind: 'concrete', child: ans, typeArgs: convertTypeArgBlock(appendix, ctx) };
         }
     }
-    ans = attributeType(ans, attributes, ctx);
+    ans.attributes = convertAttributes(attributes, ctx);
     return ans;
 }
-function attributeType(type, attributes, ctx) {
-    for (const attribute of attributes) {
-        type = {
-            kind: 'attributed',
-            attribute: convertAttribute(attribute, ctx),
-            child: type,
-        };
+function appendAttributes(typeDef, attributes, ctx) {
+    const convertedAttributes = convertAttributes(attributes, ctx);
+    if (convertedAttributes) {
+        if (typeDef.attributes) {
+            typeDef.attributes = [...typeDef.attributes, ...convertedAttributes];
+        }
+        else {
+            typeDef.attributes = convertedAttributes;
+        }
     }
-    return type;
 }
 function convertAttributes(nodes, ctx) {
     return undefineEmptyArray(nodes.map((n) => convertAttribute(n, ctx)));
@@ -541,17 +501,11 @@ function undefineEmptyArray(array) {
 }
 function convertAttribute(node, ctx) {
     const { name, value } = AttributeNode.destruct(node);
-    return {
-        name: name.value,
-        value: value && convertAttributeValue(value, ctx),
-    };
+    return { name: name.value, value: value && convertAttributeValue(value, ctx) };
 }
 function convertAttributeValue(node, ctx) {
     if (node.type === 'mcdoc:attribute/tree') {
-        return {
-            kind: 'tree',
-            values: convertAttributeTree(node, ctx),
-        };
+        return { kind: 'tree', values: convertAttributeTree(node, ctx) };
     }
     else {
         return convertType(node, ctx);
@@ -582,21 +536,21 @@ function convertIndexBody(node, ctx) {
     return parallelIndices.map((n) => convertIndex(n, ctx));
 }
 function convertIndex(node, ctx) {
-    return StaticIndexNode.is(node)
-        ? convertStaticIndex(node, ctx)
-        : convertDynamicIndex(node, ctx);
+    return StaticIndexNode.is(node) ? convertStaticIndex(node, ctx) : convertDynamicIndex(node, ctx);
 }
 function convertStaticIndex(node, ctx) {
-    return {
-        kind: 'static',
-        value: asString(node),
-    };
+    return { kind: 'static', value: asString(node) };
 }
 function convertDynamicIndex(node, ctx) {
     const { keys } = DynamicIndexNode.destruct(node);
     return {
         kind: 'dynamic',
-        accessor: keys.map(asString),
+        accessor: keys.map(key => {
+            if (LiteralNode.is(key) && key.value.startsWith('%')) {
+                return { keyword: key.value.slice(1) };
+            }
+            return asString(key);
+        }),
     };
 }
 function convertTypeArgBlock(node, ctx) {
@@ -607,16 +561,10 @@ 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 wrapType(node, {
-        kind: 'enum',
-        enumKind,
-        values: convertEnumBlock(block, ctx),
-    }, ctx);
+    return wrapType(node, { kind: 'enum', enumKind, values: convertEnumBlock(block, ctx) }, ctx);
 }
 function convertEnumBlock(node, ctx) {
     const { fields } = EnumBlockNode.destruct(node);
@@ -641,15 +589,10 @@ 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 wrapType(node, {
-        kind: 'struct',
-        fields: convertStructBlock(block, ctx),
-    }, ctx);
+    return wrapType(node, { kind: 'struct', fields: convertStructBlock(block, ctx) }, ctx);
 }
 function convertStructBlock(node, ctx) {
     const { fields } = StructBlockNode.destruct(node);
@@ -661,10 +604,11 @@ function convertStructField(node, ctx) {
         : convertStructSpreadField(node, ctx);
 }
 function convertStructPairField(node, ctx) {
-    const { attributes, key, type, isOptional } = StructPairFieldNode.destruct(node);
+    const { attributes, docComments, key, type, isOptional } = StructPairFieldNode.destruct(node);
     return {
         kind: 'pair',
         attributes: convertAttributes(attributes, ctx),
+        desc: DocCommentsNode.asText(docComments),
         key: convertStructKey(key, ctx),
         type: convertType(type, ctx),
         optional: isOptional,
@@ -688,14 +632,10 @@ function convertStructSpreadField(node, ctx) {
     };
 }
 function convertAny(node, ctx) {
-    return wrapType(node, {
-        kind: 'any',
-    }, ctx);
+    return wrapType(node, { kind: 'any' }, ctx);
 }
 function convertBoolean(node, ctx) {
-    return wrapType(node, {
-        kind: 'boolean',
-    }, ctx);
+    return wrapType(node, { kind: 'boolean' }, ctx);
 }
 function convertDispatcher(node, ctx) {
     const { index, location } = DispatcherTypeNode.destruct(node);
@@ -724,36 +664,40 @@ function convertRange(node, ctx) {
 }
 function convertLiteral(node, ctx) {
     const { value } = LiteralTypeNode.destruct(node);
-    return wrapType(node, {
-        kind: 'literal',
-        value: convertLiteralValue(value, ctx),
-    }, ctx);
+    return wrapType(node, { kind: 'literal', value: convertLiteralValue(value, ctx) }, ctx);
 }
 function convertLiteralValue(node, ctx) {
     if (LiteralNode.is(node)) {
-        return {
-            kind: 'boolean',
-            value: node.value === 'true',
-        };
+        return { kind: 'boolean', value: node.value === 'true' };
     }
     else if (TypedNumberNode.is(node)) {
         const { suffix, value } = TypedNumberNode.destruct(node);
         return {
-            kind: 'number',
+            kind: convertLiteralNumberSuffix(suffix, ctx)
+                ?? (value.type === 'integer' ? 'int' : 'double'),
             value: value.value,
-            suffix: convertLiteralNumberSuffix(suffix, ctx),
         };
     }
     else {
-        return {
-            kind: 'string',
-            value: node.value,
-        };
+        return { kind: 'string', value: node.value };
     }
 }
 function convertLiteralNumberSuffix(node, ctx) {
     const suffix = node?.value;
-    return suffix?.toLowerCase();
+    switch (suffix?.toLowerCase()) {
+        case 'b':
+            return 'byte';
+        case 's':
+            return 'short';
+        case 'l':
+            return 'long';
+        case 'f':
+            return 'float';
+        case 'd':
+            return 'double';
+        default:
+            return undefined;
+    }
 }
 function convertNumericType(node, ctx) {
     const { numericKind, valueRange } = NumericTypeNode.destruct(node);
@@ -763,8 +707,7 @@ function convertNumericType(node, ctx) {
     }, ctx);
 }
 function convertPrimitiveArray(node, ctx) {
-    const { arrayKind, lengthRange, valueRange } = PrimitiveArrayTypeNode
-        .destruct(node);
+    const { arrayKind, lengthRange, valueRange } = PrimitiveArrayTypeNode.destruct(node);
     return wrapType(node, {
         kind: `${arrayKind.value}_array`,
         lengthRange: convertRange(lengthRange, ctx),
@@ -773,31 +716,19 @@ function convertPrimitiveArray(node, ctx) {
 }
 function convertString(node, ctx) {
     const { lengthRange } = StringTypeNode.destruct(node);
-    return wrapType(node, {
-        kind: 'string',
-        lengthRange: convertRange(lengthRange, ctx),
-    }, ctx);
+    return wrapType(node, { kind: 'string', lengthRange: convertRange(lengthRange, ctx) }, ctx);
 }
 function convertReference(node, ctx) {
     const { path } = ReferenceTypeNode.destruct(node);
-    return wrapType(node, {
-        kind: 'reference',
-        path: pathArrayToString(resolvePath(path, ctx)),
-    }, ctx);
+    return wrapType(node, { kind: 'reference', path: pathArrayToString(resolvePath(path, ctx)) }, ctx);
 }
 function convertTuple(node, ctx) {
     const { items } = TupleTypeNode.destruct(node);
-    return wrapType(node, {
-        kind: 'tuple',
-        items: items.map((n) => convertType(n, ctx)),
-    }, ctx);
+    return wrapType(node, { kind: 'tuple', items: items.map((n) => convertType(n, ctx)) }, ctx);
 }
 function convertUnion(node, ctx) {
     const { members } = UnionTypeNode.destruct(node);
-    return wrapType(node, {
-        kind: 'union',
-        members: members.map((n) => convertType(n, ctx)),
-    }, ctx);
+    return wrapType(node, { kind: 'union', members: members.map((n) => convertType(n, ctx)) }, ctx);
 }
 function asString(node) {
     if (ResourceLocationNode.is(node)) {

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export * as binder from './binder/index.js';
 export * as colorizer from './colorizer/index.js';
 export * from './node/index.js';
 export * from './parser/index.js';
+export * as runtime from './runtime/index.js';
 export * from './type/index.js';
 export * from './uri_processors.js';
 export declare const initialize: ({ meta }: {

package/lib/index.js

@@ -1,19 +1,19 @@
 import * as binder from './binder/index.js';
 import * as colorizer from './colorizer/index.js';
 import * as parser from './parser/index.js';
+import { registerBuiltinAttributes } from './runtime/attribute/builtin.js';
 import * as uri_professors from './uri_processors.js';
 export * as binder from './binder/index.js';
 export * as colorizer from './colorizer/index.js';
 export * from './node/index.js';
 export * from './parser/index.js';
+export * as runtime from './runtime/index.js';
 export * from './type/index.js';
 export * from './uri_processors.js';
 /* istanbul ignore next */
 export const initialize = ({ meta }) => {
-    meta.registerLanguage('mcdoc', {
-        extensions: ['.mcdoc'],
-        parser: parser.module_,
-    });
+    meta.registerLanguage('mcdoc', { extensions: ['.mcdoc'], parser: parser.module_ });
+    registerBuiltinAttributes(meta);
     meta.registerUriBinder(uri_professors.uriBinder);
     meta.setUriSorter(uri_professors.uriSorter);
     binder.registerMcdocBinders(meta);

package/lib/node/index.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode, ColorTokenType, IntegerNode, SymbolBaseNode } from '@spyglassmc/core';
-import { CommentNode, FloatNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+import type { AstNode, ColorTokenType, SymbolBaseNode } from '@spyglassmc/core';
+import { CommentNode, FloatNode, IntegerNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
 export interface ModuleNode extends AstNode {
     type: 'mcdoc:module';
     children: TopLevelNode[];
@@ -185,11 +185,11 @@ export declare namespace LiteralTypeValueNode {
 }
 export interface TypedNumberNode extends AstNode {
     type: 'mcdoc:typed_number';
-    children: (FloatNode | LiteralNode)[];
+    children: (FloatNode | IntegerNode | LiteralNode)[];
 }
 export declare namespace TypedNumberNode {
     function destruct(node: TypedNumberNode): {
-        value: FloatNode;
+        value: FloatNode | IntegerNode;
         suffix?: LiteralNode;
     };
     function is(node: AstNode | undefined): node is TypedNumberNode;
@@ -211,6 +211,10 @@ export declare const RangeExclusiveChar = "<";
  * The bit is turned on if the range is exclusive on that end.
  */
 export type RangeKind = 0b00 | 0b01 | 0b10 | 0b11;
+export declare namespace RangeKind {
+    function isLeftExclusive(rangeKind: RangeKind): boolean;
+    function isRightExclusive(rangeKind: RangeKind): boolean;
+}
 export declare function getRangeDelimiter(kind: RangeKind): string;
 export interface FloatRangeNode extends AstNode {
     type: 'mcdoc:float_range';
@@ -395,6 +399,7 @@ export interface StructPairFieldNode extends AstNode {
 export declare namespace StructPairFieldNode {
     function destruct(node: StructPairFieldNode): {
         attributes: AttributeNode[];
+        docComments?: DocCommentsNode;
         key: StructKeyNode;
         type: TypeNode;
         isOptional?: boolean;