@spyglassmc/mcdoc 0.3.1 → 0.3.2

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([
@@ -371,12 +425,7 @@ const structBlock = setType('mcdoc:struct/block', syntax([
         },
     ]),
 ], true));
-export const struct = setType('mcdoc:struct', syntax([
-    prelim,
-    keyword('struct'),
-    optional(failOnEmpty(identifier)),
-    structBlock,
-], true));
+export const struct = setType('mcdoc:struct', syntax([prelim, keyword('struct'), optional(failOnEmpty(identifier)), structBlock], true));
 const enumInjection = setType('mcdoc:injection/enum', syntax([
     literal('enum'),
     punctuation('('),
@@ -385,11 +434,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 +442,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 +464,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 +511,7 @@ function range(type, number) {
     return setType(type, select([
         {
             predicate: delimiterPredicate,
-            parser: sequence([
-                delimiterParser,
-                number,
-            ]),
+            parser: sequence([delimiterParser, number]),
         },
         {
             parser: sequence([
@@ -502,12 +538,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 +557,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 +573,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 +596,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 +611,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,

package/lib/type/index.d.ts

@@ -35,17 +35,12 @@ export declare type Index = StaticIndex | DynamicIndex;
 export declare type ParallelIndices = Index[];
 export interface DispatcherData {
     registry: FullResourceLocation;
-    index: ParallelIndices;
+    parallelIndices: ParallelIndices;
 }
-export interface TypeBase {
-    kind: string;
-    attributes?: Attribute[];
-    indices?: ParallelIndices[];
-}
-export interface DispatcherType extends TypeBase, DispatcherData {
+export interface DispatcherType extends DispatcherData {
     kind: 'dispatcher';
 }
-export interface StructType extends TypeBase {
+export interface StructType {
     kind: 'struct';
     fields: StructTypeField[];
 }
@@ -62,7 +57,7 @@ export interface StructTypeSpreadField {
     attributes?: Attribute[];
     type: McdocType;
 }
-export interface EnumType extends TypeBase {
+export interface EnumType {
     kind: 'enum';
     enumKind?: EnumKind;
     values: EnumTypeField[];
@@ -72,21 +67,42 @@ export interface EnumTypeField {
     identifier: string;
     value: string | number | bigint;
 }
-export interface ReferenceType extends TypeBase {
+export interface ReferenceType {
     kind: 'reference';
     path?: string;
-    typeParameters?: McdocType[];
 }
-export interface UnionType<T extends McdocType = McdocType> extends TypeBase {
+export interface UnionType<T extends McdocType = McdocType> {
     kind: 'union';
     members: T[];
 }
+export interface AttributedType {
+    kind: 'attributed';
+    attribute: Attribute;
+    child: McdocType;
+}
+export interface IndexedType {
+    kind: 'indexed';
+    parallelIndices: Index[];
+    child: McdocType;
+}
+export interface TemplateType {
+    kind: 'template';
+    child: McdocType;
+    typeParams: {
+        path: string;
+    }[];
+}
+export interface ConcreteType {
+    kind: 'concrete';
+    child: McdocType;
+    typeArgs: McdocType[];
+}
 export declare const EmptyUnion: UnionType<never> & NoIndices;
 export declare function createEmptyUnion(attributes?: Attribute[]): UnionType<never> & NoIndices;
-export interface KeywordType extends TypeBase {
-    kind: 'any' | 'boolean';
+export interface KeywordType {
+    kind: 'any' | 'boolean' | 'unsafe';
 }
-export interface StringType extends TypeBase {
+export interface StringType {
     kind: 'string';
     lengthRange?: NumericRange;
 }
@@ -101,7 +117,7 @@ export declare type LiteralValue = {
     value: number;
     suffix: 'b' | 's' | 'l' | 'f' | 'd' | undefined;
 };
-export interface LiteralType extends TypeBase {
+export interface LiteralType {
     kind: 'literal';
     value: LiteralValue;
 }
@@ -109,7 +125,7 @@ export declare const LiteralNumberSuffixes: readonly ["b", "s", "l", "f", "d"];
 export declare type LiteralNumberSuffix = typeof LiteralNumberSuffixes[number];
 export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "B", "S", "L", "F", "D"];
 export declare type LiteralNumberCaseInsensitiveSuffix = typeof LiteralNumberCaseInsensitiveSuffixes[number];
-export interface NumericType extends TypeBase {
+export interface NumericType {
     kind: NumericTypeKind;
     valueRange?: NumericRange;
 }
@@ -119,7 +135,7 @@ export declare const NumericTypeFloatKinds: readonly ["float", "double"];
 export declare type NumericTypeFloatKind = typeof NumericTypeFloatKinds[number];
 export declare const NumericTypeKinds: readonly ["byte", "short", "int", "long", "float", "double"];
 export declare type NumericTypeKind = typeof NumericTypeKinds[number];
-export interface PrimitiveArrayType extends TypeBase {
+export interface PrimitiveArrayType {
     kind: 'byte_array' | 'int_array' | 'long_array';
     valueRange?: NumericRange;
     lengthRange?: NumericRange;
@@ -128,16 +144,16 @@ export declare const PrimitiveArrayValueKinds: readonly ["byte", "int", "long"];
 export declare type PrimitiveArrayValueKind = typeof PrimitiveArrayValueKinds[number];
 export declare const PrimitiveArrayKinds: readonly ("byte_array" | "int_array" | "long_array")[];
 export declare type PrimitiveArrayKind = typeof PrimitiveArrayKinds[number];
-export interface ListType extends TypeBase {
+export interface ListType {
     kind: 'list';
     item: McdocType;
     lengthRange?: NumericRange;
 }
-export interface TupleType extends TypeBase {
+export interface TupleType {
     kind: 'tuple';
     items: McdocType[];
 }
-export declare type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType;
+export declare type McdocType = DispatcherType | EnumType | KeywordType | ListType | LiteralType | NumericType | PrimitiveArrayType | ReferenceType | StringType | StructType | TupleType | UnionType | AttributedType | IndexedType | TemplateType | ConcreteType;
 export declare namespace McdocType {
     function toString(type: McdocType | undefined): string;
 }
@@ -160,7 +176,7 @@ export declare type ResolvedType = (Exclude<McdocType, DispatcherType | Referenc
 declare type NoIndices = {
     indices?: undefined;
 };
-export interface FlatStructType extends TypeBase {
+export interface FlatStructType {
     kind: 'flat_struct';
     fields: Record<string, McdocType>;
 }
@@ -169,7 +185,7 @@ export declare const unionTypes: (a: McdocType, b: McdocType) => McdocType;
 export declare const simplifyUnionType: (union: UnionType) => McdocType;
 export declare const simplifyListType: (list: ListType) => ListType;
 export declare const simplifyType: (data: McdocType) => McdocType;
-export declare const checkAssignability: ({ source, target }: {
+export declare const checkAssignability: ({ source, target, }: {
     source: McdocType | undefined;
     target: McdocType | undefined;
 }) => {