@spyglassmc/mcdoc 0.2.0 → 0.3.0

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { CommentNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
 export const ModuleNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:module';
@@ -16,6 +16,14 @@ export const TopLevelNode = Object.freeze({
     },
 });
 export const DispatchStatementNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            location: node.children.find(ResourceLocationNode.is),
+            index: node.children.find(IndexBodyNode.is),
+            target: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:dispatch_statement';
     },
@@ -26,6 +34,11 @@ export const LiteralNode = Object.freeze({
     },
 });
 export const IndexBodyNode = Object.freeze({
+    destruct(node) {
+        return {
+            parallelIndices: node.children.filter(IndexNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:index_body';
     },
@@ -46,6 +59,11 @@ export const IdentifierNode = Object.freeze({
     },
 });
 export const DynamicIndexNode = Object.freeze({
+    destruct(node) {
+        return {
+            keys: node.children.filter(AccessorKeyNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:dynamic_index';
     },
@@ -67,15 +85,26 @@ export const TypeNode = Object.freeze({
             TupleTypeNode.is(node) ||
             EnumNode.is(node) ||
             StructNode.is(node) ||
-            PathNode.is(node) ||
+            ReferenceTypeNode.is(node) ||
             DispatcherTypeNode.is(node) ||
             UnionTypeNode.is(node));
     },
-    asType(node) {
-        throw '// TODO';
+});
+export const TypeBaseNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            indices: node.children.filter(IndexBodyNode.is),
+        };
     },
 });
 export const AttributeNode = Object.freeze({
+    destruct(node) {
+        return {
+            name: node.children.find(IdentifierNode.is),
+            value: node.children.find(AttributeValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute';
     },
@@ -86,16 +115,46 @@ export const AttributeValueNode = Object.freeze({
     },
 });
 export const AttributeTreeNode = Object.freeze({
+    destruct(node) {
+        return {
+            positional: node.children.find(AttributeTreePosValuesNode.is),
+            named: node.children.find(AttributeTreeNamedValuesNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute/tree';
     },
 });
 export const AttributeTreePosValuesNode = Object.freeze({
+    destruct(node) {
+        return {
+            values: node.children.filter(AttributeValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute/tree/pos';
     },
 });
 export const AttributeTreeNamedValuesNode = Object.freeze({
+    destruct(node) {
+        const ans = {
+            values: [],
+        };
+        let key;
+        for (const child of node.children) {
+            if (CommentNode.is(child)) {
+                continue;
+            }
+            if (IdentifierNode.is(child) || StringNode.is(child)) {
+                key = child;
+            }
+            else if (key) {
+                ans.values.push({ key, value: child });
+                key = undefined;
+            }
+        }
+        return ans;
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute/tree/named';
     },
@@ -110,68 +169,229 @@ export const BooleanTypeNode = Object.freeze({
         return node?.type === 'mcdoc:type/boolean';
     },
 });
-export const StringTypeNode = Object.freeze({
-    is(node) {
-        return node?.type === 'mcdoc:type/string';
-    },
-});
 export const IntRangeNode = Object.freeze({
+    destruct(node) {
+        return destructRangeNode(node);
+    },
     is(node) {
         return node?.type === 'mcdoc:int_range';
     },
 });
 export const LiteralTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            value: node.children.find(LiteralTypeValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/literal';
     },
 });
+export const LiteralTypeValueNode = Object.freeze({
+    is(node) {
+        return LiteralNode.is(node) || TypedNumberNode.is(node) || StringNode.is(node);
+    },
+});
 export const TypedNumberNode = Object.freeze({
+    destruct(node) {
+        return {
+            value: node.children.find(FloatNode.is),
+            suffix: node.children.find(LiteralNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:typed_number';
     },
 });
 export const NumericTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            numericKind: node.children.find(LiteralNode.is),
+            valueRange: node.children.find(FloatRangeNode.is) || node.children.find(IntRangeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/numeric_type';
     },
 });
+export const RangeExclusiveChar = '<';
+export function getRangeDelimiter(kind) {
+    const prefix = kind & 0b10 ? RangeExclusiveChar : '';
+    const suffix = kind & 0b01 ? RangeExclusiveChar : '';
+    return `${prefix}..${suffix}`;
+}
+function destructRangeNode(node) {
+    let kind;
+    let min;
+    let max;
+    if (node.children.length === 1) {
+        // a
+        kind = 0b00;
+        min = max = node.children[0];
+    }
+    else if (node.children.length === 3) {
+        // a..b
+        kind = getKind(node.children[1]);
+        min = node.children[0];
+        max = node.children[2];
+    }
+    else if (LiteralNode.is(node.children[0])) {
+        // ..b
+        kind = getKind(node.children[0]);
+        max = node.children[1];
+    }
+    else {
+        // a..
+        kind = getKind(node.children[1]);
+        min = node.children[0];
+    }
+    return {
+        kind,
+        min,
+        max,
+    };
+    function getKind(delimiter) {
+        let ans = 0b00;
+        if (delimiter.value.startsWith(RangeExclusiveChar)) {
+            ans |= 0b10;
+        }
+        if (delimiter.value.endsWith(RangeExclusiveChar)) {
+            ans |= 0b01;
+        }
+        return ans;
+    }
+}
 export const FloatRangeNode = Object.freeze({
+    destruct(node) {
+        return destructRangeNode(node);
+    },
     is(node) {
         return node?.type === 'mcdoc:float_range';
     },
 });
 export const PrimitiveArrayTypeNode = Object.freeze({
+    destruct(node) {
+        let lengthRange;
+        let valueRange;
+        let afterBrackets = false;
+        for (const child of node.children) {
+            if (LiteralNode.is(child) && child.value === '[]') {
+                afterBrackets = true;
+            }
+            else if (IntRangeNode.is(child)) {
+                if (afterBrackets) {
+                    lengthRange = child;
+                }
+                else {
+                    valueRange = child;
+                }
+            }
+        }
+        return {
+            arrayKind: node.children.find(LiteralNode.is),
+            lengthRange,
+            valueRange,
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/primitive_array';
     },
 });
 export const ListTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            item: node.children.find(TypeNode.is),
+            lengthRange: node.children.find(IntRangeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/list';
     },
 });
+export const StringTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            lengthRange: node.children.find(IntRangeNode.is),
+        };
+    },
+    is(node) {
+        return node?.type === 'mcdoc:type/string';
+    },
+});
 export const TupleTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            items: node.children.filter(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/tuple';
     },
 });
+const EnumKinds = new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']);
 export const EnumNode = Object.freeze({
+    kinds: EnumKinds,
+    destruct(node) {
+        return {
+            block: node.children.find(EnumBlockNode.is),
+            docComments: node.children.find(DocCommentsNode.is),
+            enumKind: getEnumKind(node),
+            identifier: node.children.find(IdentifierNode.is),
+        };
+        function getEnumKind(node) {
+            for (const literal of node.children.filter(LiteralNode.is)) {
+                if (EnumKinds.has(literal.value)) {
+                    return literal.value;
+                }
+            }
+            return undefined;
+        }
+    },
     is(node) {
         return node?.type === 'mcdoc:enum';
     },
-    kinds: new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']),
 });
 export const DocCommentsNode = Object.freeze({
+    /**
+     * @returns The text content of this doc comment block.
+     */
+    asText(node) {
+        if (!node) {
+            return undefined;
+        }
+        let comments = node.children.map(doc => doc.comment);
+        // If every comment contains a leading space or is empty, stripe the leading spaces off.
+        // e.g. /// This is an example doc comment.
+        //      ///
+        //      /// Another line.
+        // should be converted to "This is an example doc comment.\n\nAnother line."
+        if (comments.every(s => s.length === 0 || s.startsWith(' '))) {
+            comments = comments.map(s => s.slice(1));
+        }
+        return comments.join('\n');
+    },
     is(node) {
         return node?.type === 'mcdoc:doc_comments';
     },
 });
 export const EnumBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            fields: node.children.filter(EnumFieldNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:enum/block';
     },
 });
 export const EnumFieldNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+            value: node.children.find(EnumValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:enum/field';
     },
