@spyglassmc/mcdoc 0.3.1 → 0.3.3

package/lib/parser/index.js

@@ -1,8 +1,8 @@
 import * as core from '@spyglassmc/core';
-import { any, Arrayable, failOnEmpty, failOnError, Failure, map, optional, Range, repeat, ResourceLocation, select, sequence, setType, stopBefore, validate } from '@spyglassmc/core';
+import { any, Arrayable, failOnEmpty, failOnError, Failure, map, optional, Range, repeat, ResourceLocation, select, sequence, setType, stopBefore, validate, } from '@spyglassmc/core';
 import { arrayToMessage, localeQuote, localize } from '@spyglassmc/locales';
 import { RangeExclusiveChar } from '../node/index.js';
-import { LiteralNumberCaseInsensitiveSuffixes, NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords } from '../type/index.js';
+import { LiteralNumberCaseInsensitiveSuffixes, NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords, } from '../type/index.js';
 /**
  * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
  *
@@ -20,7 +20,9 @@ delegatesDocComments = false) {
     return (src, ctx) => {
         const ans = [];
         src.skipWhitespace();
-        while (src.canRead() && src.peek(2) === '//' && (!delegatesDocComments || src.peek(3) !== '///')) {
+        while (src.canRead() &&
+            src.peek(2) === '//' &&
+            (!delegatesDocComments || src.peek(3) !== '///')) {
             const result = comment(src, ctx);
             ans.push(result);
             src.skipWhitespace();
@@ -47,9 +49,10 @@ export function literal(literal, options) {
             value: '',
             colorTokenType: options?.colorTokenType,
         };
-        ans.value = src.readIf(c => options?.allowedChars?.has(c) ?? (options?.specialChars?.has(c) || /[a-z]/i.test(c)));
+        ans.value = src.readIf((c) => options?.allowedChars?.has(c) ??
+            (options?.specialChars?.has(c) || /[a-z]/i.test(c)));
         ans.range.end = src.cursor;
-        if (Arrayable.toArray(literal).every(l => l !== ans.value)) {
+        if (Arrayable.toArray(literal).every((l) => l !== ans.value)) {
             ctx.err.report(localize('expected-got', arrayToMessage(literal), localeQuote(ans.value)), ans);
         }
         return ans;
@@ -83,22 +86,54 @@ function marker(punctuation) {
     };
 }
 export function resLoc(options) {
-    return validate(core.resourceLocation(options), res => res.namespace !== undefined, localize('mcdoc.parser.resource-location.colon-expected', localeQuote(ResourceLocation.NamespacePathSep)));
+    return validate(core.resourceLocation(options), (res) => res.namespace !== undefined, localize('mcdoc.parser.resource-location.colon-expected', localeQuote(ResourceLocation.NamespacePathSep)));
 }
 const UnicodeControlCharacters = Object.freeze([
-    '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06',
-    '\x07', '\x08', '\x09', '\x0A', '\x0B', '\x0C', '\x0D',
-    '\x0E', '\x0F', '\x7F',
+    '\x00',
+    '\x01',
+    '\x02',
+    '\x03',
+    '\x04',
+    '\x05',
+    '\x06',
+    '\x07',
+    '\x08',
+    '\x09',
+    '\x0A',
+    '\x0B',
+    '\x0C',
+    '\x0D',
+    '\x0E',
+    '\x0F',
+    '\x7F',
 ]);
 export const string = stopBefore(core.string({
-    escapable: { characters: ['b', 'f', 'n', 'r', 't', '\\', '"'], unicode: true },
+    escapable: {
+        characters: ['b', 'f', 'n', 'r', 't', '\\', '"'],
+        unicode: true,
+    },
     quotes: ['"'],
 }), ...UnicodeControlCharacters);
 export const identifier = (src, ctx) => {
     // https://spyglassmc.com/user/mcdoc/#identifier
     const IdentifierStart = /^[\p{L}\p{Nl}]$/u;
     const IdentifierContinue = /^[\p{L}\p{Nl}\u200C\u200D\p{Mn}\p{Mc}\p{Nd}\p{Pc}]$/u;
-    const ReservedWords = new Set(['any', 'boolean', 'byte', 'double', 'enum', 'false', 'float', 'int', 'long', 'short', 'string', 'struct', 'super', 'true']);
+    const ReservedWords = new Set([
+        'any',
+        'boolean',
+        'byte',
+        'double',
+        'enum',
+        'false',
+        'float',
+        'int',
+        'long',
+        'short',
+        'string',
+        'struct',
+        'super',
+        'true',
+    ]);
     const ans = {
         type: 'mcdoc:identifier',
         range: Range.create(src),
@@ -145,7 +180,7 @@ function indexBody(options) {
     const index = select([
         {
             prefix: '%',
-            parser: literal(StaticIndexKeywords.map(v => `%${v}`), { specialChars: new Set(['%']) }),
+            parser: literal(StaticIndexKeywords.map((v) => `%${v}`), { specialChars: new Set(['%']) }),
         },
         {
             prefix: '"',
@@ -158,7 +193,13 @@ function indexBody(options) {
                 : dynamicIndex,
         },
         {
-            parser: any([resLoc({ category: 'mcdoc/dispatcher', accessType: options?.accessType }), identifier]),
+            parser: any([
+                resLoc({
+                    category: 'mcdoc/dispatcher',
+                    accessType: options?.accessType,
+                }),
+                identifier,
+            ]),
         },
     ]);
     return setType('mcdoc:index_body', syntax([
@@ -178,10 +219,7 @@ export const path = (src, ctx) => {
     if (src.trySkip('::')) {
         isAbsolute = true;
     }
-    return map(sequence([
-        pathSegment,
-        repeat(sequence([marker('::'), pathSegment])),
-    ]), res => {
+    return map(sequence([pathSegment, repeat(sequence([marker('::'), pathSegment]))]), (res) => {
         const ans = {
             type: 'mcdoc:path',
             children: res.children,
@@ -196,12 +234,12 @@ const attributeTreePosValues = setType('mcdoc:attribute/tree/pos', syntax([
     syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(attributeValue) }], true), true),
 ], true));
 const attributeNamedValue = syntax([
+    select([{ prefix: '"', parser: string }, { parser: identifier }]),
     select([
-        { prefix: '"', parser: string },
-        { parser: identifier },
-    ]),
-    select([
-        { prefix: '=', parser: syntax([punctuation('='), { get: () => attributeValue }], true) },
+        {
+            prefix: '=',
+            parser: syntax([punctuation('='), { get: () => attributeValue }], true),
+        },
         { parser: { get: () => attributeTree } },
     ]),
 ], true);
@@ -211,7 +249,12 @@ const attributeTreeNamedValues = setType('mcdoc:attribute/tree/named', syntax([
 ], true));
 const treeBody = any([
     syntax([attributeTreeNamedValues, optional(marker(','))]),
-    syntax([attributeTreePosValues, punctuation(','), attributeTreeNamedValues, optional(marker(','))]),
+    syntax([
+        attributeTreePosValues,
+        punctuation(','),
+        attributeTreeNamedValues,
+        optional(marker(',')),
+    ]),
     syntax([attributeTreePosValues, optional(marker(','))]),
 ]);
 const AttributeTreeClosure = Object.freeze({
@@ -220,7 +263,13 @@ const AttributeTreeClosure = Object.freeze({
     '{': '}',
 });
 const attributeTree = (src, ctx) => {
-    const delim = src.trySkip('(') ? '(' : (src.trySkip('[') ? '[' : (src.trySkip('{') ? '{' : undefined));
+    const delim = src.trySkip('(')
+        ? '('
+        : src.trySkip('[')
+            ? '['
+            : src.trySkip('{')
+                ? '{'
+                : undefined;
     if (!delim) {
         return Failure;
     }
@@ -235,24 +284,60 @@ const attributeTree = (src, ctx) => {
     return ans;
 };
 const attributeValue = select([
-    { predicate: src => ['(', '[', '{'].includes(src.peek()), parser: attributeTree },
+    {
+        predicate: (src) => ['(', '[', '{'].includes(src.peek()),
+        parser: attributeTree,
+    },
     { parser: { get: () => type } },
 ]);
 export const attribute = setType('mcdoc:attribute', syntax([
     marker('#['),
     identifier,
     select([
-        { prefix: '=', parser: syntax([punctuation('='), attributeValue, punctuation(']')], true) },
-        { predicate: src => ['(', '[', '{'].includes(src.peek()), parser: syntax([attributeTree, punctuation(']')], true) },
+        {
+            prefix: '=',
+            parser: syntax([punctuation('='), attributeValue, punctuation(']')], true),
+        },
+        {
+            predicate: (src) => ['(', '[', '{'].includes(src.peek()),
+            parser: syntax([
+                attributeTree,
+                punctuation(']'),
+            ], true),
+        },
         { parser: punctuation(']') },
     ]),
 ], true));
 const attributes = repeat(attribute);
+const typeParam = setType('mcdoc:type_param', syntax([
+    identifier,
+    // optional(syntax([failOnError(literal('extends')), { get: () => type }])),
+]));
+const typeParamBlock = setType('mcdoc:type_param_block', syntax([
+    punctuation('<'),
+    select([
+        { prefix: '>', parser: punctuation('>') },
+        {
+            parser: syntax([
+                typeParam,
+                syntaxRepeat(syntax([marker(','), failOnEmpty(typeParam)])),
+                optional(marker(',')),
+                punctuation('>'),
+            ]),
+        },
+    ]),
+]));
+const noop = () => undefined;
+const optionalTypeParamBlock = select([{ prefix: '<', parser: typeParamBlock }, { parser: noop }]);
 export const dispatchStatement = setType('mcdoc:dispatch_statement', syntax([
     attributes,
     keyword('dispatch'),
-    resLoc({ category: 'mcdoc/dispatcher', accessType: 1 /* SymbolAccessType.Write */ }),
+    resLoc({
+        category: 'mcdoc/dispatcher',
+        accessType: 1 /* SymbolAccessType.Write */,
+    }),
     indexBody({ noDynamic: true }),
