skir 1.2.3 → 1.2.5

package/dist/parser.js

@@ -1,1323 +0,0 @@
-import { convertCase, unquoteAndUnescape } from "skir-internal";
-import * as Casing from "./casing.js";
-import { mergeDocs } from "./doc_comment_parser.js";
-/** Runs syntactic analysis on a module. */
-export function parseModule(moduleTokens, mode) {
-    const { modulePath, sourceCode } = moduleTokens;
-    const errors = [];
-    const it = new TokenIterator(moduleTokens, mode, errors);
-    const maybeBrokenDeclarations = parseDeclarations(it, "module");
-    const brokenConstants = maybeBrokenDeclarations.filter((d) => d.kind === "broken-constant");
-    const brokenMethods = maybeBrokenDeclarations.filter((d) => d.kind === "broken-method");
-    const declarations = maybeBrokenDeclarations.filter((d) => d.kind !== "broken-constant" && d.kind !== "broken-method");
-    it.expectThenNext([""]);
-    // Create a mappinng from names to declarations, and check for duplicates.
-    const nameToDeclaration = {};
-    const pathToImports = new Map();
-    for (const declaration of declarations) {
-        let nameTokens;
-        let otherModulePath;
-        let importDeclaration;
-        if (declaration.kind === "import") {
-            nameTokens = declaration.importedNames;
-            otherModulePath = resolveModulePath(declaration.modulePath, modulePath, errors);
-            importDeclaration = declaration;
-        }
-        else if (declaration.kind === "import-alias") {
-            nameTokens = [declaration.name];
-            otherModulePath = resolveModulePath(declaration.modulePath, modulePath, errors);
-            importDeclaration = declaration;
-        }
-        else {
-            nameTokens = [declaration.name];
-        }
-        if (otherModulePath) {
-            let imports = pathToImports.get(otherModulePath);
-            if (!imports) {
-                imports = [];
-                pathToImports.set(otherModulePath, imports);
-            }
-            imports.push(importDeclaration);
-            importDeclaration.resolvedModulePath = otherModulePath;
-        }
-        for (const nameToken of nameTokens) {
-            const name = nameToken.text;
-            if (name in nameToDeclaration) {
-                errors.push({
-                    token: nameToken,
-                    message: `Duplicate identifier '${name}'`,
-                });
-            }
-            else {
-                nameToDeclaration[name] = declaration;
-            }
-        }
-    }
-    const importBlockRange = validateImportBlock(declarations, moduleTokens, errors);
-    const pathToImportedNames = {};
-    for (const [path, imports] of pathToImports) {
-        const importsNoAlias = imports.filter((i) => i.kind === "import");
-        const importsWithAlias = imports.filter((i) => i.kind === "import-alias");
-        if (importsNoAlias.length && importsWithAlias.length) {
-            for (const importNoAlias of importsNoAlias) {
-                errors.push({
-                    token: importNoAlias.modulePath,
-                    message: "Module already imported with an alias",
-                });
-            }
-            continue;
-        }
-        if (importsWithAlias.length >= 2) {
-            for (const importWithAlias of importsWithAlias.slice(1)) {
-                errors.push({
-                    token: importWithAlias.modulePath,
-                    message: "Module already imported with a different alias",
-                });
-            }
-            continue;
-        }
-        if (importsNoAlias.length) {
-            const names = new Set();
-            for (const importNoAlias of importsNoAlias) {
-                for (const importedName of importNoAlias.importedNames) {
-                    names.add(importedName.text);
-                }
-            }
-            pathToImportedNames[path] = {
-                kind: "some",
-                names: names,
-            };
-        }
-        else {
-            const alias = importsWithAlias[0].name.text;
-            pathToImportedNames[path] = {
-                kind: "all",
-                alias: alias,
-            };
-        }
-    }
-    const methods = declarations.filter((d) => d.kind === "method");
-    const constants = declarations.filter((d) => d.kind === "constant");
-    return {
-        result: {
-            kind: "module",
-            path: modulePath,
-            sourceCode: sourceCode,
-            nameToDeclaration: nameToDeclaration,
-            declarations: declarations,
-            importBlockRange: importBlockRange,
-            records: collectModuleRecords(declarations),
-            pathToImportedNames: pathToImportedNames,
-            methods: methods,
-            brokenMethods: brokenMethods,
-            constants: constants,
-            brokenConstants: brokenConstants,
-        },
-        errors: errors,
-    };
-}
-function parseDeclarations(it, parentNode) {
-    const result = [];
-    // Returns true on a next token if it indicates that the statement is over.
-    const isEndToken = (t) => t === "" || (parentNode !== "module" && t === "}");
-    // Returns true if the token may be the last token of a valid statement.
-    const isLastToken = (t) => t === "}" || t === ";";
-    while (!isEndToken(it.current)) {
-        const startIndex = it.index;
-        const declaration = parseDeclaration(it, parentNode);
-        if (declaration !== null) {
-            result.push(declaration);
-            if (declaration.kind === "method" ||
-                declaration.kind === "broken-method") {
-                if (declaration.inlineRequestRecord) {
-                    result.push(declaration.inlineRequestRecord);
-                }
-                if (declaration.inlineResponseRecord) {
-                    result.push(declaration.inlineResponseRecord);
-                }
-            }
-        }
-        else {
-            // We have an invalid statement. An error was already registered. Perhaps
-            // the statement was parsed entirely but was incorrect (`removed 1, 1;`), or
-            // zero tokens were consumed (`a`), or a few tokens were consumed but did
-            // not form a statement. We want to recover from whichever scenario to avoid
-            // showing unhelpful extra error messages.
-            const noTokenWasConsumed = it.index === startIndex;
-            if (noTokenWasConsumed) {
-                it.next();
-                if (isLastToken(it.previous)) {
-                    // For example: two semicolons in a row.
-                    continue;
-                }
-            }
-            if (noTokenWasConsumed ||
-                (it.current !== "" && !isLastToken(it.previous))) {
-                let nestedLevel = 0;
-                while (true) {
-                    const token = it.current;
-                    if (token === "") {
-                        break;
-                    }
-                    it.next();
-                    if (token === "{") {
-                        ++nestedLevel;
-                    }
-                    else if (token === "}") {
-                        --nestedLevel;
-                    }
-                    if (nestedLevel <= 0 && isLastToken(token)) {
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    return result;
-}
-function parseDeclaration(it, parentNode) {
-    const doc = collectDoc(it);
-    let recordType = "enum";
-    const parentIsRoot = parentNode === "module";
-    const expected = [
-        /*0:*/ "struct",
-        /*1:*/ "enum",
-        /*2:*/ parentIsRoot ? null : "removed",
-        /*3:*/ parentIsRoot ? null : TOKEN_IS_IDENTIFIER,
-        /*4:*/ parentIsRoot ? "import" : null,
-        /*5:*/ parentIsRoot ? "method" : null,
-        /*6:*/ parentIsRoot ? "const" : null,
-    ];
-    const match = it.expectThenNext(expected);
-    switch (match.case) {
-        case 0:
-            recordType = "struct";
-        // Falls through.
-        case 1:
-            return parseRecord(it, recordType, doc);
-        case 2:
-            return parseRemoved(it, match.token);
-        case 3:
-            return parseField(it, match.token, doc, parentNode);
-        case 4:
-            return parseImport(it, match.token);
-        case 5:
-            return parseMethod(it, doc);
-        case 6:
-            return parseConstant(it, doc);
-        default:
-            return null;
-    }
-}
-class RecordBuilder {
-    constructor(recordName, recordType, doc, stableId, inlineContext, errors) {
-        this.recordName = recordName;
-        this.recordType = recordType;
-        this.doc = doc;
-        this.stableId = stableId;
-        this.inlineContext = inlineContext;
-        this.errors = errors;
-        this.nameToDeclaration = {};
-        this.numbers = new Set();
-        this.numbering = "";
-        this.removedNumbers = [];
-    }
-    addDeclaration(declaration) {
-        if (this.numbering === "broken") {
-            return;
-        }
-        let nameToken;
-        let errorToken;
-        let numbers = [];
-        let newNumbering = this.numbering;
-        // Unless explicitly specified, the number assigned to the first field of an
-        // enum is 1.
-        const nextImplicitNumber = this.numbers.size + (this.recordType === "enum" ? 1 : 0);
-        switch (declaration.kind) {
-            case "field": {
-                nameToken = declaration.name;
-                errorToken = nameToken;
-                newNumbering = declaration.number < 0 ? "implicit" : "explicit";
-                if (declaration.number < 0) {
-                    declaration = { ...declaration, number: nextImplicitNumber };
-                }
-                numbers = [declaration.number];
-                break;
-            }
-            case "record": {
-                nameToken = declaration.name;
-                errorToken = nameToken;
-                break;
-            }
-            case "removed": {
-                errorToken = declaration.removedToken;
-                if (declaration.numbers.length) {
-                    newNumbering = "explicit";
-                    numbers = declaration.numbers;
-                }
-                else {
-                    newNumbering = "implicit";
-                    numbers = [nextImplicitNumber];
-                }
-            }
-        }
-        // Make sure we're not mixing implicit and explicit numbering.
-        if (this.numbering === "") {
-            this.numbering = newNumbering;
-        }
-        else if (this.numbering !== newNumbering) {
-            this.errors.push({
-                token: errorToken,
-                message: "Cannot mix implicit and explicit numbering",
-            });
-            this.numbering = "broken";
-        }
-        // Register the record/field name and make sure it's unique.
-        if (nameToken !== undefined) {
-            const name = nameToken.text;
-            if (name in this.nameToDeclaration) {
-                this.errors.push({
-                    token: nameToken,
-                    message: `Duplicate identifier '${name}'`,
-                });
-                return;
-            }
-            this.nameToDeclaration[name] = declaration;
-        }
-        // Register the field number and make sure it's unique.
-        for (const number of numbers) {
-            if (this.numbers.has(number)) {
-                this.errors.push({
-                    token: errorToken,
-                    message: `Duplicate field number ${number}`,
-                });
-                this.numbering = "broken";
-                return;
-            }
-            else if (number === 0 && this.recordType === "enum") {
-                this.errors.push({
-                    token: errorToken,
-                    message: "Number 0 is reserved for UNKNOWN field",
-                });
-                return;
-            }
-            this.numbers.add(number);
-        }
-        // Register the removed field numbers.
-        if (declaration.kind === "removed") {
-            this.removedNumbers.push(...numbers);
-        }
-    }
-    build() {
-        const isStruct = this.recordType === "struct";
-        // If the record is a struct, make sure that all field numbers are
-        // consecutive starting from 0. The fields of an enum, on the other hand,
-        // can be sparse.
-        if (isStruct) {
-            for (let i = 0; i < this.numbers.size; ++i) {
-                if (this.numbers.has(i)) {
-                    continue;
-                }
-                this.errors.push({
-                    token: this.recordName,
-                    message: `Missing field number ${i}`,
-                });
-                break;
-            }
-        }
-        const declarations = Object.values(this.nameToDeclaration);
-        const fields = declarations.filter((d) => d.kind === "field");
-        const nestedRecords = declarations.filter((d) => d.kind === "record");
-        const { recordName } = this;
-        let key = `${recordName.line.modulePath}:${recordName.position}`;
-        if (this.inlineContext) {
-            key += `:${this.inlineContext.context}`;
-        }
-        const numSlots = isStruct && fields.length
-            ? Math.max(...fields.map((f) => f.number)) + 1
-            : 0;
-        const numSlotsInclRemovedNumbers = isStruct ? this.numbers.size : 0;
-        return {
-            kind: "record",
-            key: key,
-            name: this.recordName,
-            recordType: this.recordType,
-            doc: this.doc,
-            nameToDeclaration: this.nameToDeclaration,
-            declarations: Object.values(this.nameToDeclaration),
-            fields: fields,
-            nestedRecords: nestedRecords,
-            removedNumbers: this.removedNumbers.sort(),
-            recordNumber: this.stableId,
-            numSlots: numSlots,
-            numSlotsInclRemovedNumbers: numSlotsInclRemovedNumbers,
-        };
-    }
-}
-function parseRecord(it, recordType, doc, inlineContext) {
-    // A struct or an enum.
-    let nameToken;
-    if (inlineContext) {
-        const { originalName } = inlineContext;
-        let transformedName = convertCase(originalName.text, "UpperCamel");
-        if (inlineContext.context === "method-request") {
-            transformedName += "Request";
-        }
-        else if (inlineContext.context === "method-response") {
-            transformedName += "Response";
-        }
-        nameToken = {
-            ...originalName,
-            text: transformedName,
-        };
-    }
-    else {
-        // Read the name.
-        const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-        if (nameMatch.case < 0) {
-            return null;
-        }
-        Casing.validate(nameMatch.token, "UpperCamel", it.errors);
-        nameToken = nameMatch.token;
-    }
-    let stableId = null;
-    if (it.current === "(") {
-        it.next();
-        stableId = parseUint32(it, "?");
-        if (stableId === -2) {
-            return null;
-        }
-        if (it.expectThenNext([")"]).case < 0) {
-            return null;
-        }
-    }
-    if (it.expectThenNext(["{"]).case < 0) {
-        return null;
-    }
-    const declarations = parseDeclarations(it, recordType);
-    it.expectThenNext(["}"]);
-    const builder = new RecordBuilder(nameToken, recordType, doc, stableId, inlineContext, it.errors);
-    for (const declaration of declarations) {
-        builder.addDeclaration(declaration);
-        if (declaration.kind === "field" && declaration.inlineRecord) {
-            builder.addDeclaration(declaration.inlineRecord);
-        }
-    }
-    return builder.build();
-}
-function parseField(it, name, doc, recordType) {
-    // May only be undefined if the type is an enum.
-    let type;
-    let inlineRecord;
-    let number = -1;
-    const makeField = () => {
-        return {
-            kind: "field",
-            name: name,
-            number: number,
-            doc: doc,
-            unresolvedType: type,
-            // Will be populated at a later stage.
-            type: undefined,
-            // Will be populated at a later stage.
-            isRecursive: false,
-            inlineRecord: inlineRecord,
-        };
-    };
-    while (true) {
-        const typeAllowed = type === undefined && number < 0;
-        const endAllowed = type !== undefined || recordType === "enum";
-        const numberAllowed = number < 0 && endAllowed;
-        const expected = [
-            /*0:*/ typeAllowed ? ":" : null,
-            /*1:*/ numberAllowed ? "=" : null,
-            /*2:*/ endAllowed ? ";" : null,
-        ];
-        const match = it.expectThenNext(expected);
-        switch (match.case) {
-            case 0: {
-                const inlineContext = {
-                    context: "field",
-                    originalName: name,
-                };
-                const typeOrInlineRecord = parseTypeOrInlineRecord(it, inlineContext);
-                type = typeOrInlineRecord.type;
-                inlineRecord = typeOrInlineRecord.inlineRecord;
-                if (type === undefined) {
-                    return null;
-                }
-                break;
-            }
-            case 1: {
-                number = parseUint32(it);
-                if (number < 0) {
-                    return null;
-                }
-                break;
-            }
-            case 2: {
-                const expectedCasing = type ? "lower_underscore" : "UPPER_UNDERSCORE";
-                Casing.validate(name, expectedCasing, it.errors);
-                if (recordType === "enum" && name.text === "UNKNOWN") {
-                    it.errors.push({
-                        token: name,
-                        message: `Cannot name field of enum: UNKNOWN`,
-                    });
-                }
-                return makeField();
-            }
-            case -1: {
-                if (endAllowed) {
-                    return makeField();
-                }
-                else {
-                    return null;
-                }
-            }
-        }
-    }
-}
-const PRIMITIVE_TYPES = new Set([
-    "bool",
-    "int32",
-    "int64",
-    "hash64",
-    "float32",
-    "float64",
-    "timestamp",
-    "string",
-    "bytes",
-]);
-function parseTypeOrInlineRecord(it, inlineContext) {
-    if (it.current === "struct" || it.current === "enum") {
-        const recordType = it.current;
-        it.next();
-        const inlineRecord = parseRecord(it, recordType, EMPTY_DOC, inlineContext);
-        const type = inlineRecord
-            ? {
-                kind: "record",
-                nameParts: [inlineRecord.name],
-                absolute: false,
-            }
-            : undefined;
-        return {
-            type: type,
-            inlineRecord: inlineRecord ? inlineRecord : undefined,
-        };
-    }
-    else {
-        return {
-            type: parseType(it),
-            inlineRecord: undefined,
-        };
-    }
-}
-function parseType(it) {
-    const match = it.expectThenNext([
-        /*0:*/ "[",
-        /*1:*/ TOKEN_IS_IDENTIFIER,
-        /*2:*/ ".",
-    ]);
-    let value;
-    switch (match.case) {
-        case 0: {
-            // Left square bracket.
-            value = parseArrayType(it);
-            break;
-        }
-        case 1:
-            // An identifier.
-            if (PRIMITIVE_TYPES.has(match.token.text)) {
-                value = {
-                    kind: "primitive",
-                    primitive: match.token.text,
-                };
-                break;
-            }
-        // Falls through.
-        case 2: {
-            // Dot.
-            value = parseRecordRef(it, match.token);
-            break;
-        }
-        default:
-            return undefined;
-    }
-    if (value === undefined) {
-        return undefined;
-    }
-    if (it.current === "?") {
-        it.next();
-        return { kind: "optional", other: value };
-    }
-    else {
-        return value;
-    }
-}
-function parseArrayType(it) {
-    const item = parseType(it);
-    if (item === undefined) {
-        return undefined;
-    }
-    let key = undefined;
-    while (true) {
-        const keyAllowed = !key && item.kind === "record";
-        const match = it.expectThenNext([
-            /*0:*/ keyAllowed ? "|" : null,
-            /*1:*/ "]",
-        ]);
-        switch (match.case) {
-            case 0: {
-                // '|'
-                key = parseFieldPath(it, match.token);
-                if (key === null) {
-                    return undefined;
-                }
-                break;
-            }
-            case 1:
-                return { kind: "array", item: item, key: key };
-            default:
-                return undefined;
-        }
-    }
-}
-function parseFieldPath(it, pipeToken) {
-    const fieldNames = [];
-    while (true) {
-        const match = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-        if (match.case < 0) {
-            return undefined;
-        }
-        fieldNames.push(match.token);
-        if (it.current === ".") {
-            it.next();
-        }
-        else {
-            break;
-        }
-    }
-    const path = fieldNames.map((name) => ({
-        name: name,
-    }));
-    return {
-        pipeToken: pipeToken,
-        path,
-        // Just because we need to provide a value.
-        // The correct value will be populated at a later stage.
-        keyType: { kind: "primitive", primitive: "bool" },
-    };
-}
-function parseRecordRef(it, nameOrDot) {
-    const absolute = nameOrDot.text === ".";
-    const nameParts = [];
-    if (nameOrDot.text === ".") {
-        const match = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-        if (match.case < 0) {
-            return undefined;
-        }
-        nameParts.push(match.token);
-    }
-    else {
-        nameParts.push(nameOrDot);
-    }
-    while (it.current === ".") {
-        it.next();
-        const match = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-        if (match.case < 0) {
-            return undefined;
-        }
-        nameParts.push(match.token);
-    }
-    return { kind: "record", nameParts: nameParts, absolute: absolute };
-}
-function parseUint32(it, maybeQuestionMark) {
-    if (maybeQuestionMark && it.mode === "lenient" && it.current === "?") {
-        it.next();
-        return -1;
-    }
-    const match = it.expectThenNext([TOKEN_IS_POSITIVE_INT]);
-    if (match.case < 0) {
-        return -2;
-    }
-    const { text } = match.token;
-    const valueAsBigInt = BigInt(text);
-    if (valueAsBigInt < BigInt(2 ** 32)) {
-        return +text;
-    }
-    else {
-        it.errors.push({
-            token: match.token,
-            message: "Value out of uint32 range",
-        });
-        return -2;
-    }
-}
-// Parses the 'removed' declaration.
-// Assumes the current token is the token after 'removed'.
-function parseRemoved(it, removedToken) {
-    const numbers = [];
-    // The 5 states are:
-    //   ·  '?': expect a number or a semicolon
-    //   ·  ',': expect a comma or a semicolon
-    //   · '..': expect a comma, a semicolon or a '..'
-    //   ·  '0': expect a single number or the lower bound of a range
-    //   ·  '1': expect the upper bound of a range
-    let expect = "?";
-    let lowerBound;
-    loop: while (true) {
-        const endAllowed = expect === "?" || expect === "," || expect === "..";
-        const expected = [
-            /*0:*/ expect === "," || expect === ".." ? "," : null,
-            /*1:*/ expect === "?" || expect === "0" || expect === "1"
-                ? TOKEN_IS_POSITIVE_INT
-                : null,
-            /*2:*/ endAllowed ? ";" : null,
-            /*3:*/ expect === ".." ? ".." : null,
-        ];
-        const match = it.expectThenNext(expected);
-        switch (match.case) {
-            case 0: {
-                // A comma.
-                expect = "0";
-                break;
-            }
-            case 1: {
-                // A number.
-                const number = +match.token.text;
-                if (lowerBound === undefined) {
-                    expect = "..";
-                    numbers.push(number);
-                }
-                else {
-                    expect = ",";
-                    if (number <= lowerBound) {
-                        it.errors.push({
-                            token: removedToken,
-                            message: "Upper bound must be greater than lower bound",
-                        });
-                    }
-                    for (let n = lowerBound; n <= number; ++n) {
-                        numbers.push(n);
-                    }
-                    lowerBound = undefined;
-                }
-                break;
-            }
-            case 2: {
-                // A semicolon.
-                break loop;
-            }
-            case 3: {
-                // A '..'
-                expect = "1";
-                lowerBound = numbers.pop();
-                break;
-            }
-            case -1:
-                if (endAllowed) {
-                    break loop;
-                }
-                else {
-                    return null;
-                }
-        }
-    }
-    // Make sure we don't have a duplicate number.
-    const seenNumbers = new Set();
-    for (const number of numbers) {
-        if (seenNumbers.has(number)) {
-            it.errors.push({
-                token: removedToken,
-                message: `Duplicate field number ${number}`,
-            });
-            return null;
-        }
-        seenNumbers.add(number);
-    }
-    return {
-        kind: "removed",
-        removedToken: removedToken,
-        numbers: numbers,
-    };
-}
-function parseImport(it, importToken) {
-    const tokenMatch = it.expectThenNext(["*", "{", TOKEN_IS_IDENTIFIER]);
-    switch (tokenMatch.case) {
-        case 0:
-            return parseImportAs(it, importToken);
-        case 1:
-            return parseImportGivenNames(it, importToken);
-        case 2:
-            // TODO: drop this case once the curly bracket syntax becomes mandatory.
-            return parseImportGivenNames(it, importToken, tokenMatch.token);
-        default:
-            return null;
-    }
-}
-function parseImportAs(it, importToken) {
-    if (it.expectThenNext(["as"]).case < 0)
-        return null;
-    const aliasMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-    if (aliasMatch.case < 0) {
-        return null;
-    }
-    Casing.validate(aliasMatch.token, "lower_underscore", it.errors);
-    if (it.expectThenNext(["from"]).case < 0)
-        return null;
-    const modulePathMatch = it.expectThenNext([TOKEN_IS_STRING_LITERAL]);
-    if (modulePathMatch.case < 0) {
-        return null;
-    }
-    const range = {
-        start: importToken.position,
-        end: it.currentToken.position + it.current.length,
-    };
-    it.expectThenNext([";"]);
-    const modulePath = modulePathMatch.token;
-    return {
-        kind: "import-alias",
-        importToken: importToken,
-        name: aliasMatch.token,
-        range: range,
-        modulePath: modulePath,
-    };
-}
-function parseImportGivenNames(it, importToken, 
-// TODO: remove this parameter once the curly bracket syntax becomes mandatory
-firstName) {
-    const importedNames = firstName ? [firstName] : [];
-    if (firstName) {
-        // Old syntax
-        while (it.current === ",") {
-            it.next();
-            const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-            if (nameMatch.case < 0) {
-                return null;
-            }
-            importedNames.push(nameMatch.token);
-        }
-    }
-    else {
-        // New syntax with curly brackets
-        while (true) {
-            let match = it.expectThenNext([TOKEN_IS_IDENTIFIER, "}"]);
-            if (match.case === 0) {
-                importedNames.push(match.token);
-            }
-            else if (match.case === 1) {
-                break;
-            }
-            else {
-                return null;
-            }
-            match = it.expectThenNext([",", "}"]);
-            if (match.case === 1) {
-                break;
-            }
-            else if (match.case < 0) {
-                return null;
-            }
-        }
-    }
-    if (it.expectThenNext(["from"]).case < 0)
-        return null;
-    const modulePathMatch = it.expectThenNext([TOKEN_IS_STRING_LITERAL]);
-    if (modulePathMatch.case < 0) {
-        return null;
-    }
-    const range = {
-        start: importToken.position,
-        end: it.currentToken.position + it.current.length,
-    };
-    it.expectThenNext([";"]);
-    const modulePath = modulePathMatch.token;
-    return {
-        kind: "import",
-        importToken: importToken,
-        importedNames: importedNames,
-        range: range,
-        modulePath: modulePath,
-    };
-}
-function parseMethod(it, doc) {
-    const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-    if (nameMatch.case < 0) {
-        return null;
-    }
-    const name = nameMatch.token;
-    Casing.validate(name, "UpperCamel", it.errors);
-    if (it.expectThenNext(["("]).case < 0) {
-        return null;
-    }
-    const requestTypeOrInlineRecord = parseTypeOrInlineRecord(it, {
-        context: "method-request",
-        originalName: name,
-    });
-    const requestType = requestTypeOrInlineRecord.type;
-    if (!requestType) {
-        return null;
-    }
-    if (it.expectThenNext([")"]).case < 0) {
-        return null;
-    }
-    if (it.expectThenNext([":"]).case < 0) {
-        return {
-            kind: "broken-method",
-            unresolvedRequestType: requestType,
-            inlineRequestRecord: requestTypeOrInlineRecord.inlineRecord,
-            unresolvedResponseType: undefined,
-            inlineResponseRecord: undefined,
-        };
-    }
-    const responseTypeOrInlineRecord = parseTypeOrInlineRecord(it, {
-        context: "method-response",
-        originalName: name,
-    });
-    const responseType = responseTypeOrInlineRecord.type;
-    if (!responseType) {
-        return null;
-    }
-    if (it.expectThenNext(["="]).case < 0) {
-        return {
-            kind: "broken-method",
-            unresolvedRequestType: requestType,
-            inlineRequestRecord: requestTypeOrInlineRecord.inlineRecord,
-            unresolvedResponseType: responseType,
-            inlineResponseRecord: responseTypeOrInlineRecord.inlineRecord,
-        };
-    }
-    const number = parseUint32(it, "?");
-    if (number === -2) {
-        return null;
-    }
-    it.expectThenNext([";"]);
-    return {
-        kind: "method",
-        name: nameMatch.token,
-        doc: doc,
-        unresolvedRequestType: requestType,
-        unresolvedResponseType: responseType,
-        // Will be populated at a later stage.
-        requestType: undefined,
-        // Will be populated at a later stage.
-        responseType: undefined,
-        number: number,
-        inlineRequestRecord: requestTypeOrInlineRecord.inlineRecord,
-        inlineResponseRecord: responseTypeOrInlineRecord.inlineRecord,
-    };
-}
-function parseConstant(it, doc) {
-    const nameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-    if (nameMatch.case < 0) {
-        return null;
-    }
-    Casing.validate(nameMatch.token, "UPPER_UNDERSCORE", it.errors);
-    if (it.expectThenNext([":"]).case < 0) {
-        return null;
-    }
-    const type = parseType(it);
-    if (!type) {
-        return null;
-    }
-    if (it.expectThenNext(["="]).case < 0) {
-        return {
-            kind: "broken-constant",
-            unresolvedType: type,
-        };
-    }
-    const value = parseValue(it);
-    if (value === null) {
-        return null;
-    }
-    it.expectThenNext([";"]);
-    return {
-        kind: "constant",
-        name: nameMatch.token,
-        doc: doc,
-        unresolvedType: type,
-        type: undefined,
-        value: value,
-        valueAsDenseJson: undefined,
-    };
-}
-function parseValue(it) {
-    const expected = [
-        /*0:*/ "{",
-        /*1:*/ "{|",
-        /*2:*/ "[",
-        /*3:*/ "false",
-        /*4:*/ "true",
-        /*5:*/ "null",
-        /*6:*/ TOKEN_IS_NUMBER,
-        /*7:*/ TOKEN_IS_STRING_LITERAL,
-    ];
-    const match = it.expectThenNext(expected);
-    switch (match.case) {
-        case 0:
-        case 1: {
-            const partial = match.case === 1;
-            return parseObjectValue(match.token, it, partial);
-        }
-        case 2: {
-            const items = parseArrayValue(it);
-            if (items === null) {
-                return null;
-            }
-            return {
-                kind: "array",
-                token: match.token,
-                items: items,
-            };
-        }
-        case 3:
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-            return {
-                kind: "literal",
-                token: match.token,
-            };
-        default:
-            return null;
-    }
-}
-function parseObjectValue(objectToken, it, partial) {
-    const closingToken = partial ? "|}" : "}";
-    const entries = {};
-    const orphanNames = [];
-    const makeObjectValue = () => ({
-        kind: "object",
-        token: objectToken,
-        entries: entries,
-        orphanNames: orphanNames,
-        partial: partial,
-    });
-    while (true) {
-        if (it.current === closingToken) {
-            it.next();
-            return makeObjectValue();
-        }
-        const fieldNameMatch = it.expectThenNext([TOKEN_IS_IDENTIFIER]);
-        if (fieldNameMatch.case < 0) {
-            return null;
-        }
-        const fieldNameToken = fieldNameMatch.token;
-        const fieldName = fieldNameMatch.token.text;
-        if (it.expectThenNext([":"]).case < 0) {
-            orphanNames.push(fieldNameToken);
-            continue;
-        }
-        if (fieldName in entries) {
-            it.errors.push({
-                token: fieldNameMatch.token,
-                message: "Duplicate field",
-            });
-        }
-        const value = parseValue(it);
-        if (value === null) {
-            return null;
-        }
-        entries[fieldName] = {
-            name: fieldNameToken,
-            value: value,
-        };
-        const endMatch = it.expectThenNext([",", closingToken]);
-        if (endMatch.case < 0) {
-            return null;
-        }
-        if (endMatch.token.text === closingToken) {
-            return makeObjectValue();
-        }
-    }
-}
-function parseArrayValue(it) {
-    if (it.current === "]") {
-        it.next();
-        return [];
-    }
-    const items = [];
-    while (true) {
-        const item = parseValue(it);
-        if (item === null) {
-            return null;
-        }
-        items.push(item);
-        const match = it.expectThenNext([",", "]"]);
-        if (match.case < 0) {
-            return null;
-        }
-        if (match.token.text === "]") {
-            return items;
-        }
-        if (it.current === "]") {
-            it.next();
-            return items;
-        }
-    }
-}
-function collectDoc(it) {
-    const { moduleTokens } = it;
-    const docComments = [];
-    while (it.current.startsWith("///")) {
-        docComments.push(it.currentToken);
-        it.next();
-    }
-    return mergeDocs(docComments.map((c) => moduleTokens.posToDoc[c.position] ?? EMPTY_DOC));
-}
-const EMPTY_DOC = Object.freeze({
-    text: "",
-    pieces: Object.freeze([]),
-});
-class TokenPredicate {
-}
-class TokenIsIdentifier extends TokenPredicate {
-    matches(token) {
-        // "..." is the autocompletion placeholder
-        return /^\w/.test(token) || token === "...";
-    }
-    what() {
-        return "identifier";
-    }
-}
-const TOKEN_IS_IDENTIFIER = new TokenIsIdentifier();
-class TokenIsPositiveInt extends TokenPredicate {
-    matches(token) {
-        return /^[0-9]+$/.test(token);
-    }
-    what() {
-        return "positive integer";
-    }
-}
-const TOKEN_IS_POSITIVE_INT = new TokenIsPositiveInt();
-class TokenIsNumber extends TokenPredicate {
-    matches(token) {
-        return /^[0-9-]/.test(token);
-    }
-    what() {
-        return "number";
-    }
-}
-const TOKEN_IS_NUMBER = new TokenIsNumber();
-class TokenIsStringLiteral extends TokenPredicate {
-    matches(token) {
-        return /^["']/.test(token);
-    }
-    what() {
-        return "string literal";
-    }
-}
-const TOKEN_IS_STRING_LITERAL = new TokenIsStringLiteral();
-class TokenIterator {
-    constructor(moduleTokens, mode, errors) {
-        this.moduleTokens = moduleTokens;
-        this.mode = mode;
-        this.errors = errors;
-        this.tokenIndex = 0;
-        this.tokens = moduleTokens.tokens;
-    }
-    // Returns both:
-    //   · the index of the first predicate matching the current token, or -1 if
-    //       there is none
-    //   · the current token (before the move)
-    //
-    // If the current token matches any predicate, i.e. if the index is not -1,
-    // moves to the next token before returning. Otherwise, registers an error.
-    expectThenNext(expected) {
-        let token = this.tokens[this.tokenIndex];
-        while (token.text.startsWith("///")) {
-            this.errors.push({
-                token: token,
-                message: "Doc comments can only precede declarations",
-            });
-            ++this.tokenIndex;
-            token = this.tokens[this.tokenIndex];
-        }
-        for (let i = 0; i < expected.length; ++i) {
-            const e = expected[i];
-            if (e === null) {
-                continue;
-            }
-            const match = e instanceof TokenPredicate ? e.matches(token.text) : token.text === e;
-            if (!match) {
-                continue;
-            }
-            ++this.tokenIndex;
-            return {
-                case: i,
-                token: token,
-            };
-        }
-        // No match: register an error.
-        const expectedParts = [];
-        for (let i = 0; i < expected.length; ++i) {
-            const e = expected[i];
-            if (e === null) {
-                continue;
-            }
-            expectedParts.push(e instanceof TokenPredicate ? e.what() : `'${e}'`);
-        }
-        const expectedMsg = expectedParts.length === 1
-            ? expectedParts[0]
-            : `one of: ${expectedParts.join(", ")}`;
-        this.errors.push({
-            token: token,
-            expected: expectedMsg,
-        });
-        return {
-            case: -1,
-            token: token,
-        };
-    }
-    get currentToken() {
-        return this.tokens[this.tokenIndex];
-    }
-    get current() {
-        return this.currentToken.text;
-    }
-    get previous() {
-        return this.tokens[this.tokenIndex - 1].text;
-    }
-    next() {
-        ++this.tokenIndex;
-    }
-    get index() {
-        return this.tokenIndex;
-    }
-}
-function collectModuleRecords(declarations) {
-    const result = [];
-    const collect = (declarations, ancestors) => {
-        for (const record of declarations) {
-            if (record.kind !== "record")
-                continue;
-            const updatedRecordAncestors = ancestors.concat([record]);
-            const modulePath = record.name.line.modulePath;
-            const recordLocation = {
-                kind: "record-location",
-                record: record,
-                recordAncestors: updatedRecordAncestors,
-                modulePath: modulePath,
-            };
-            // We want depth-first.
-            collect(record.declarations, updatedRecordAncestors);
-            result.push(recordLocation);
-        }
-    };
-    collect(declarations, []);
-    return result;
-}
-function validateImportBlock(declarations, moduleTokens, errors) {
-    let state = "no-import-seen";
-    let startPosition;
-    let endPosition = -1;
-    let anyError = false;
-    for (const declaration of declarations) {
-        if (declaration.kind === "import" || declaration.kind === "import-alias") {
-            if (state === "no-import-seen") {
-                state = "first-legal-import-seen";
-                startPosition = declaration.range.start;
-            }
-            else if (state === "last-legal-import-seen") {
-                errors.push({
-                    token: declaration.importToken,
-                    message: "Import declarations must be grouped together at the top",
-                });
-                anyError = true;
-            }
-            endPosition = Math.max(endPosition, declaration.range.end);
-        }
-        else {
-            // Not an import
-            state = "last-legal-import-seen";
-        }
-    }
-    if (startPosition === undefined || anyError) {
-        return null;
-    }
-    const range = {
-        start: startPosition,
-        end: endPosition,
-    };
-    // Look for comments within `range`.
-    {
-        let tokens = moduleTokens.tokensWithComments;
-        tokens = tokens.slice(tokens.findIndex((t) => t.position >= range.start));
-        tokens = tokens.slice(0, tokens.findIndex((t) => t.position >= range.end));
-        for (const token of tokens) {
-            if (token.text.startsWith("//")) {
-                errors.push({
-                    token: token,
-                    message: "Comments not allowed within import block",
-                });
-                anyError = true;
-            }
-        }
-    }
-    return anyError ? null : range;
-}
-/** Extracts the "@{...}/{...}/" package prefix from a module path. */
-export function extractPackagePrefix(modulePath) {
-    const match = modulePath.match(/^(@[^/]+\/[^/]+\/)/);
-    return match?.at(1) ?? "";
-}
-function posixDirname(p) {
-    const i = p.lastIndexOf("/");
-    return i >= 0 ? p.slice(0, i) : "";
-}
-function posixNormalize(p) {
-    const parts = p.split("/");
-    const result = [];
-    for (const part of parts) {
-        if (part === "..") {
-            if (result.length > 0 && result[result.length - 1] !== "..") {
-                result.pop();
-            }
-            else {
-                result.push("..");
-            }
-        }
-        else if (part !== "." && part !== "") {
-            result.push(part);
-        }
-    }
-    return result.length === 0 ? "." : result.join("/");
-}
-function resolveModulePath(pathToken, originModulePath, errors) {
-    let modulePath = unquoteAndUnescape(pathToken.text);
-    if (/\\/.test(modulePath)) {
-        errors.push({
-            token: pathToken,
-            message: "Replace backslash with slash",
-        });
-        return undefined;
-    }
-    if (modulePath.startsWith("./") || modulePath.startsWith("../")) {
-        if (modulePath.includes("/@")) {
-            errors.push({
-                token: pathToken,
-                message: "Use absolute path",
-            });
-            return undefined;
-        }
-        // This is a relative path from the module. Let's transform it into a
-        // relative path from root.
-        modulePath = posixNormalize(posixDirname(originModulePath) + "/" + modulePath);
-    }
-    else if (originModulePath.startsWith("@") && !modulePath.startsWith("@")) {
-        const packagePrefix = extractPackagePrefix(originModulePath);
-        modulePath = packagePrefix + modulePath;
-    }
-    // "a/./b/../c" => "a/c"
-    modulePath = posixNormalize(modulePath);
-    if (modulePath.startsWith(`../`)) {
-        errors.push({
-            token: pathToken,
-            message: "Module path must point to a file within skir-src",
-        });
-        return undefined;
-    }
-    return modulePath;
-}
-//# sourceMappingURL=parser.js.map