@@ -187,31 +407,68 @@ export const PrelimNode = Object.freeze({
     },
 });
 export const StructNode = Object.freeze({
+    destruct(node) {
+        return {
+            block: node.children.find(StructBlockNode.is),
+            docComments: node.children.find(DocCommentsNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct';
     },
 });
-export const PathTypeNode = Object.freeze({
+export const ReferenceTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            path: node.children.find(PathNode.is),
+            typeParameters: node.children.filter(TypeNode.is),
+        };
+    },
     is(node) {
-        return node?.type === 'mcdoc:type/path';
+        return node?.type === 'mcdoc:type/reference';
     },
 });
 export const TypeParamBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            params: node.children.filter(TypeParamNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type_param_block';
     },
 });
 export const TypeParamNode = Object.freeze({
+    destruct(node) {
+        return {
+            // constraint: node.children.find(TypeNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type_param';
     },
 });
 export const PathNode = Object.freeze({
+    destruct(node) {
+        const lastChild = atArray(node?.children, -1);
+        return {
+            children: node?.children ?? [],
+            isAbsolute: node?.isAbsolute,
+            lastIdentifier: IdentifierNode.is(lastChild) ? lastChild : undefined,
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:path';
     },
 });
 export const StructBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            fields: node.children.filter(StructFieldNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/block';
     },
@@ -222,6 +479,14 @@ export const StructFieldNode = Object.freeze({
     },
 });
 export const StructPairFieldNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            key: node.children.find(StructKeyNode.is),
+            type: node.children.find(TypeNode.is),
+            isOptional: node.isOptional,
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/field/pair';
     },