+    optionalTypeParamBlock,
     literal('to'),
     { get: () => type },
 ], true));
@@ -260,40 +345,26 @@ export const docComment = core.comment({
     singleLinePrefixes: new Set(['///']),
     includesEol: true,
 });
-export const docComments = setType('mcdoc:doc_comments', repeat(docComment, src => {
+export const docComments = setType('mcdoc:doc_comments', repeat(docComment, (src) => {
     src.skipWhitespace();
     return [];
 }));
-const prelim = syntax([
-    optional(failOnEmpty(docComments)),
-    attributes,
-]);
-const enumType = literal([
-    'byte',
-    'short',
-    'int',
-    'long',
-    'string',
-    'float',
-    'double',
-], { colorTokenType: 'type' });
+const prelim = syntax([optional(failOnEmpty(docComments)), attributes]);
+const enumType = literal(['byte', 'short', 'int', 'long', 'string', 'float', 'double'], { colorTokenType: 'type' });
 export const float = core.float({
     pattern: /^[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)?|[0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?)$/,
 });
 export const typedNumber = setType('mcdoc:typed_number', sequence([
     float,
-    optional(keyword(LiteralNumberCaseInsensitiveSuffixes, { colorTokenType: 'keyword' })),
+    optional(keyword(LiteralNumberCaseInsensitiveSuffixes, {
+        colorTokenType: 'keyword',
+    })),
 ]));
 const enumValue = select([
     { prefix: '"', parser: string },
     { parser: typedNumber },
 ]);
-const enumField = setType('mcdoc:enum/field', syntax([
-    prelim,
-    identifier,
-    punctuation('='),
-    enumValue,
-], true));
+const enumField = setType('mcdoc:enum/field', syntax([prelim, identifier, punctuation('='), enumValue], true));
 const enumBlock = setType('mcdoc:enum/block', syntax([
     punctuation('{'),
     select([
@@ -317,11 +388,7 @@ export const enum_ = setType('mcdoc:enum', syntax([
     optional(failOnError(identifier)),
     enumBlock,
 ], true));
-const structMapKey = setType('mcdoc:struct/map_key', syntax([
-    punctuation('['),
-    { get: () => type },
-    punctuation(']'),
-], true));
+const structMapKey = setType('mcdoc:struct/map_key', syntax([punctuation('['), { get: () => type }, punctuation(']')], true));
 const structKey = select([
     { prefix: '"', parser: string },
     { prefix: '[', parser: structMapKey },
@@ -329,17 +396,11 @@ const structKey = select([
 ]);
 const structPairField = (src, ctx) => {
     let isOptional;
-    const result0 = syntax([
-        prelim,
-        structKey,
-    ], true)(src, ctx);
+    const result0 = syntax([prelim, structKey], true)(src, ctx);
     if (src.trySkip('?')) {
         isOptional = true;
     }
-    const result1 = syntax([
-        punctuation(':'),
-        { get: () => type },
-    ], true)(src, ctx);
+    const result1 = syntax([punctuation(':'), { get: () => type }], true)(src, ctx);
     const ans = {
         type: 'mcdoc:struct/field/pair',
         children: [...result0.children, ...result1.children],
@@ -348,15 +409,8 @@ const structPairField = (src, ctx) => {
     };
     return ans;
 };
-const structSpreadField = setType('mcdoc:struct/field/spread', syntax([
-    attributes,
-    marker('...'),
-    { get: () => type },
-], true));
-const structField = any([
-    structSpreadField,
-    structPairField,
-]);
+const structSpreadField = setType('mcdoc:struct/field/spread', syntax([attributes, marker('...'), { get: () => type }], true));
+const structField = any([structSpreadField, structPairField]);
 const structBlock = setType('mcdoc:struct/block', syntax([
     punctuation('{'),
     select([
@@ -385,11 +439,7 @@ const enumInjection = setType('mcdoc:injection/enum', syntax([
     path,
     enumBlock,
 ]));
-const structInjection = setType('mcdoc:injection/struct', syntax([
-    literal('struct'),
-    path,
-    structBlock,
-]));
+const structInjection = setType('mcdoc:injection/struct', syntax([literal('struct'), path, structBlock]));
 export const injection = setType('mcdoc:injection', syntax([
     keyword('inject'),
     select([
@@ -397,31 +447,8 @@ export const injection = setType('mcdoc:injection', syntax([
         { parser: structInjection },
     ]),
 ]));
-const typeParam = setType('mcdoc:type_param', syntax([
-    identifier,
-    // optional(syntax([failOnError(literal('extends')), { get: () => type }])),
-]));
-const typeParamBlock = setType('mcdoc:type_param_block', syntax([
-    punctuation('<'),
-    select([
-        { prefix: '>', parser: punctuation('>') },
-        {
-            parser: syntax([
-                typeParam,
-                syntaxRepeat(syntax([marker(','), failOnEmpty(typeParam)])),
-                optional(marker(',')),
-                punctuation('>'),
-            ]),
-        },
-    ]),
-]));
-const noop = () => undefined;
-const optionalTypeParamBlock = select([
-    { prefix: '<', parser: typeParamBlock },
-    { parser: noop },
-]);
-export const typeAlias = setType('mcdoc:type_alias', syntax([
-    docComments,
+export const typeAliasStatement = setType('mcdoc:type_alias', syntax([
+    prelim,
     keyword('type'),
     identifier,
     optionalTypeParamBlock,
@@ -442,16 +469,33 @@ const topLevel = any([
     enum_,
     injection,
     struct,
-    typeAlias,
+    typeAliasStatement,
     useStatement,
 ]);
 export const module_ = setType('mcdoc:module', syntaxRepeat(topLevel, true));
+const typeArgBlock = setType('mcdoc:type_arg_block', syntax([
+    marker('<'),
+    select([
+        { prefix: '>', parser: punctuation('>') },
+        {
+            parser: syntax([
+                { get: () => type },
+                syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(type) }], true), true),
+                optional(marker(',')),
+                punctuation('>'),
+            ], true),
+        },
+    ]),
+]));
 /* eslint-enable @typescript-eslint/indent */
 function typeBase(type, parser) {
     return setType(type, syntax([
         attributes,
         parser,
-        syntaxRepeat(failOnError(indexBody())),
+        syntaxRepeat(select([
+            { prefix: '<', parser: typeArgBlock },
+            { parser: failOnError(indexBody()) },
+        ])),
     ], true));
 }
 export const anyType = typeBase('mcdoc:type/any', keyword('any', { colorTokenType: 'type' }));
@@ -472,10 +516,7 @@ function range(type, number) {
     return setType(type, select([
         {
             predicate: delimiterPredicate,
-            parser: sequence([
-                delimiterParser,
-                number,
-            ]),
+            parser: sequence([delimiterParser, number]),
         },
         {
             parser: sequence([
@@ -502,12 +543,12 @@ const atIntRange = optional((src, ctx) => {
     src.skipWhitespace();
     return intRange(src, ctx);
 });
-export const stringType = typeBase('mcdoc:type/string', syntax([
-    keyword('string', { colorTokenType: 'type' }),
-    atIntRange,
-]));
+export const stringType = typeBase('mcdoc:type/string', syntax([keyword('string', { colorTokenType: 'type' }), atIntRange]));
 export const literalType = typeBase('mcdoc:type/literal', select([
-    { predicate: src => src.tryPeek('false') || src.tryPeek('true'), parser: keyword(['false', 'true'], { colorTokenType: 'type' }) },
+    {
+        predicate: (src) => src.tryPeek('false') || src.tryPeek('true'),
+        parser: keyword(['false', 'true'], { colorTokenType: 'type' }),
+    },
     { prefix: '"', parser: failOnEmpty(string) },
     { parser: failOnError(typedNumber) },
 ]));
@@ -521,7 +562,7 @@ const atFloatRange = optional((src, ctx) => {
 });
 export const numericType = typeBase('mcdoc:type/numeric_type', select([
     {
-        predicate: src => NumericTypeFloatKinds.some(k => src.tryPeek(k)),
+        predicate: (src) => NumericTypeFloatKinds.some((k) => src.tryPeek(k)),
         parser: syntax([
             keyword(NumericTypeFloatKinds, { colorTokenType: 'type' }),
             atFloatRange,
@@ -537,15 +578,13 @@ export const numericType = typeBase('mcdoc:type/numeric_type', select([
 export const primitiveArrayType = typeBase('mcdoc:type/primitive_array', syntax([
     literal(PrimitiveArrayValueKinds),
     atIntRange,
-    keyword('[]', { allowedChars: new Set(['[', ']']), colorTokenType: 'type' }),
+    keyword('[]', {
+        allowedChars: new Set(['[', ']']),
+        colorTokenType: 'type',
+    }),
     atIntRange,
 ]));
-export const listType = typeBase('mcdoc:type/list', syntax([
-    marker('['),
-    { get: () => type },
-    punctuation(']'),
-    atIntRange,
-], true));
+export const listType = typeBase('mcdoc:type/list', syntax([marker('['), { get: () => type }, punctuation(']'), atIntRange], true));
 export const tupleType = typeBase('mcdoc:type/tuple', syntax([
     marker('['),
     { get: () => type },
@@ -562,10 +601,7 @@ export const tupleType = typeBase('mcdoc:type/tuple', syntax([
         },
     ]),
 ], true));
-export const dispatcherType = typeBase('mcdoc:type/dispatcher', syntax([
-    failOnError(resLoc({ category: 'mcdoc/dispatcher' })),
-    indexBody(),
-]));
+export const dispatcherType = typeBase('mcdoc:type/dispatcher', syntax([failOnError(resLoc({ category: 'mcdoc/dispatcher' })), indexBody()]));
 export const unionType = typeBase('mcdoc:type/union', syntax([
     marker('('),
     select([
@@ -580,23 +616,7 @@ export const unionType = typeBase('mcdoc:type/union', syntax([
         },
     ]),
 ]));
-export const referenceType = typeBase('mcdoc:type/reference', syntax([
-    path,
-    optional(syntax([
-        marker('<'),
-        select([
-            { prefix: '>', parser: punctuation('>') },
-            {
-                parser: syntax([
-                    { get: () => type },
-                    syntaxRepeat(syntax([marker(','), { get: () => failOnEmpty(type) }], true), true),
-                    optional(marker(',')),
-                    punctuation('>'),
-                ], true),
-            },
-        ]),
-    ])),
-]));
+export const referenceType = typeBase('mcdoc:type/reference', syntax([path]));
 export const type = any([
     anyType,
     booleanType,