@spyglassmc/mcdoc 0.3.10 → 0.3.12

package/lib/binder/index.d.ts

@@ -2,11 +2,13 @@ import type { BinderContext, MetaRegistry } from '@spyglassmc/core';
 import { AsyncBinder } from '@spyglassmc/core';
 import type { AdditionalContext } from '../common.js';
 import type { ModuleNode } from '../node/index.js';
+import type { SimplifiedMcdocType } from '../runtime/checker/index.js';
 import type { McdocType } from '../type/index.js';
 interface McdocBinderContext extends BinderContext, AdditionalContext {
 }
 export interface TypeDefSymbolData {
     typeDef: McdocType;
+    simplifiedTypeDef?: SimplifiedMcdocType;
 }
 export declare namespace TypeDefSymbolData {
     function is(data: unknown): data is TypeDefSymbolData;

package/lib/runtime/attribute/builtin.js

@@ -1,10 +1,12 @@
 import * as core from '@spyglassmc/core';
+import { localeQuote, localize } from '@spyglassmc/locales';
 import { registerAttribute, validator } from './index.js';
 const idValidator = validator.alternatives(validator.map(validator.string, v => ({ registry: v })), validator.tree({
     registry: validator.string,
     tags: validator.optional(validator.options('allowed', 'implicit', 'required')),
     definition: validator.optional(validator.boolean),
     prefix: validator.optional(validator.options('!')),
+    empty: validator.optional(validator.options('allowed')),
 }), () => ({}));
 function getResourceLocationOptions({ registry, tags, definition }, requireCanonical, ctx, typeDef) {
     if (!registry) {
@@ -45,6 +47,10 @@ function getResourceLocationOptions({ registry, tags, definition }, requireCanon
     ctx.logger.warn(`[mcdoc id] Unhandled registry ${registry}`);
     return undefined;
 }
+const integerValidator = validator.alternatives(validator.tree({
+    min: validator.optional(validator.number),
+    max: validator.optional(validator.number),
+}), () => ({}));
 export function registerBuiltinAttributes(meta) {
     registerAttribute(meta, 'canonical', () => undefined, {
     // Has hardcoded behavior in the runtime checker
@@ -108,6 +114,11 @@ export function registerBuiltinAttributes(meta) {
             }
             const resourceLocation = core.resourceLocation(options);
             return (src, ctx) => {
+                if (config.empty && !src.canRead()) {
+                    return core.string({
+                        unquotable: { blockList: new Set(), allowEmpty: true },
+                    })(src, ctx);
+                }
                 if (config.prefix) {
                     return core.prefixed({ prefix: config.prefix, child: resourceLocation })(src, ctx);
                 }
@@ -126,5 +137,70 @@ export function registerBuiltinAttributes(meta) {
             return resourceLocation;
         },
     });
+    registerAttribute(meta, 'integer', integerValidator, {
+        stringParser: (config) => {
+            return core.integer({ pattern: /^-?\d+$/, min: config.min, max: config.max });
+        },
+    });
+    registerAttribute(meta, 'color', validator.string, {
+        checkInferred: (config, inferred, ctx) => {
+            if (config === 'hex_rgb' && inferred.kind === 'literal' && inferred.value.kind === 'string') {
+                return inferred.value.value.startsWith('#');
+            }
+            return true;
+        },
+        checker: (config, inferred) => {
+            return (node, ctx) => {
+                switch (config) {
+                    case 'named':
+                        if (inferred.kind !== 'literal' || inferred.value.kind !== 'string') {
+                            return;
+                        }
+                        node.color = core.Color.fromNamed(inferred.value.value);
+                        return;
+                    case 'hex_rgb':
+                        if (inferred.kind !== 'literal' || inferred.value.kind !== 'string') {
+                            return;
+                        }
+                        let range = node.range;
+                        if (core.StringBaseNode.is(node) && node.quote) {
+                            range = core.Range.translate(range, 1, -1);
+                        }
+                        if (!inferred.value.value.startsWith('#')) {
+                            ctx.err.report(localize('expected', localeQuote('#')), range, 2 /* core.ErrorSeverity.Warning */);
+                            return;
+                        }
+                        node.color = {
+                            value: core.Color.fromHexRGB(inferred.value.value),
+                            format: [core.ColorFormat.HexRGB],
+                            range,
+                        };
+                        return;
+                    case 'composite_rgb':
+                        if (inferred.kind !== 'literal' || typeof inferred.value.value !== 'number') {
+                            return;
+                        }
+                        node.color = {
+                            value: core.Color.fromCompositeRGB(inferred.value.value),
+                            format: [core.ColorFormat.CompositeRGB],
+                            range: node.range,
+                        };
+                        return;
+                    case 'composite_argb':
+                        if (inferred.kind !== 'literal' || typeof inferred.value.value !== 'number') {
+                            return;
+                        }
+                        node.color = {
+                            value: core.Color.fromCompositeARGB(inferred.value.value),
+                            format: [core.ColorFormat.CompositeARGB],
+                            range: node.range,
+                        };
+                        return;
+                    default:
+                        return;
+                }
+            };
+        },
+    });
 }
 //# sourceMappingURL=builtin.js.map

package/lib/runtime/attribute/index.d.ts

@@ -1,5 +1,5 @@
 import * as core from '@spyglassmc/core';
-import type { Attribute, StructTypePairField } from '../../type/index.js';
+import type { Attribute, McdocType, StructTypePairField, UnionType } from '../../type/index.js';
 import type { McdocCheckerContext, SimplifiedMcdocType, SimplifiedMcdocTypeNoUnion } from '../checker/index.js';
 import type { McdocCompleterContext } from '../completer/index.js';
 import type { McdocAttributeValidator } from './validator.js';
@@ -10,7 +10,9 @@ export interface McdocAttribute<C = unknown> {
     mapField?: <T>(config: C, field: StructTypePairField, ctx: McdocCheckerContext<T>) => StructTypePairField;
     filterElement?: (config: C, ctx: core.ContextBase) => boolean;
     stringParser?: <T>(config: C, typeDef: SimplifiedMcdocTypeNoUnion, ctx: McdocCheckerContext<T>) => core.InfallibleParser<core.AstNode | undefined> | undefined;
+    checker?: <T>(config: C, inferred: Exclude<McdocType, UnionType>, ctx: McdocCheckerContext<T>) => core.SyncChecker<core.AstNode> | undefined;
     stringMocker?: (config: C, typeDef: core.DeepReadonly<SimplifiedMcdocTypeNoUnion>, ctx: McdocCompleterContext) => core.AstNode | undefined;
+    numericCompleter?: (config: C, ctx: McdocCompleterContext) => core.CompletionItem[];
 }
 export declare function registerAttribute<C extends core.Returnable>(meta: core.MetaRegistry, name: string, validator: McdocAttributeValidator<C>, attribute: McdocAttribute<C>): void;
 interface AttributeInfo {

package/lib/runtime/checker/context.d.ts

@@ -14,6 +14,7 @@ export interface RuntimePair<T> {
 }
 export type NodeEquivalenceChecker = (inferredNode: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>, definition: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>) => boolean;
 export type TypeInfoAttacher<T> = (node: T, definition: SimplifiedMcdocType, description?: string) => void;
+export type NodeAttacher<T> = (node: T, attacher: (node: core.AstNode) => void) => void;
 export type StringAttacher<T> = (node: T, attacher: (node: core.StringBaseNode) => void) => void;
 export type ChildrenGetter<T> = (node: T, simplified: SimplifiedMcdocTypeNoUnion) => RuntimeUnion<T>[];
 export type ErrorReporter<T> = (error: McdocRuntimeError<T>) => void;
@@ -24,6 +25,7 @@ export interface McdocCheckerContext<T> extends core.CheckerContext {
     getChildren: ChildrenGetter<T>;
     reportError: ErrorReporter<T>;
     attachTypeInfo?: TypeInfoAttacher<T>;
+    nodeAttacher?: NodeAttacher<T>;
     stringAttacher?: StringAttacher<T>;
 }
 type McdocCheckerContextOptions<T> = Partial<McdocCheckerContext<T>>;

package/lib/runtime/checker/context.js

@@ -9,6 +9,7 @@ export var McdocCheckerContext;
             getChildren: options.getChildren ?? (() => []),
             reportError: options.reportError ?? (() => { }),
             attachTypeInfo: options.attachTypeInfo,
+            nodeAttacher: options.nodeAttacher,
             stringAttacher: options.stringAttacher,
         };
     }

package/lib/runtime/checker/error.js

@@ -202,7 +202,7 @@ function condense(validDefinitions, is, equals, combineAlternatives) {
     }, []);
     const distinctErrors = distinctErrorsPerNode.flatMap(e => e.errors);
     const commonErrors = distinctErrors
-        .filter(e => e.definitions.length == validDefinitions.length)
+        .filter(e => e.definitions.length === validDefinitions.length)
         .map(e => e.error);
     const definitionsWithUncommonErrors = distinctErrors
         .filter(e => e.definitions.length < validDefinitions.length)
@@ -342,7 +342,7 @@ export function getDefaultErrorReporter(ctx, getErrorRange) {
                 localizedText = localize(`mcdoc.runtime.checker.${defaultTranslationKey}`);
                 break;
             case 'internal':
-                break;
+                return;
             default:
                 localizedText = localize(defaultTranslationKey);
         }

package/lib/runtime/checker/index.d.ts

@@ -65,16 +65,16 @@ export interface SimplifyValueNode<T> {
 export interface SimplifyContext<T> {
     node: SimplifyValueNode<T>;
     ctx: McdocCheckerContext<T>;
-    structFields?: {
-        literalFields: Map<string, StructTypePairField>;
-        complexFields: SimplifiedStructTypePairField[];
-    };
     isMember?: boolean;
     typeArgs?: SimplifiedMcdocType[];
     typeMapping?: {
         [path: string]: SimplifiedMcdocType;
     };
 }
-export declare function simplify<T>(typeDef: Exclude<McdocType, UnionType>, context: SimplifyContext<T>): SimplifiedMcdocTypeNoUnion;
-export declare function simplify<T>(typeDef: McdocType, context: SimplifyContext<T>): SimplifiedMcdocType;
+export interface SimplifyResult<T extends SimplifiedMcdocType> {
+    typeDef: T;
+    dynamicData?: boolean;
+}
+export declare function simplify<T>(typeDef: Exclude<McdocType, UnionType>, context: SimplifyContext<T>): SimplifyResult<SimplifiedMcdocTypeNoUnion>;
+export declare function simplify<T>(typeDef: McdocType, context: SimplifyContext<T>): SimplifyResult<SimplifiedMcdocType>;
 //# sourceMappingURL=index.d.ts.map

package/lib/runtime/checker/index.js

@@ -88,7 +88,7 @@ export function typeDefinition(runtimeValues, typeDef, ctx) {
         children: [],
     }));
     for (const value of rootNode.possibleValues) {
-        const simplifiedRoot = simplify(typeDef, { ctx, node: value });
+        const simplifiedRoot = simplify(typeDef, { ctx, node: value }).typeDef;
         const validRootDefinitions = simplifiedRoot.kind === 'union'
             ? simplifiedRoot.members
             : [simplifiedRoot];
@@ -110,7 +110,7 @@ export function typeDefinition(runtimeValues, typeDef, ctx) {
     while (nodeQueue.length !== 0) {
         const node = nodeQueue.shift();
         for (const value of node.possibleValues) {
-            const inferredSimplified = simplify(value.node.inferredType, { ctx, node: value });
+            const inferredSimplified = simplify(value.node.inferredType, { ctx, node: value }).typeDef;
             const children = ctx.getChildren(value.node.originalNode, inferredSimplified);
             const childNodes = children.map(c => {
                 const ans = {
@@ -165,7 +165,7 @@ export function typeDefinition(runtimeValues, typeDef, ctx) {
                             // the same types again and just collect the errors of the lower depth.
                             // This will currently lead to a stack overflow error when e.g. comparing two
                             // text component definitions
-                            const simplified = simplify(childDef.type, { ctx, node: childValue });
+                            const simplified = simplify(childDef.type, { ctx, node: childValue }).typeDef;
                             const childDefinitionGroup = {
                                 parents: [def],
                                 runtimeNode: childValue,
@@ -212,10 +212,10 @@ function attachTypeInfo(node, ctx) {
     if (definitions.length === 1) {
         const { typeDef, groupNode } = definitions[0];
         ctx.attachTypeInfo?.(node.node.originalNode, typeDef, groupNode.desc);
-        handleStringAttachers(node.node, typeDef, ctx);
+        handleNodeAttachers(node.node, typeDef, ctx);
         if (node.entryNode.runtimeKey && groupNode.keyDefinition) {
             ctx.attachTypeInfo?.(node.entryNode.runtimeKey.originalNode, groupNode.keyDefinition, groupNode.desc);
-            handleStringAttachers(node.entryNode.runtimeKey, groupNode.keyDefinition, ctx);
+            handleNodeAttachers(node.entryNode.runtimeKey, groupNode.keyDefinition, ctx);
         }
     }
     else if (definitions.length > 1) {
@@ -237,40 +237,46 @@ function attachTypeInfo(node, ctx) {
         attachTypeInfo(child, ctx);
     }
 }
-function handleStringAttachers(runtimeValue, typeDef, ctx) {
-    const { stringAttacher } = ctx;
-    if (!stringAttacher) {
+function handleNodeAttachers(runtimeValue, typeDef, ctx) {
+    const { nodeAttacher, stringAttacher } = ctx;
+    if (!nodeAttacher && !stringAttacher) {
         return;
     }
     handleAttributes(typeDef.attributes, ctx, (handler, config) => {
         const parser = handler.stringParser?.(config, typeDef, ctx);
-        if (!parser) {
-            return;
-        }
-        stringAttacher(runtimeValue.originalNode, (node) => {
-            const src = new Source(node.value, node.valueMap);
-            const start = src.cursor;
-            const child = parser(src, ctx);
-            if (!child) {
-                ctx.err.report(localize('expected', localize('mcdoc.runtime.checker.value')), Range.create(start, src.skipRemaining()));
-                return;
-            }
-            else if (src.canRead()) {
-                ctx.err.report(localize('mcdoc.runtime.checker.trailing'), Range.create(src.cursor, src.skipRemaining()));
-            }
-            node.children = [child];
-        });
+        if (parser && stringAttacher) {
+            stringAttacher(runtimeValue.originalNode, (node) => {
+                const src = new Source(node.value, node.valueMap);
+                const start = src.cursor;
+                const child = parser(src, ctx);
+                if (!child) {
+                    ctx.err.report(localize('expected', localize('mcdoc.runtime.checker.value')), Range.create(start, src.skipRemaining()));
+                    return;
+                }
+                else if (src.canRead()) {
+                    ctx.err.report(localize('mcdoc.runtime.checker.trailing'), Range.create(src.cursor, src.skipRemaining()));
+                }
+                node.children = [child];
+            });
+        }
+        const checker = handler.checker?.(config, runtimeValue.inferredType, ctx);
+        if (checker && nodeAttacher) {
+            nodeAttacher(runtimeValue.originalNode, (node) => {
+                checker(node, ctx);
+            });
+        }
     });
 }
 function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx) {
-    const typeDefValueType = getValueType(typeDef);
-    const runtimeValueType = getValueType(simplifiedInferred);
     const childDefinitions = Array(children.length)
         .fill(undefined);
-    if ((typeDef.kind !== 'any' && typeDef.kind !== 'unsafe'
-        && simplifiedInferred.kind !== 'unsafe'
-        && runtimeValueType.kind !== typeDefValueType.kind
-        && !ctx.isEquivalent(runtimeValueType, typeDefValueType))) {
+    if (typeDef.kind === 'any' || typeDef.kind === 'unsafe' || simplifiedInferred.kind === 'unsafe') {
+        return { childDefinitions, errors: [] };
+    }
+    const typeDefValueType = getValueType(typeDef);
+    const runtimeValueType = getValueType(simplifiedInferred);
+    if (runtimeValueType.kind !== typeDefValueType.kind
+        && !ctx.isEquivalent(runtimeValueType, typeDefValueType)) {
         return {
             childDefinitions,
             errors: [{ kind: 'type_mismatch', node: runtimeNode, expected: [typeDef] }],
@@ -299,9 +305,6 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
         };
     }
     switch (typeDef.kind) {
-        case 'any':
-        case 'unsafe':
-            break;
         case 'byte':
         case 'short':
         case 'int':
@@ -357,6 +360,7 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
                     otherKvps.push({ value: child, index: i });
                 }
             }
+            const missingKeys = new Set();
             for (const pair of typeDef.fields) {
                 const otherKvpMatches = [];
                 let foundMatch = false;
@@ -368,17 +372,14 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
                     }
                 }
                 if (!foundMatch) {
-                    for (let i = 0; i < otherKvps.length; i++) {
-                        const kvp = otherKvps[i];
+                    for (const kvp of otherKvps) {
                         if (isAssignable(kvp.value.key.inferredType, pair.key, ctx, ctx.isEquivalent)) {
                             foundMatch = true;
-                            otherKvps.splice(i, 1);
                             otherKvpMatches.push(kvp.index);
-                            i--;
                         }
                     }
                     for (const kvp of literalKvps.entries()) {
-                        if (!kvp[1].definition
+                        if ((!kvp[1].definition || kvp[1].definition.keyType?.kind !== 'literal')
                             && isAssignable({ kind: 'literal', value: { kind: 'string', value: kvp[0] } }, pair.key, ctx, ctx.isEquivalent)) {
                             foundMatch = true;
                             kvp[1].definition = { keyType: pair.key, type: pair.type, desc: pair.desc };
@@ -393,9 +394,14 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
                     && pair.key.kind === 'literal'
                     && pair.key.value.kind === 'string'
                     && pair.optional !== true) {
-                    errors.push({ kind: 'missing_key', node: runtimeNode, keys: [pair.key.value.value] });
+                    missingKeys.add(pair.key.value.value);
                 }
             }
+            errors.push(...Array.from(missingKeys).map(key => ({
+                kind: 'missing_key',
+                node: runtimeNode,
+                keys: [key],
+            })));
             for (const kvp of literalKvps.values()) {
                 for (const value of kvp.values) {
                     childDefinitions[value.index] = kvp.definition;
@@ -484,16 +490,16 @@ export function getPossibleTypes(typeDef) {
     return typeDef.kind === 'union' ? typeDef.members.flatMap(m => getPossibleTypes(m)) : [typeDef];
 }
 export function simplify(typeDef, context) {
-    function wrap(typeDef) {
-        if (!typeDef.attributes?.length) {
-            return typeDef;
+    function wrap(result) {
+        if (!result.typeDef.attributes?.length) {
+            return result;
         }
         handleAttributes(typeDef.attributes, context.ctx, (handler, config) => {
             if (handler.mapType) {
-                typeDef = handler.mapType(config, typeDef, context.ctx);
+                result.typeDef = handler.mapType(config, result.typeDef, context.ctx);
             }
         });
-        return typeDef;
+        return result;
     }
     switch (typeDef.kind) {
         case 'reference':
@@ -519,53 +525,67 @@ export function simplify(typeDef, context) {
         case 'mapped':
             return wrap(simplifyMapped(typeDef, context));
         default:
-            return wrap(typeDef);
+            return wrap({ typeDef });
     }
 }
 function simplifyReference(typeDef, context) {
     if (!typeDef.path) {
         // TODO when does this happen?
         context.ctx.logger.warn(`Tried to access empty reference`);
-        return { kind: 'union', members: [] };
+        return { typeDef: { kind: 'union', members: [] } };
     }
     const mapped = context.typeMapping?.[typeDef.path];
     if (mapped) {
-        return mapped;
+        return { typeDef: mapped, dynamicData: true };
     }
     // TODO Probably need to keep original symbol around in some way to support "go to definition"
     const symbol = context.ctx.symbols.query(context.ctx.doc, 'mcdoc', typeDef.path);
-    const def = symbol.getData(TypeDefSymbolData.is)?.typeDef;
-    if (!def) {
+    const data = symbol.getData(TypeDefSymbolData.is);
+    if (!data?.typeDef) {
         context.ctx.logger.warn(`Tried to access unknown reference ${typeDef.path}`);
-        return { kind: 'union', members: [] };
+        return { typeDef: { kind: 'union', members: [] } };
     }
-    const simplifiedDef = simplify(def, context);
+    if (data.simplifiedTypeDef) {
+        return { typeDef: data.simplifiedTypeDef };
+    }
+    const simplifiedResult = simplify(data.typeDef, context);
     if (typeDef.attributes?.length) {
-        return {
-            ...simplifiedDef,
-            attributes: [...typeDef.attributes, ...simplifiedDef.attributes ?? []],
+        simplifiedResult.typeDef = {
+            ...simplifiedResult.typeDef,
+            attributes: [...typeDef.attributes, ...simplifiedResult.typeDef.attributes ?? []],
         };
     }
-    return simplifiedDef;
+    if (!simplifiedResult.dynamicData) {
+        symbol.amend({
+            data: {
+                data: {
+                    ...data,
+                    simplifiedTypeDef: simplifiedResult.typeDef,
+                },
+            },
+        });
+    }
+    return simplifiedResult;
 }
 function simplifyDispatcher(typeDef, context) {
-    const dispatcher = context.ctx.symbols.query(context.ctx.doc, 'mcdoc/dispatcher', typeDef.registry).symbol
-        ?.members;
+    const dispatcherQuery = context.ctx.symbols.query(context.ctx.doc, 'mcdoc/dispatcher', typeDef.registry);
+    const dispatcher = dispatcherQuery.symbol?.members;
     if (!dispatcher) {
         context.ctx.logger.warn(`Tried to access unknown dispatcher ${typeDef.registry}`);
-        return { kind: 'union', members: [] };
+        return { typeDef: { kind: 'union', members: [] } };
     }
-    return resolveIndices(typeDef.parallelIndices, dispatcher, context);
+    const result = resolveIndices(typeDef.parallelIndices, dispatcher, dispatcherQuery, context);
+    return result;
 }
 function simplifyIndexed(typeDef, context) {
-    const child = simplify(typeDef.child, {
+    const childResult = simplify(typeDef.child, {
         ...context,
         typeArgs: [],
-        structFields: undefined,
     });
+    const child = childResult.typeDef;
     if (child.kind !== 'struct') {
         context.ctx.logger.warn(`Tried to index un-indexable type ${child.kind}`);
-        return { kind: 'union', members: [] };
+        return { typeDef: { kind: 'union', members: [] }, dynamicData: childResult.dynamicData };
     }
     const symbolMap = {};
     for (const field of child.fields) {
@@ -577,15 +597,44 @@ function simplifyIndexed(typeDef, context) {
             };
         }
     }
-    return resolveIndices(typeDef.parallelIndices, symbolMap, context);
+    const simplified = resolveIndices(typeDef.parallelIndices, symbolMap, undefined, context);
+    return { ...simplified, dynamicData: childResult.dynamicData ?? simplified.dynamicData };
 }
-function resolveIndices(parallelIndices, symbolMap, context) {
+function resolveIndices(parallelIndices, symbolMap, symbolQuery, context) {
+    let dynamicData = false;
     let values = [];
+    function pushValue(key, data) {
+        if (data.simplifiedTypeDef) {
+            if (data.simplifiedTypeDef.kind === 'union') {
+                values.push(...data.simplifiedTypeDef.members);
+            }
+            else {
+                values.push(data.simplifiedTypeDef);
+            }
+        }
+        else {
+            const simplifiedResult = simplify(data.typeDef, context);
+            if (simplifiedResult.dynamicData) {
+                dynamicData = true;
+            }
+            else if (symbolQuery) {
+                symbolQuery.member(key, s => s.amend({
+                    data: { data: { ...data, simplifiedTypeDef: simplifiedResult.typeDef } },
+                }));
+            }
+            if (simplifiedResult.typeDef.kind === 'union') {
+                values.push(...simplifiedResult.typeDef.members);
+            }
+            else {
+                values.push(simplifiedResult.typeDef);
+            }
+        }
+    }
     let unkownTypeDef = false;
     function getUnknownTypeDef() {
         if (unkownTypeDef === false) {
             const data = symbolMap['%unknown']?.data;
-            unkownTypeDef = TypeDefSymbolData.is(data) ? data.typeDef : undefined;
+            unkownTypeDef = TypeDefSymbolData.is(data) ? data : undefined;
         }
         return unkownTypeDef;
     }
@@ -593,10 +642,12 @@ function resolveIndices(parallelIndices, symbolMap, context) {
         let lookup = [];
         if (index.kind === 'static') {
             if (index.value === '%fallback') {
-                values = Object.values(symbolMap)
-                    .map(e => e.data)
-                    .filter(TypeDefSymbolData.is)
-                    .map(f => f.typeDef);
+                values = [];
+                for (const [key, value] of Object.entries(symbolMap)) {
+                    if (TypeDefSymbolData.is(value.data)) {
+                        pushValue(key, value.data);
+                    }
+                }
                 break;
             }
             if (index.value.startsWith('minecraft:')) {
@@ -607,6 +658,7 @@ function resolveIndices(parallelIndices, symbolMap, context) {
             }
         }
         else {
+            dynamicData = true;
             let possibilities = context.isMember
                 ? [{ value: context.node, key: context.node.entryNode.runtimeKey }]
                 : [{
@@ -633,7 +685,8 @@ function resolveIndices(parallelIndices, symbolMap, context) {
                     const newPossibilities = [];
                     for (const node of possibilities) {
                         const possibleChildren = node.value
-                            ? context.ctx.getChildren(node.value.node.originalNode, simplify(node.value.node.inferredType, { ...context, node: node.value })).filter(child => {
+                            ? context.ctx.getChildren(node.value.node.originalNode, simplify(node.value.node.inferredType, { ...context, node: node.value })
+                                .typeDef).filter(child => {
                                 if (!Array.isArray(child)) {
                                     return child.key.inferredType.kind === 'literal'
                                         && child.key.inferredType.value.kind === 'string'
@@ -680,23 +733,26 @@ function resolveIndices(parallelIndices, symbolMap, context) {
         }
         const currentValues = lookup.map(v => {
             const data = symbolMap[v]?.data;
-            return TypeDefSymbolData.is(data) ? data.typeDef : getUnknownTypeDef();
+            return { value: v, data: TypeDefSymbolData.is(data) ? data : getUnknownTypeDef() };
         });
-        if (currentValues.includes(undefined)) {
+        const missing = currentValues.find(v => !v.data);
+        if (missing) {
             // fallback case
-            return { kind: 'any' };
+            return { typeDef: { kind: 'any' }, dynamicData };
         }
         else {
-            values.push(...currentValues.map(v => v));
+            for (const entry of currentValues) {
+                pushValue(entry.value, entry.data);
+            }
         }
     }
     if (values.length === 1) {
-        // avoid overhead from union
-        return simplify(values[0], context);
+        return { typeDef: values[0], dynamicData };
     }
-    return simplifyUnion({ kind: 'union', members: values }, context);
+    return { typeDef: { kind: 'union', members: values }, dynamicData };
 }
 function simplifyUnion(typeDef, context) {
+    let dynamicData = false;
     const filterCanonical = context.ctx.requireCanonical
         && typeDef.members.some(m => m.attributes?.some(a => a.name === 'canonical'));
     const validMembers = typeDef.members
@@ -716,46 +772,29 @@ function simplifyUnion(typeDef, context) {
         return keep;
     });
     if (validMembers.length === 1) {
-        // Avoid needing to manually add struct fields to parent if we are in a spread operation
         return simplify(validMembers[0], context);
     }
     const members = [];
     for (const member of validMembers) {
-        const simplified = simplify(member, {
-            ...context,
-            structFields: undefined,
-        });
+        const { typeDef: simplified, dynamicData: memberDynamic } = simplify(member, context);
+        if (memberDynamic) {
+            dynamicData = true;
+        }
         if (simplified.kind === 'union') {
             members.push(...simplified.members);
         }
         else {
             members.push(simplified);
         }
-        if (context.structFields && members.length > 1) {
-            return { kind: 'union', members: [] };
-        }
     }
     if (members.length === 1) {
-        // This should basically never happen, only when a union member resolves to an empty union.
-        // Apply struct fields to parent if we are inside a spread operation.
-        if (members[0].kind === 'struct' && context.structFields) {
-            for (const field of members[0].fields) {
-                if (field.key.kind === 'literal' && field.key.value.kind === 'string') {
-                    context.structFields.literalFields.set(field.key.value.value, field);
-                }
-                else {
-                    context.structFields.complexFields.push(field);
-                }
-            }
-        }
-        return members[0];
+        return { typeDef: members[0], dynamicData };
     }
-    return { ...typeDef, kind: 'union', members };
+    return { typeDef: { kind: 'union', members }, dynamicData };
 }
 function simplifyStruct(typeDef, context) {
-    const literalFields = context.structFields?.literalFields
-        ?? new Map();
-    let complexFields = context.structFields?.complexFields ?? [];
+    const fields = [];
+    let dynamicData = false;
     function addField(key, field) {
         handleAttributes(field.attributes, context.ctx, (handler, config) => {
             if (handler.mapField) {
@@ -763,20 +802,16 @@ function simplifyStruct(typeDef, context) {
             }
         });
         if (typeof key === 'string') {
-            literalFields.set(key, field);
-        }
-        else if (key.kind === 'literal' && key.value.kind === 'string' && !key.attributes?.length) {
-            literalFields.set(key.value.value, field);
+            fields.push({
+                ...field,
+                key: { kind: 'literal', value: { kind: 'string', value: key } },
+            });
         }
         else if (key.kind === 'union') {
             key.members.forEach(m => addField(m, { ...field, optional: true }));
         }
         else {
-            // Only keep fields where the new key is not assignable to an existing field
-            complexFields = complexFields.filter(other => !McdocType.equals(key, typeof other.key === 'string'
-                ? { kind: 'literal', value: { kind: 'string', value: other.key } }
-                : other.key));
-            complexFields.push({ ...field, key });
+            fields.push({ ...field, key });
         }
     }
     for (const field of typeDef.fields) {
@@ -790,22 +825,41 @@ function simplifyStruct(typeDef, context) {
             continue;
         }
         if (field.kind === 'pair') {
-            // Don't simplify the value here. We need to have the correct `node` and `parents`, which we
-            // cannot deterministically find for non-string keys.
-            // Instead, this method will be called by every struct child by the outer checking method.
-            const structKey = typeof field.key === 'string'
-                ? field.key
-                : simplify(field.key, { ...context, isMember: true, typeArgs: [] });
-            const mappedField = context.typeMapping
-                ? {
+            // Don't simplify the value here, simplify is shallow and needs a runtime value to work
+            // properly, so the values should only be simplified once they were assigned to a
+            // runtime value.
+            let structKey;
+            if (typeof field.key === 'string') {
+                structKey = field.key;
+            }
+            else {
+                const simplifiedKeyResult = simplify(field.key, {
+                    ...context,
+                    isMember: true,
+                    typeArgs: [],
+                });
+                if (simplifiedKeyResult.dynamicData) {
+                    dynamicData = true;
+                }
+                structKey = simplifiedKeyResult.typeDef;
+            }
+            let mappedField;
+            if (context.typeMapping) {
+                mappedField = {
                     ...field,
                     type: {
                         kind: 'mapped',
                         child: field.type,
                         mapping: context.typeMapping,
                     },
-                }
-                : field;
+                };
+                // Don't cache mapped field data
+                // TODO find a better way to handle mapped types with caching
+                dynamicData = true;
+            }
+            else {
+                mappedField = field;
+            }
             addField(structKey, mappedField);
         }
         else {
@@ -813,54 +867,53 @@ function simplifyStruct(typeDef, context) {
                 ...context,
                 isMember: true,
                 typeArgs: [],
-                structFields: { literalFields, complexFields },
             });
-            // Recursive calls above will already modify literal and complex fields passed by the
-            // context, so no need to handle them here.
-            // In case we are spreading sth that resolves to `any`, allow any other additional field.
-            if (simplifiedSpread.kind === 'any') {
-                addField({ kind: 'any' }, { kind: 'pair', key: { kind: 'any' }, type: { kind: 'any' } });
+            if (simplifiedSpread.dynamicData) {
+                dynamicData = true;
+            }
+            if (simplifiedSpread.typeDef.kind === 'any') {
+                fields.push({ kind: 'pair', key: { kind: 'any' }, type: { kind: 'any' } });
+            }
+            else if (simplifiedSpread.typeDef.kind === 'struct') {
+                fields.push(...simplifiedSpread.typeDef.fields);
             }
         }
     }
-    if (context.structFields) {
-        // In this case we are spreading a struct and the fields have been added to the parent map
-        // from context now.
-        return { kind: 'struct', fields: [] };
-    }
-    // Literal fields may still be assignable to complex fields,
-    // however this is currently not seen as an issue
     return {
-        kind: 'struct',
-        fields: [
-            ...complexFields,
-            ...[...literalFields.entries()].map(([key, field]) => ({
-                ...field,
-                key: { kind: 'literal', value: { kind: 'string', value: key } },
-            })),
-        ],
+        typeDef: { kind: 'struct', fields },
+        dynamicData,
     };
 }
 function simplifyList(typeDef, context) {
     if (!context.typeMapping) {
-        return typeDef;
+        return { typeDef };
     }
     return {
-        ...typeDef,
-        item: { kind: 'mapped', child: typeDef.item, mapping: context.typeMapping },
+        typeDef: {
+            ...typeDef,
+            item: { kind: 'mapped', child: typeDef.item, mapping: context.typeMapping },
+        },
+        // Don't cache mapped field data
+        // TODO find a better way to handle mapped types with caching
+        dynamicData: true,
     };
 }
 function simplifyTuple(typeDef, context) {
     if (!context.typeMapping) {
-        return typeDef;
+        return { typeDef };
     }
     return {
-        ...typeDef,
-        items: typeDef.items.map(item => ({
-            kind: 'mapped',
-            child: item,
-            mapping: context.typeMapping,
-        })),
+        typeDef: {
+            ...typeDef,
+            items: typeDef.items.map(item => ({
+                kind: 'mapped',
+                child: item,
+                mapping: context.typeMapping,
+            })),
+        },
+        // Don't cache mapped field data
+        // TODO find a better way to handle mapped types with caching
+        dynamicData: true,
     };
 }
 function simplifyEnum(typeDef, context) {
@@ -876,11 +929,19 @@ function simplifyEnum(typeDef, context) {
         });
         return keep;
     });
-    return { ...typeDef, enumKind: typeDef.enumKind ?? 'int', values: filteredValues };
+    return { typeDef: { ...typeDef, enumKind: typeDef.enumKind ?? 'int', values: filteredValues } };
 }
 function simplifyConcrete(typeDef, context) {
-    const simplifiedArgs = typeDef.typeArgs.map(arg => simplify(arg, context));
-    return simplify(typeDef.child, { ...context, typeArgs: simplifiedArgs });
+    let dynamicData = false;
+    const simplifiedArgs = typeDef.typeArgs.map(arg => {
+        const ans = simplify(arg, context);
+        if (ans.dynamicData) {
+            dynamicData = true;
+        }
+        return ans.typeDef;
+    });
+    const result = simplify(typeDef.child, { ...context, typeArgs: simplifiedArgs });
+    return { typeDef: result.typeDef, dynamicData: dynamicData || result.dynamicData };
 }
 function simplifyTemplate(typeDef, context) {
     if (context.typeArgs?.length !== typeDef.typeParams.length) {
@@ -893,13 +954,19 @@ function simplifyTemplate(typeDef, context) {
     return simplify(typeDef.child, { ...context, typeArgs: [], typeMapping: mapping });
 }
 function simplifyMapped(typeDef, context) {
+    let dynamicData = false;
     // Mapped types that were created in simplify are always simplified
     // types already, in which case this will be a cheap operation, but
     // this is necessary for type safety
     const simplifiedMapping = Object.fromEntries(Object.entries(typeDef.mapping).map(([path, param]) => {
-        return [path, simplify(param, context)];
+        const ans = simplify(param, context);
+        if (ans.dynamicData) {
+            dynamicData = true;
+        }
+        return [path, ans.typeDef];
     }));
-    return simplify(typeDef.child, { ...context, typeMapping: simplifiedMapping });
+    const ans = simplify(typeDef.child, { ...context, typeMapping: simplifiedMapping });
+    return { typeDef: ans.typeDef, dynamicData: dynamicData || ans.dynamicData };
 }
 function getValueType(type) {
     switch (type.kind) {

package/lib/runtime/completer/index.d.ts

@@ -12,9 +12,11 @@ export declare function getFields(typeDef: core.DeepReadonly<SimplifiedMcdocType
 export type SimpleCompletionValue = {
     value: string;
     detail?: string;
+    labelSuffix?: string;
     kind?: McdocType['kind'];
     completionKind?: core.CompletionKind;
     insertText?: string;
+    sortText?: string;
 };
 export declare function getValues(typeDef: core.DeepReadonly<McdocType>, ctx: McdocCompleterContext): SimpleCompletionValue[];
 //# sourceMappingURL=index.d.ts.map

package/lib/runtime/completer/index.js

@@ -95,6 +95,13 @@ export function getValues(typeDef, ctx) {
                 detail: v.identifier,
                 kind: typeDef.enumKind ?? 'string',
             }));
+        case 'byte':
+        case 'short':
+        case 'int':
+        case 'long':
+        case 'float':
+        case 'double':
+            return getNumericCompletions(typeDef, ctx);
         default:
             return [];
     }
@@ -110,9 +117,11 @@ function getStringCompletions(typeDef, ctx) {
         ans.push(...items.map(item => ({
             value: item.label,
             kind: 'string',
+            labelSuffix: item.labelSuffix,
             detail: item.detail,
             completionKind: item.kind,
             insertText: item.insertText,
+            sortText: item.sortText,
         })));
     });
     if (ans.length === 0 && typeDef.kind === 'literal') {
@@ -120,4 +129,23 @@ function getStringCompletions(typeDef, ctx) {
     }
     return ans;
 }
+function getNumericCompletions(typeDef, ctx) {
+    const ans = [];
+    handleAttributes(typeDef.attributes, ctx, (handler, config) => {
+        const items = handler.numericCompleter?.(config, ctx);
+        if (!items) {
+            return;
+        }
+        ans.push(...items.map(item => ({
+            value: item.label,
+            kind: typeDef.kind,
+            labelSuffix: item.labelSuffix,
+            detail: item.detail,
+            completionKind: item.kind,
+            insertText: item.insertText,
+            sortText: item.sortText,
+        })));
+    });
+    return ans;
+}
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.7",
-    "@spyglassmc/locales": "0.3.7"
+    "@spyglassmc/core": "0.4.9",
+    "@spyglassmc/locales": "0.3.8"
   }
 }