@@ -232,30 +497,62 @@ export const StructKeyNode = Object.freeze({
     },
 });
 export const StructMapKeyNode = Object.freeze({
+    destruct(node) {
+        return {
+            type: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/map_key';
     },
 });
 export const StructSpreadFieldNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            type: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/field/spread';
     },
 });
 export const DispatcherTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            location: node.children.find(ResourceLocationNode.is),
+            index: node.children.find(IndexBodyNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/dispatcher';
     },
 });
 export const UnionTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            members: node.children.filter(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/union';
     },
 });
 export const InjectionNode = Object.freeze({
+    destruct(node) {
+        return {
+            injection: node.children.find(InjectionContentNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:injection';
     },
 });
+export const InjectionContentNode = Object.freeze({
+    is(node) {
+        return EnumInjectionNode.is(node) || StructInjectionNode.is(node);
+    },
+});
 export const EnumInjectionNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:injection/enum';
@@ -267,11 +564,25 @@ export const StructInjectionNode = Object.freeze({
     },
 });
 export const TypeAliasNode = Object.freeze({
+    destruct(node) {
+        return {
+            docComments: node.children.find(DocCommentsNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+            typeParams: node.children.find(TypeParamBlockNode.is),
+            rhs: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type_alias';
     },
 });
 export const UseStatementNode = Object.freeze({
+    destruct(node) {
+        return {
+            binding: node.children.find(IdentifierNode.is),
+            path: node.children.find(PathNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:use_statement';
     },

package/lib/parser/index.d.ts

@@ -1,6 +1,6 @@
 import type { ColorTokenType, CommentNode, FloatNode, InfallibleParser, IntegerNode, Parser, ResourceLocationNode, ResourceLocationOptions, StringNode } from '@spyglassmc/core';
 import { Arrayable } from '@spyglassmc/core';
-import type { AnyTypeNode, AttributeNode, BooleanTypeNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, EnumNode, IdentifierNode, InjectionNode, ListTypeNode, LiteralNode, LiteralTypeNode, ModuleNode, NumericTypeNode, PathNode, PathTypeNode, PrimitiveArrayTypeNode, StringTypeNode, StructNode, TupleTypeNode, TypeAliasNode, TypedNumberNode, TypeNode, UnionTypeNode, UseStatementNode } from '../node/index.js';
+import type { AnyTypeNode, AttributeNode, BooleanTypeNode, DispatcherTypeNode, DispatchStatementNode, DocCommentsNode, EnumNode, FloatRangeNode, IdentifierNode, InjectionNode, IntRangeNode, ListTypeNode, LiteralNode, LiteralTypeNode, ModuleNode, NumericTypeNode, PathNode, PrimitiveArrayTypeNode, ReferenceTypeNode, StringTypeNode, StructNode, TupleTypeNode, TypeAliasNode, TypedNumberNode, TypeNode, UnionTypeNode, UseStatementNode } from '../node/index.js';
 /**
  * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
  *
@@ -31,14 +31,16 @@ export declare const module_: Parser<ModuleNode>;
 export declare const anyType: Parser<AnyTypeNode>;
 export declare const booleanType: Parser<BooleanTypeNode>;
 export declare const integer: InfallibleParser<IntegerNode>;
+export declare const intRange: InfallibleParser<IntRangeNode>;
 export declare const stringType: Parser<StringTypeNode>;
 export declare const literalType: Parser<LiteralTypeNode>;
+export declare const floatRange: InfallibleParser<FloatRangeNode>;
 export declare const numericType: Parser<NumericTypeNode>;
 export declare const primitiveArrayType: Parser<PrimitiveArrayTypeNode>;
 export declare const listType: Parser<ListTypeNode>;
 export declare const tupleType: Parser<TupleTypeNode>;
 export declare const dispatcherType: Parser<DispatcherTypeNode>;
 export declare const unionType: Parser<UnionTypeNode>;
-export declare const pathType: InfallibleParser<PathTypeNode>;
+export declare const referenceType: InfallibleParser<ReferenceTypeNode>;
 export declare const type: InfallibleParser<TypeNode>;
 //# sourceMappingURL=index.d.ts.map