@spyglassmc/mcdoc 0.3.50 → 0.3.52

package/lib/binder/index.js

@@ -1,4 +1,4 @@
-import { AsyncBinder, atArray, Dev, ErrorSeverity, FloatNode, IntegerNode, LongNode, Range, ResourceLocationNode, StringNode, SymbolUtil, traversePreOrder, } from '@spyglassmc/core';
+import { AsyncBinder, Dev, ErrorSeverity, FloatNode, IntegerNode, LongNode, Range, ResourceLocationNode, StringNode, 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, LongRangeNode, 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';
 var ModuleSymbolData;
@@ -288,7 +288,7 @@ async function bindPath(node, ctx) {
             },
         })).else(() => {
             if (indexRight === 0) {
-                ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(atArray(identifiers, -1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node, ErrorSeverity.Warning);
+                ctx.err.report(localize('mcdoc.binder.path.unknown-identifier', localeQuote(identifiers.at(-1)), localeQuote(pathArrayToString(identifiers.slice(0, -1)))), node, ErrorSeverity.Warning);
             }
         });
     }
@@ -413,7 +413,7 @@ function* resolvePathByStep(path, ctx, options = {}) {
     }
 }
 function resolvePath(path, ctx, options = {}) {
-    return atArray([...resolvePathByStep(path, ctx, options)], -1)?.identifiers;
+    return [...resolvePathByStep(path, ctx, options)].at(-1)?.identifiers;
 }
 function identifierToUri(module, ctx) {
     return ctx.symbols.global.mcdoc?.[module]?.definition?.[0]?.uri;

package/lib/node/index.d.ts

@@ -284,7 +284,7 @@ export interface EnumNode extends TypeBaseNode<DocCommentsNode | LiteralNode | I
 }
 export type EnumKind = typeof EnumNode.Kinds extends Set<infer V> ? V : never;
 export declare namespace EnumNode {
-    const Kinds: Set<"string" | "long" | "float" | "byte" | "short" | "int" | "double">;
+    const Kinds: Set<"byte" | "double" | "float" | "int" | "long" | "short" | "string">;
     function destruct(node: EnumNode): {
         block: EnumBlockNode;
         docComments?: DocCommentsNode;

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { atArray, CommentNode, FloatNode, IntegerNode, LongNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
+import { CommentNode, FloatNode, IntegerNode, LongNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
 export var ModuleNode;
 (function (ModuleNode) {
     function is(node) {
@@ -581,7 +581,7 @@ export var TypeParamNode;
 export var PathNode;
 (function (PathNode) {
     function destruct(node) {
-        const lastChild = atArray(node?.children, -1);
+        const lastChild = node?.children.at(-1);
         return {
             children: node?.children ?? [],
             isAbsolute: node?.isAbsolute,

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

@@ -12,7 +12,7 @@ export interface RuntimePair<T> {
     key: RuntimeNode<T>;
     possibleValues: RuntimeNode<T>[];
 }
-export type NodeEquivalenceChecker = (inferredNode: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>, definition: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>) => boolean;
+export type TypeConverter<T> = (node: T, definition: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>) => SimplifiedMcdocTypeNoUnion | undefined;
 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;
@@ -21,7 +21,7 @@ export type ErrorReporter<T> = (error: McdocRuntimeError<T>) => void;
 export interface McdocCheckerContext<T> extends core.CheckerContext {
     allowMissingKeys: boolean;
     requireCanonical: boolean;
-    isEquivalent: NodeEquivalenceChecker;
+    tryConvertTo: TypeConverter<T>;
     getChildren: ChildrenGetter<T>;
     reportError: ErrorReporter<T>;
     attachTypeInfo?: TypeInfoAttacher<T>;

package/lib/runtime/checker/context.js

@@ -5,7 +5,7 @@ export var McdocCheckerContext;
             ...ctx,
             allowMissingKeys: options.allowMissingKeys ?? false,
             requireCanonical: options.requireCanonical ?? false,
-            isEquivalent: options.isEquivalent ?? (() => false),
+            tryConvertTo: options.tryConvertTo ?? (() => undefined),
             getChildren: options.getChildren ?? (() => []),
             reportError: options.reportError ?? (() => { }),
             attachTypeInfo: options.attachTypeInfo,

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

@@ -1,7 +1,7 @@
 import type { CheckerContext, FullResourceLocation } from '@spyglassmc/core';
 import type { EnumType, Index, KeywordType, ListType, LiteralType, LongType, NumericType, ParallelIndices, PrimitiveArrayType, StringType, StructType, StructTypePairField, TupleType, UnionType } from '../../type/index.js';
 import { McdocType } from '../../type/index.js';
-import type { NodeEquivalenceChecker, RuntimeNode } from './context.js';
+import type { RuntimeNode, TypeConverter } from './context.js';
 import { McdocCheckerContext } from './context.js';
 import type { McdocRuntimeError } from './error.js';
 export * from './context.js';
@@ -16,7 +16,7 @@ export interface SimplifiedStructTypePairField extends StructTypePairField {
 }
 export declare function reference<T>(node: RuntimeNode<T>[], path: string, ctx: McdocCheckerContext<T>): void;
 export declare function dispatcher<T>(node: RuntimeNode<T>[], registry: FullResourceLocation, index: string | Index | ParallelIndices, ctx: McdocCheckerContext<T>): void;
-export declare function isAssignable(assignValue: McdocType, typeDef: McdocType, ctx: CheckerContext, isEquivalent?: NodeEquivalenceChecker): boolean;
+export declare function isAssignable(assignValue: McdocType, typeDef: McdocType, ctx: CheckerContext, convert?: TypeConverter<McdocType>): boolean;
 export interface CheckerTreeNode<T> {
     parent: CheckerTreeRuntimeNode<T> | undefined;
     runtimeKey: RuntimeNode<T> | undefined;

package/lib/runtime/checker/index.js

@@ -18,7 +18,7 @@ export function dispatcher(node, registry, index, ctx) {
             : [index];
     typeDefinition(node, { kind: 'dispatcher', registry, parallelIndices }, ctx);
 }
-export function isAssignable(assignValue, typeDef, ctx, isEquivalent) {
+export function isAssignable(assignValue, typeDef, ctx, convert) {
     if (assignValue.kind === 'literal' && typeDef.kind === 'literal'
         && assignValue.value.kind === typeDef.value.kind
         && !assignValue.attributes && !typeDef.attributes) {
@@ -26,18 +26,27 @@ export function isAssignable(assignValue, typeDef, ctx, isEquivalent) {
     }
     let ans = true;
     const newCtx = McdocCheckerContext.create(ctx, {
-        isEquivalent,
+        tryConvertTo: convert,
         getChildren: (_, d) => {
             switch (d.kind) {
                 case 'list':
                     const vals = getPossibleTypes(d.item);
                     return [vals.map(v => ({ originalNode: v, inferredType: v }))];
                 case 'byte_array':
-                    return [[{ originalNode: { kind: 'byte' }, inferredType: { kind: 'byte' } }]];
+                    return [[{
+                                originalNode: { kind: 'byte' },
+                                inferredType: { kind: 'byte' },
+                            }]];
                 case 'int_array':
-                    return [[{ originalNode: { kind: 'int' }, inferredType: { kind: 'int' } }]];
+                    return [[{
+                                originalNode: { kind: 'int' },
+                                inferredType: { kind: 'int' },
+                            }]];
                 case 'long_array':
-                    return [[{ originalNode: { kind: 'long' }, inferredType: { kind: 'long' } }]];
+                    return [[{
+                                originalNode: { kind: 'long' },
+                                inferredType: { kind: 'long' },
+                            }]];
                 case 'struct':
                     return d.fields.map(f => {
                         const vals = getPossibleTypes(f.type);
@@ -278,9 +287,13 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
         return { childDefinitions, errors: [] };
     }
     const typeDefValueType = getValueType(typeDef);
-    const runtimeValueType = getValueType(simplifiedInferred);
-    if (runtimeValueType.kind !== typeDefValueType.kind
-        && !ctx.isEquivalent(runtimeValueType, typeDefValueType)) {
+    let runtimeValueType = getValueType(simplifiedInferred);
+    if (runtimeValueType.kind !== typeDefValueType.kind) {
+        simplifiedInferred = ctx.tryConvertTo(runtimeNode.originalNode, typeDefValueType)
+            ?? simplifiedInferred;
+        runtimeValueType = getValueType(simplifiedInferred);
+    }
+    if (runtimeValueType.kind !== typeDefValueType.kind) {
         return {
             childDefinitions,
             errors: [{ kind: 'type_mismatch', node: runtimeNode, expected: [typeDef] }],
@@ -378,14 +391,22 @@ function checkShallowly(runtimeNode, simplifiedInferred, children, typeDef, ctx)
                 }
                 if (!foundMatch) {
                     for (const kvp of otherKvps) {
-                        if (isAssignable(kvp.value.key.inferredType, pair.key, ctx, ctx.isEquivalent)) {
+                        if (isAssignable(kvp.value.key.inferredType, pair.key, ctx, (type, target) => type === kvp.value.key.inferredType
+                            ? ctx.tryConvertTo(kvp.value.key.originalNode, target)
+                            : undefined)) {
                             foundMatch = true;
                             otherKvpMatches.push(kvp.index);
                         }
                     }
                     for (const kvp of literalKvps.entries()) {
+                        const literalType = {
+                            kind: 'literal',
+                            value: { kind: 'string', value: kvp[0] },
+                        };
                         if ((!kvp[1].definition || kvp[1].definition.keyType?.kind !== 'literal')
-                            && isAssignable({ kind: 'literal', value: { kind: 'string', value: kvp[0] } }, pair.key, ctx, ctx.isEquivalent)) {
+                            && kvp[1].values.some(v => isAssignable(literalType, pair.key, ctx, (type, target) => type === literalType
+                                ? ctx.tryConvertTo(v.pair.key.originalNode, target)
+                                : undefined))) {
                             foundMatch = true;
                             kvp[1].definition = { keyType: pair.key, type: pair.type, desc: pair.desc };
                         }

package/lib/type/index.d.ts

@@ -160,6 +160,9 @@ export interface LiteralLongNumberValue {
     kind: 'long';
     value: bigint;
 }
+export declare namespace LiteralNumericValue {
+    function makeIfValid(kind: string, value: number | bigint, allowInt?: boolean, allowFloat?: boolean): LiteralNumericValue | LiteralLongNumberValue | undefined;
+}
 export interface LiteralType extends McdocBaseType {
     kind: 'literal';
     value: LiteralValue;

package/lib/type/index.js

@@ -150,6 +150,46 @@ export function createEmptyUnion(attributes) {
         // attributes,
     };
 }
+export var LiteralNumericValue;
+(function (LiteralNumericValue) {
+    function makeIfValid(kind, value, allowInt = true, allowFloat = true) {
+        value = Number(value);
+        switch (kind) {
+            case 'byte':
+                if (allowInt && value >= -128 && value < 128) {
+                    return { kind: 'byte', value };
+                }
+                break;
+            case 'short':
+                if (allowInt && value >= -32768 && value < 32768) {
+                    return { kind: 'short', value };
+                }
+                break;
+            case 'int':
+                if (allowInt && value >= -2147483648 && value < 2147483648) {
+                    return { kind: 'int', value };
+                }
+                break;
+            case 'long':
+                if (allowInt && value >= -9223372036854775808n && value < 9223372036854775808n) {
+                    return { kind: 'long', value: BigInt(value) };
+                }
+                break;
+            case 'float':
+                if (allowFloat) {
+                    return { kind: 'float', value };
+                }
+                break;
+            case 'double':
+                if (allowFloat) {
+                    return { kind: 'double', value };
+                }
+                break;
+        }
+        return undefined;
+    }
+    LiteralNumericValue.makeIfValid = makeIfValid;
+})(LiteralNumericValue || (LiteralNumericValue = {}));
 export const NumericTypeIntKinds = Object.freeze(['byte', 'short', 'int', 'long']);
 export const NumericTypeFloatKinds = Object.freeze(['float', 'double']);
 export const NumericTypeKinds = Object.freeze([...NumericTypeIntKinds, ...NumericTypeFloatKinds]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "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.46",
-    "@spyglassmc/locales": "0.3.24"
+    "@spyglassmc/core": "0.4.48",
+    "@spyglassmc/locales": "0.3.25"
   }
 }