silverbullet/common/space_lua/parse.ts

import { lezerToParseTree } from "$common/markdown_parser/parse_tree.ts";
import {
    cleanTree,
    type ParseTree,
} from "@silverbulletmd/silverbullet/lib/tree";
import { parser } from "./parse-lua.js";
import { styleTags } from "@lezer/highlight";
import type {
    LuaAttName,
    LuaBlock,
    LuaExpression,
    LuaFunctionBody,
    LuaFunctionCallExpression,
    LuaFunctionName,
    LuaLValue,
    LuaPrefixExpression,
    LuaStatement,
    LuaTableField,
} from "./ast.ts";

const luaStyleTags = styleTags({
    // Identifier: t.variableName,
    // TagIdentifier: t.variableName,
    // GlobalIdentifier: t.variableName,
    // String: t.string,
    // Number: t.number,
    // PageRef: ct.WikiLinkTag,
    // BinExpression: t.operator,
    // TernaryExpression: t.operator,
    // Regex: t.regexp,
    // "where limit select render Order OrderKW and or null as InKW NotKW BooleanKW each all":
    //     t.keyword,
});

export const highlightingQueryParser = parser.configure({
    props: [
        luaStyleTags,
    ],
});

function parseChunk(t: ParseTree): LuaBlock {
    if (t.type !== "Chunk") {
        throw new Error(`Expected Chunk, got ${t.type}`);
    }
    return parseBlock(t.children![0]);
}

function parseBlock(t: ParseTree): LuaBlock {
    if (t.type !== "Block") {
        throw new Error(`Expected Block, got ${t.type}`);
    }
    const statements = t.children!.map(parseStatement);
    return { type: "Block", statements, from: t.from, to: t.to };
}

function parseStatement(t: ParseTree): LuaStatement {
    switch (t.type) {
        case "Block":
            return parseChunk(t.children![0]);
        case "Semicolon":
            return { type: "Semicolon", from: t.from, to: t.to };
        case "Label":
            return {
                type: "Label",
                name: t.children![1].children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "Break":
            return { type: "Break", from: t.from, to: t.to };
        case "Goto":
            return {
                type: "Goto",
                name: t.children![1].children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "Scope":
            return parseBlock(t.children![1]);
        case ";":
            return { type: "Semicolon", from: t.from, to: t.to };
        case "WhileStatement":
            return {
                type: "While",
                condition: parseExpression(t.children![1]),
                block: parseBlock(t.children![3]),
            };
        case "RepeatStatement":
            return {
                type: "Repeat",
                block: parseBlock(t.children![1]),
                condition: parseExpression(t.children![3]),
            };
        case "IfStatement": {
            const conditions: {
                condition: LuaExpression;
                block: LuaBlock;
                from?: number;
                to?: number;
            }[] = [];
            let elseBlock: LuaBlock | undefined = undefined;
            for (let i = 0; i < t.children!.length; i += 4) {
                console.log("Looking at", t.children![i]);
                const child = t.children![i];
                if (
                    child.children![0].text === "if" ||
                    child.children![0].text === "elseif"
                ) {
                    conditions.push({
                        condition: parseExpression(t.children![i + 1]),
                        block: parseBlock(t.children![i + 3]),
                        from: child.from,
                        to: child.to,
                    });
                } else if (child.children![0].text === "else") {
                    elseBlock = parseBlock(t.children![i + 1]);
                } else if (child.children![0].text === "end") {
                    break;
                } else {
                    throw new Error(
                        `Unknown if clause type: ${child.children![0].text}`,
                    );
                }
            }
            return {
                type: "If",
                conditions,
                elseBlock,
                from: t.from,
                to: t.to,
            };
        }
        case "ForStatement":
            if (t.children![1].type === "ForNumeric") {
                const forNumeric = t.children![1];
                return {
                    type: "For",
                    name: forNumeric.children![0].children![0].text!,
                    start: parseExpression(forNumeric.children![2]),
                    end: parseExpression(forNumeric.children![4]),
                    step: forNumeric.children![5]
                        ? parseExpression(forNumeric.children![6])
                        : undefined,
                    block: parseBlock(t.children![3]),
                    from: t.from,
                    to: t.to,
                };
            } else {
                const forGeneric = t.children![1];
                return {
                    type: "ForIn",
                    names: parseNameList(forGeneric.children![0]),
                    expressions: parseExpList(forGeneric.children![2]),
                    block: parseBlock(t.children![3]),
                    from: t.from,
                    to: t.to,
                };
            }
        case "Function":
            return {
                type: "Function",
                name: parseFunctionName(t.children![1]),
                body: parseFunctionBody(t.children![2]),
                from: t.from,
                to: t.to,
            };
        case "LocalFunction":
            return {
                type: "LocalFunction",
                name: t.children![2].children![0].text!,
                body: parseFunctionBody(t.children![3]),
            };
        case "FunctionCall":
            return {
                type: "FunctionCallStatement",
                call: parseExpression(
                    {
                        type: "FunctionCall",
                        children: t.children!,
                        from: t.from,
                        to: t.to,
                    },
                ) as LuaFunctionCallExpression,
            };
        case "Assign":
            return {
                type: "Assignment",
                variables: t.children![0].children!.filter((t) =>
                    t.type !== ","
                ).map(
                    parseLValue,
                ),
                expressions: parseExpList(t.children![2]),
                from: t.from,
                to: t.to,
            };
        case "Local":
            return {
                type: "Local",
                names: parseAttNames(t.children![1]),
                expressions: t.children![3] ? parseExpList(t.children![3]) : [],
                from: t.from,
                to: t.to,
            };
        case "ReturnStatement": {
            const expressions = t.children![1]
                ? parseExpList(t.children![1])
                : [];
            return { type: "Return", expressions, from: t.from, to: t.to };
        }
        case "break":
            return { type: "Break", from: t.from, to: t.to };
        default:
            console.error(t);
            throw new Error(`Unknown statement type: ${t.children![0].text}`);
    }
}

function parseAttNames(t: ParseTree): LuaAttName[] {
    if (t.type !== "AttNameList") {
        throw new Error(`Expected AttNameList, got ${t.type}`);
    }
    return t.children!.filter((t) => t.type !== ",").map(parseAttName);
}

function parseAttName(t: ParseTree): LuaAttName {
    if (t.type !== "AttName") {
        throw new Error(`Expected AttName, got ${t.type}`);
    }
    return {
        type: "AttName",
        name: t.children![0].children![0].text!,
        attribute: t.children![1].children![1]
            ? t.children![1].children![1].children![0].text!
            : undefined,
        from: t.from,
        to: t.to,
    };
}

function parseLValue(t: ParseTree): LuaLValue {
    switch (t.type) {
        case "Name":
            return {
                type: "Variable",
                name: t.children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "Property":
            return {
                type: "PropertyAccess",
                object: parsePrefixExpression(t.children![0]),
                property: t.children![2].children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "MemberExpression":
            return {
                type: "TableAccess",
                object: parsePrefixExpression(t.children![0]),
                key: parseExpression(t.children![2]),
                from: t.from,
                to: t.to,
            };
        default:
            console.error(t);
            throw new Error(`Unknown lvalue type: ${t.type}`);
    }
}

function parseFunctionName(t: ParseTree): LuaFunctionName {
    if (t.type !== "FuncName") {
        throw new Error(`Expected FunctionName, got ${t.type}`);
    }
    const propNames: string[] = [];
    let colonName: string | undefined = undefined;
    for (let i = 0; i < t.children!.length; i += 2) {
        const prop = t.children![i];
        propNames.push(prop.children![0].text!);
        if (t.children![i + 1] && t.children![i + 1].type === ":") {
            colonName = t.children![i + 2].children![0].text!;
            break;
        }
    }
    return {
        type: "FunctionName",
        propNames,
        colonName,
        from: t.from,
        to: t.to,
    };
}

function parseNameList(t: ParseTree): string[] {
    if (t.type !== "NameList") {
        throw new Error(`Expected NameList, got ${t.type}`);
    }
    return t.children!.filter((t) => t.type === "Name").map((t) =>
        t.children![0].text!
    );
}

function parseExpList(t: ParseTree): LuaExpression[] {
    if (t.type !== "ExpList") {
        throw new Error(`Expected ExpList, got ${t.type}`);
    }
    return t.children!.filter((t) => t.type !== ",").map(parseExpression);
}

function parseExpression(t: ParseTree): LuaExpression {
    switch (t.type) {
        case "LiteralString": {
            let cleanString = t.children![0].text!;
            // Remove quotes etc
            cleanString = cleanString.slice(1, -1);
            return {
                type: "String",
                value: cleanString,
                from: t.from,
                to: t.to,
            };
        }
        case "Number":
            return {
                type: "Number",
                value: parseFloat(t.children![0].text!),
                from: t.from,
                to: t.to,
            };
        case "BinaryExpression":
            return {
                type: "Binary",
                operator: t.children![1].children![0].text!,
                left: parseExpression(t.children![0]),
                right: parseExpression(t.children![2]),
                from: t.from,
                to: t.to,
            };
        case "UnaryExpression":
            return {
                type: "Unary",
                operator: t.children![0].children![0].text!,
                argument: parseExpression(t.children![1]),
                from: t.from,
                to: t.to,
            };
        case "Property":
            return {
                type: "PropertyAccess",
                object: parsePrefixExpression(t.children![0]),
                property: t.children![2].children![0].text!,
                from: t.from,
                to: t.to,
            };

        case "Parens":
            return parseExpression(t.children![1]);
        case "FunctionCall": {
            if (t.children![1].type === ":") {
                return {
                    type: "FunctionCall",
                    prefix: parsePrefixExpression(t.children![0]),
                    name: t.children![2].children![0].text!,
                    args: parseFunctionArgs(t.children!.slice(3)),
                    from: t.from,
                    to: t.to,
                };
            }
            return {
                type: "FunctionCall",
                prefix: parsePrefixExpression(t.children![0]),
                args: parseFunctionArgs(t.children!.slice(1)),
                from: t.from,
                to: t.to,
            };
        }
        case "FunctionDef": {
            const body = parseFunctionBody(t.children![1]);
            return {
                type: "FunctionDefinition",
                body,
                from: t.from,
                to: t.to,
            };
        }
        case "Name":
            return {
                type: "Variable",
                name: t.children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "Ellipsis":
            return { type: "Variable", name: "...", from: t.from, to: t.to };
        case "true":
            return { type: "Boolean", value: true, from: t.from, to: t.to };
        case "false":
            return { type: "Boolean", value: false, from: t.from, to: t.to };
        case "TableConstructor":
            return {
                type: "TableConstructor",
                fields: t.children!.slice(1, -1).filter((t) =>
                    ["FieldExp", "FieldProp", "FieldDynamic"].includes(t.type!)
                ).map(parseTableField),
                from: t.from,
                to: t.to,
            };
        case "nil":
            return { type: "Nil", from: t.from, to: t.to };
        default:
            console.error(t);
            throw new Error(`Unknown expression type: ${t.type}`);
    }
}

function parseFunctionArgs(ts: ParseTree[]): LuaExpression[] {
    console.log("Parsing function args", JSON.stringify(ts, null, 2));
    return ts.filter((t) => ![",", "(", ")"].includes(t.type!)).map(
        parseExpression,
    );
}

function parseFunctionBody(t: ParseTree): LuaFunctionBody {
    if (t.type !== "FuncBody") {
        throw new Error(`Expected FunctionBody, got ${t.type}`);
    }
    return {
        type: "FunctionBody",
        parameters: t.children![1].children!.filter((t) =>
            ["Name", "Ellipsis"].includes(t.type!)
        )
            .map((t) => t.children![0].text!),
        block: parseBlock(t.children![3]),
        from: t.from,
        to: t.to,
    };
}

function parsePrefixExpression(t: ParseTree): LuaPrefixExpression {
    switch (t.type) {
        case "Name":
            return {
                type: "Variable",
                name: t.children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "Property":
            return {
                type: "PropertyAccess",
                object: parsePrefixExpression(t.children![0]),
                property: t.children![2].children![0].text!,
                from: t.from,
                to: t.to,
            };
        case "MemberExpression":
            return {
                type: "TableAccess",
                object: parsePrefixExpression(t.children![0]),
                key: parseExpression(t.children![2]),
                from: t.from,
                to: t.to,
            };
        case "Parens":
            return {
                type: "Parenthesized",
                expression: parseExpression(t.children![1]),
                from: t.from,
                to: t.to,
            };
        default:
            console.error(t);
            throw new Error(`Unknown prefix expression type: ${t.type}`);
    }
}

function parseTableField(t: ParseTree): LuaTableField {
    switch (t.type) {
        case "FieldExp":
            return {
                type: "ExpressionField",
                value: parseExpression(t.children![0]),
                from: t.from,
                to: t.to,
            };
        case "FieldProp":
            return {
                type: "PropField",
                key: t.children![0].children![0].text!,
                value: parseExpression(t.children![2]),
                from: t.from,
                to: t.to,
            };
        case "FieldDynamic":
            return {
                type: "DynamicField",
                key: parseExpression(t.children![1]),
                value: parseExpression(t.children![4]),
                from: t.from,
                to: t.to,
            };
        default:
            console.error(t);
            throw new Error(`Unknown table field type: ${t.type}`);
    }
}

export function parse(s: string): LuaBlock {
    const t = parseToCrudeAST(s);
    console.log("Clean tree", JSON.stringify(t, null, 2));
    const result = parseChunk(t);
    console.log("Parsed AST", JSON.stringify(result, null, 2));
    return result;
}

export function parseToCrudeAST(t: string): ParseTree {
    return cleanTree(lezerToParseTree(t, parser.parse(t).topNode), true);
}