skir 1.2.3 → 1.2.5

package/dist/module_set.js

@@ -1,1331 +0,0 @@
-import { unquoteAndUnescape, } from "skir-internal";
-import { resolveDocReferences } from "./doc_reference_resolver.js";
-import { declarationsToExpectedNames, ExpectedNamesCollector, } from "./expected_names.js";
-import { isStringLiteral, literalValueToDenseJson, literalValueToIdentity, valueHasPrimitiveType, } from "./literals.js";
-import { extractPackagePrefix, parseModule } from "./parser.js";
-import { tokenizeModule } from "./tokenizer.js";
-/**
- * Result of compiling a set of modules. Immutable.
- *
- * Support incremental compilation by accepting an optional cache of the previous
- * module set. This cache can be used to avoid re-parsing and re-resolving
- * modules that haven't changed since the last compilation.
- */
-export class ModuleSet {
-    static compile(modulePathToContent, cache, parseMode = "strict") {
-        return new ModuleSet(modulePathToContent, cache, parseMode);
-    }
-    static compileForCompletion(currentModulePath, currentPosition, modulePathToContent, cache) {
-        if (!modulePathToContent.has(currentModulePath)) {
-            throw new Error(`Not found: ${currentModulePath}`);
-        }
-        const moduleSet = new ModuleSet(modulePathToContent, cache, "lenient", {
-            modulePath: currentModulePath,
-            position: currentPosition,
-        });
-        return moduleSet.modules.get(currentModulePath);
-    }
-    constructor(modulePathToContent, cache, parseMode, completionMode) {
-        this.modulePathToContent = modulePathToContent;
-        this.parseMode = parseMode;
-        this.completionMode = completionMode;
-        this.moduleBundles = new Map();
-        this.registry = new DeclarationRegistry();
-        this.cache = cache
-            ? new Cache(modulePathToContent, cache.moduleBundles, cache.registry)
-            : undefined;
-        // In completion mode, no need to recompile modules which are not dependencies of
-        // the current module.
-        const modulePaths = completionMode
-            ? [completionMode.modulePath]
-            : modulePathToContent.keys();
-        for (const modulePath of modulePaths) {
-            this.parseAndResolve(modulePath, new Set());
-        }
-        this.finalizationResult = this.finalize();
-        // So it can be garbage collected.
-        this.cache = undefined;
-    }
-    parseAndResolve(modulePath, inProgressSet) {
-        const inMap = this.moduleBundles.get(modulePath);
-        if (inMap !== undefined) {
-            return inMap;
-        }
-        const result = this.doParseAndResolve(modulePath, inProgressSet);
-        if (result) {
-            this.moduleBundles.set(modulePath, result);
-        }
-        return result;
-    }
-    /** Called by `parseAndResolve` when the module is not in the map already. */
-    doParseAndResolve(modulePath, inProgressSet) {
-        const moduleContent = this.modulePathToContent.get(modulePath);
-        if (moduleContent === undefined) {
-            return null;
-        }
-        let moduleTokens;
-        {
-            let moduleCacheResult;
-            if (modulePath === this.completionMode?.modulePath) {
-                moduleCacheResult = { kind: "no-cache" };
-            }
-            else {
-                moduleCacheResult = this.cache?.getModuleCacheResult(modulePath) ?? {
-                    kind: "no-cache",
-                };
-            }
-            switch (moduleCacheResult.kind) {
-                case "no-cache": {
-                    moduleTokens = tokenizeModule(moduleContent, modulePath, this.completionMode);
-                    break;
-                }
-                case "module-tokens": {
-                    moduleTokens = moduleCacheResult.tokens;
-                    break;
-                }
-                case "module-bundle": {
-                    this.registry.mergeFrom(moduleCacheResult.bundle.registry);
-                    return moduleCacheResult.bundle;
-                }
-            }
-        }
-        let module;
-        const errors = [];
-        {
-            const parseResult = parseModule(moduleTokens.result, this.parseMode);
-            errors.push(...parseResult.errors);
-            module = parseResult.result;
-        }
-        const moduleBundle = new ModuleBundle(moduleTokens, {
-            result: module,
-            errors: errors,
-        });
-        // Process all imports.
-        for (const declaration of module.declarations) {
-            if (declaration.kind !== "import" &&
-                declaration.kind !== "import-alias") {
-                continue;
-            }
-            const otherModulePath = declaration.resolvedModulePath;
-            if (otherModulePath === undefined) {
-                // An error was already registered.
-                continue;
-            }
-            // Add the imported module to the module set.
-            const circularDependencyMessage = "Circular dependency between modules";
-            if (inProgressSet.has(modulePath)) {
-                errors.push({
-                    token: declaration.modulePath,
-                    message: circularDependencyMessage,
-                });
-                continue;
-            }
-            inProgressSet.add(modulePath);
-            const otherModule = this.parseAndResolve(otherModulePath, inProgressSet);
-            inProgressSet.delete(modulePath);
-            if (otherModule === null) {
-                errors.push({
-                    token: declaration.modulePath,
-                    message: "Module not found",
-                    expectedNames: suggestModulePaths(unquoteAndUnescape(declaration.modulePath.text), modulePath, this.modulePathToContent.keys()),
-                });
-            }
-            else if (otherModule.tokens.errors.length !== 0 ||
-                otherModule.module.errors.length !== 0) {
-                const hasCircularDependency = otherModule.module.errors.some((e) => e.message === circularDependencyMessage);
-                if (hasCircularDependency) {
-                    errors.push({
-                        token: declaration.modulePath,
-                        message: circularDependencyMessage,
-                    });
-                }
-                else {
-                    errors.push({
-                        token: declaration.modulePath,
-                        message: "Imported module has errors",
-                        errorIsInOtherModule: true,
-                    });
-                }
-            }
-            else if (declaration.kind === "import") {
-                // Make sure that the symbols we are importing exist in the imported
-                // module and are not imported symbols themselves.
-                for (const importedName of declaration.importedNames) {
-                    const importedDeclaration = otherModule.module.result.nameToDeclaration[importedName.text];
-                    if (importedDeclaration === undefined) {
-                        errors.push({
-                            token: importedName,
-                            message: "Not found",
-                            expectedNames: declarationsToExpectedNames(otherModule.module.result.nameToDeclaration, (d) => d.kind === "record"),
-                        });
-                    }
-                    else if (importedDeclaration.kind === "import") {
-                        errors.push({
-                            token: importedName,
-                            message: "Cannot reimport imported record",
-                        });
-                    }
-                    else if (importedDeclaration.kind !== "record") {
-                        errors.push({
-                            token: importedName,
-                            message: "Not a record",
-                        });
-                    }
-                }
-            }
-        }
-        if (errors.length && !this.completionMode) {
-            return moduleBundle;
-        }
-        // We can't merge these 3 loops into a single one, each operation must run
-        // after the last operation ran on the whole map.
-        // Loop 1: merge the module records map into the cross-module record map.
-        for (const record of module.records) {
-            const { key } = record.record;
-            this.registry.recordMap.set(key, record);
-            moduleBundle.registry.recordMap.set(key, record);
-            const { recordNumber } = record.record;
-            if (recordNumber != null && !modulePath.startsWith("@")) {
-                moduleBundle.registry.pushNumberRecord(recordNumber, key);
-            }
-        }
-        // Loop 2: resolve every field type of every record in the module.
-        // Store the result in the Field object.
-        const usedImports = new Set();
-        const typeResolver = new TypeResolver(module, this.moduleBundles, this.completionMode
-            ? this.cache?.registry.topLevelNameToRecordLocations
-            : undefined, usedImports, errors);
-        for (const record of module.records) {
-            this.storeResolvedFieldTypes(record, typeResolver);
-        }
-        // Loop 3: once all the types of record fields have been resolved.
-        const doResolveDocReferences = (documentee) => resolveDocReferences(documentee, module, (p) => this.moduleBundles.get(p)?.module.result, this.recordMap, errors);
-        for (const moduleRecord of module.records) {
-            const { record } = moduleRecord;
-            // For every field, determine if the field is recursive, i.e. the field
-            // type depends on the record where the field is defined.
-            // Store the result in the Field object.
-            this.storeFieldRecursivity(record);
-            // Verify that the `key` field of every array type is valid.
-            for (const field of record.fields) {
-                const { type } = field;
-                if (type) {
-                    this.validateArrayKeys(type, errors);
-                }
-                // Resolve the references in the doc comments of the field.
-                doResolveDocReferences({
-                    kind: "field",
-                    field: field,
-                    record: record,
-                });
-            }
-            // Resolve the references in the doc comments of the record.
-            doResolveDocReferences(record);
-        }
-        const resolveTopLevelTypeAndValidate = (type) => {
-            const resolvedType = typeResolver.resolve(type, "top-level");
-            if (resolvedType) {
-                this.validateArrayKeys(resolvedType, errors);
-            }
-            return resolvedType;
-        };
-        // Resolve every request/response type of every method in the module.
-        // Store the result in the Method object.
-        for (const method of module.methods) {
-            const { unresolvedRequestType, unresolvedResponseType } = method;
-            // Resolve request type.
-            method.requestType = resolveTopLevelTypeAndValidate(unresolvedRequestType);
-            // Resolve response type.
-            method.responseType = resolveTopLevelTypeAndValidate(unresolvedResponseType);
-            const { number } = method;
-            if (!modulePath.startsWith("@")) {
-                moduleBundle.registry.pushNumberMethod(number, method);
-            }
-            // Resolve the references in the doc comments of the method.
-            doResolveDocReferences(method);
-        }
-        for (const method of module.brokenMethods) {
-            const { unresolvedRequestType, unresolvedResponseType } = method;
-            resolveTopLevelTypeAndValidate(unresolvedRequestType);
-            if (unresolvedResponseType) {
-                resolveTopLevelTypeAndValidate(unresolvedResponseType);
-            }
-        }
-        // Resolve every constant type. Store the result in the constant object.
-        for (const constant of module.constants) {
-            const { unresolvedType } = constant;
-            const type = resolveTopLevelTypeAndValidate(unresolvedType);
-            constant.type = type;
-            if (type) {
-                constant.valueAsDenseJson = //
-                    this.valueToDenseJson(constant.value, type, errors);
-            }
-            // Resolve the references in the doc comments of the constant.
-            doResolveDocReferences(constant);
-        }
-        for (const constant of module.brokenConstants) {
-            const { unresolvedType } = constant;
-            resolveTopLevelTypeAndValidate(unresolvedType);
-        }
-        moduleBundle.registry.pushTopLevelNames(module.declarations
-            .filter((d) => d.kind === "record")
-            .map((d) => ({
-            name: d.name.text,
-            doc: d.doc,
-            modulePath: modulePath,
-        })));
-        ensureAllImportsAreUsed(module, usedImports, errors);
-        this.registry.mergeFrom(moduleBundle.registry);
-        return moduleBundle;
-    }
-    storeResolvedFieldTypes(record, typeResolver) {
-        for (const field of record.record.fields) {
-            if (field.unresolvedType === undefined) {
-                // A constant enum field.
-                continue;
-            }
-            field.type = typeResolver.resolve(field.unresolvedType, record);
-        }
-    }
-    storeFieldRecursivity(record) {
-        for (const field of record.fields) {
-            if (!field.type)
-                continue;
-            const modes = record.recordType === "struct"
-                ? ["hard", "via-optional", "soft"]
-                : ["soft"];
-            for (const mode of modes) {
-                const deps = new Set();
-                this.collectTypeDeps(field.type, mode, deps);
-                if (deps.has(record.key)) {
-                    field.isRecursive = mode;
-                    break;
-                }
-            }
-        }
-    }
-    collectTypeDeps(input, mode, out) {
-        switch (input.kind) {
-            case "record": {
-                if (mode === "via-optional")
-                    return;
-                const { key } = input;
-                if (out.has(key))
-                    return;
-                out.add(key);
-                // Recursively add deps of all fields of the record.
-                const record = this.recordMap.get(key)?.record;
-                if (!record) {
-                    console.error("collectTypeDeps: record not found", key);
-                    return;
-                }
-                if (mode === "hard" && record.recordType === "enum") {
-                    return;
-                }
-                for (const field of record.fields) {
-                    if (field.type === undefined)
-                        continue;
-                    this.collectTypeDeps(field.type, mode, out);
-                }
-                break;
-            }
-            case "array": {
-                if (mode === "soft") {
-                    this.collectTypeDeps(input.item, mode, out);
-                }
-                break;
-            }
-            case "optional": {
-                switch (mode) {
-                    case "soft": {
-                        this.collectTypeDeps(input.other, mode, out);
-                        break;
-                    }
-                    case "via-optional": {
-                        // Important: must pass "hard" here.
-                        this.collectTypeDeps(input.other, "hard", out);
-                        break;
-                    }
-                    default: {
-                        const _ = mode;
-                    }
-                }
-                break;
-            }
-        }
-    }
-    /**
-     * Verifies that the `key` field of every array type found in `topLevelType`
-     * is valid. Populates the `keyType` field of every field path.
-     */
-    validateArrayKeys(topLevelType, errors) {
-        const validate = (type) => {
-            const { key, item } = type;
-            if (!key) {
-                return;
-            }
-            const { path } = key;
-            // Iterate the fields in the sequence.
-            let currentType = item;
-            let enumRef;
-            for (let i = 0; i < path.length; ++i) {
-                const pathItem = path[i];
-                const fieldName = pathItem.name;
-                if (currentType.kind !== "record") {
-                    if (i === 0) {
-                        errors.push({
-                            token: key.pipeToken,
-                            message: "Item must have struct type",
-                        });
-                    }
-                    else {
-                        const previousFieldName = path[i - 1].name;
-                        errors.push({
-                            token: previousFieldName,
-                            message: "Must have struct type",
-                        });
-                    }
-                    return;
-                }
-                const record = this.recordMap.get(currentType.key)?.record;
-                if (!record) {
-                    console.error("validateArrayKeys: record not found", currentType.key);
-                    return;
-                }
-                if (record.recordType === "struct") {
-                    const field = record.nameToDeclaration[fieldName.text];
-                    if (field?.kind !== "field") {
-                        errors.push({
-                            token: fieldName,
-                            message: `Field not found in struct ${record.name.text}`,
-                            expectedNames: declarationsToExpectedNames(record.nameToDeclaration, (d) => d.kind === "field"),
-                        });
-                        return undefined;
-                    }
-                    pathItem.declaration = field;
-                    if (!field.type) {
-                        // An error was already registered.
-                        return;
-                    }
-                    currentType = field.type;
-                }
-                else {
-                    // An enum.
-                    if (fieldName.text !== "kind") {
-                        errors.push({
-                            token: fieldName,
-                            expected: "'kind'",
-                            expectedNames: [{ name: "kind" }],
-                        });
-                        return undefined;
-                    }
-                    enumRef = currentType;
-                    currentType = {
-                        kind: "primitive",
-                        primitive: "string",
-                    };
-                }
-            }
-            if (currentType.kind !== "primitive") {
-                errors.push({
-                    token: path.at(-1).name,
-                    message: "Does not have primitive type",
-                });
-                return;
-            }
-            // If the last field name of the `kind` field of an enum, we store a
-            // reference to the enum in the `keyType` field of the array type.
-            key.keyType = enumRef || currentType;
-        };
-        const traverseType = (type) => {
-            switch (type.kind) {
-                case "array":
-                    validate(type);
-                    return traverseType(type.item);
-                case "optional":
-                    return traverseType(type.other);
-            }
-        };
-        traverseType(topLevelType);
-    }
-    valueToDenseJson(value, expectedType, errors) {
-        switch (expectedType.kind) {
-            case "optional": {
-                if (value.kind === "literal" && value.token.text === "null") {
-                    value.type = { kind: "null" };
-                    return null;
-                }
-                return this.valueToDenseJson(value, expectedType.other, errors);
-            }
-            case "array": {
-                if (value.kind !== "array") {
-                    errors.push({
-                        token: value.token,
-                        expected: "array",
-                    });
-                    return undefined;
-                }
-                const json = [];
-                let allGood = true;
-                for (const item of value.items) {
-                    const itemJson = //
-                     this.valueToDenseJson(item, expectedType.item, errors);
-                    if (itemJson !== undefined) {
-                        json.push(itemJson);
-                    }
-                    else {
-                        // Even if we could return now, better to verify the type of the
-                        // other items.
-                        allGood = false;
-                    }
-                }
-                if (!allGood) {
-                    return undefined;
-                }
-                const { key } = expectedType;
-                value.key = key;
-                if (key) {
-                    validateKeyedItems(value.items, key, errors);
-                }
-                return json;
-            }
-            case "record": {
-                const record = this.recordMap.get(expectedType.key);
-                if (!record) {
-                    // An error was already registered.
-                    return undefined;
-                }
-                return record.record.recordType === "struct"
-                    ? this.structValueToDenseJson(value, record.record, errors)
-                    : this.enumValueToDenseJson(value, record.record, errors);
-            }
-            case "primitive": {
-                const { token } = value;
-                const { primitive } = expectedType;
-                if (value.kind !== "literal" ||
-                    !valueHasPrimitiveType(token.text, primitive)) {
-                    errors.push({
-                        token: value.token,
-                        expected: primitive,
-                    });
-                    return undefined;
-                }
-                value.type = expectedType;
-                return literalValueToDenseJson(token.text, expectedType.primitive);
-            }
-        }
-    }
-    structValueToDenseJson(value, expectedStruct, errors) {
-        const { token } = value;
-        if (value.kind !== "object") {
-            errors.push({
-                token: token,
-                expected: "object",
-            });
-            return undefined;
-        }
-        const json = Array(expectedStruct.numSlotsInclRemovedNumbers).fill(0);
-        let allGood = true;
-        const fieldNameTokens = Object.values(value.entries)
-            .map((e) => e.name)
-            .concat(value.orphanNames);
-        const fieldNames = new Set(fieldNameTokens.map((t) => t.text));
-        for (const fieldName of fieldNameTokens) {
-            const field = expectedStruct.nameToDeclaration[fieldName.text];
-            if (field?.kind !== "field") {
-                errors.push({
-                    token: fieldName,
-                    message: `Field not found in struct ${expectedStruct.name.text}`,
-                    expectedNames: declarationsToExpectedNames(expectedStruct.nameToDeclaration, (d) => d.kind === "field" && !fieldNames.has(d.name.text)),
-                });
-                allGood = false;
-                continue;
-            }
-        }
-        let arrayLen = 0;
-        for (const field of expectedStruct.fields) {
-            const { type } = field;
-            if (!type) {
-                allGood = false;
-                continue;
-            }
-            const fieldEntry = value.entries[field.name.text];
-            let valueJson;
-            if (fieldEntry) {
-                fieldEntry.fieldDeclaration = field;
-                valueJson = this.valueToDenseJson(fieldEntry.value, type, errors);
-            }
-            else {
-                // Unless the object is declared partial, all fields are required.
-                if (value.partial) {
-                    valueJson = this.getDefaultJson(type);
-                }
-                else {
-                    errors.push({
-                        token: token,
-                        message: `Missing entry: ${field.name.text}`,
-                    });
-                }
-            }
-            if (valueJson === undefined) {
-                allGood = false;
-                continue;
-            }
-            json[field.number] = valueJson;
-            const hasDefaultValue = type.kind === "optional"
-                ? valueJson === null
-                : !valueJson ||
-                    (Array.isArray(valueJson) && !valueJson.length) ||
-                    (type.kind === "primitive" &&
-                        (type.primitive === "int64" || type.primitive === "hash64") &&
-                        valueJson === "0");
-            if (!hasDefaultValue) {
-                arrayLen = Math.max(arrayLen, field.number + 1);
-            }
-        }
-        if (!allGood) {
-            return undefined;
-        }
-        value.record = expectedStruct;
-        return json.slice(0, arrayLen);
-    }
-    enumValueToDenseJson(value, expectedEnum, errors) {
-        const { token } = value;
-        if (value.kind === "literal" && isStringLiteral(token.text)) {
-            // The value is a string.
-            // It must match the name of one of the constants defined in the enum.
-            const fieldName = unquoteAndUnescape(token.text);
-            if (fieldName === "UNKNOWN") {
-                // Present on every enum.
-                return 0;
-            }
-            const field = expectedEnum.nameToDeclaration[fieldName];
-            if (field?.kind !== "field") {
-                errors.push({
-                    token: token,
-                    message: `Variant not found in enum ${expectedEnum.name.text}`,
-                    expectedNames: [{ name: "UNKNOWN" }].concat(declarationsToExpectedNames(expectedEnum.nameToDeclaration, (d) => d.kind === "field" && !d.type)),
-                });
-                return undefined;
-            }
-            if (field.type) {
-                errors.push({
-                    token: token,
-                    message: "Refers to a wrapper variant",
-                });
-                return undefined;
-            }
-            value.type = {
-                kind: "enum",
-                enum: expectedEnum,
-                variant: field,
-            };
-            return field.number;
-        }
-        else if (value.kind === "object") {
-            // The value is an object. It must have exactly two entries:
-            //   · 'kind' must match the name of one of the wrapper variants defined in
-            //     the enum
-            //   · 'value' must match the type of the wrapper variant
-            const { entries } = value;
-            const kindEntry = entries.kind;
-            const enumValue = entries.value;
-            const nameTokens = Object.values(entries)
-                .map((e) => e.name)
-                .concat(value.orphanNames);
-            for (const nameToken of nameTokens) {
-                if (nameToken.text === "kind" || nameToken.text === "value") {
-                    continue;
-                }
-                const expectedNames = (kindEntry ? [] : [{ name: "kind" }]).concat(enumValue ? [] : [{ name: "value" }]);
-                errors.push({
-                    token: nameToken,
-                    message: "Extraneous entry",
-                    expectedNames: expectedNames,
-                });
-                return undefined;
-            }
-            if (!kindEntry) {
-                errors.push({
-                    token: token,
-                    message: "Missing entry: kind",
-                });
-                return undefined;
-            }
-            const kindValueToken = kindEntry.value.token;
-            if (kindEntry.value.kind !== "literal" ||
-                !isStringLiteral(kindValueToken.text)) {
-                errors.push({
-                    token: kindValueToken,
-                    expected: "string",
-                });
-                return undefined;
-            }
-            const variantName = unquoteAndUnescape(kindValueToken.text);
-            const variant = expectedEnum.nameToDeclaration[variantName];
-            if (variant?.kind !== "field") {
-                errors.push({
-                    token: kindValueToken,
-                    message: `Variant not found in enum ${expectedEnum.name.text}`,
-                    expectedNames: declarationsToExpectedNames(expectedEnum.nameToDeclaration, (d) => d.kind === "field" && !!d.type),
-                });
-                return undefined;
-            }
-            if (!variant.type) {
-                errors.push({
-                    token: kindValueToken,
-                    message: "Refers to a constant variant",
-                });
-                return undefined;
-            }
-            if (!enumValue) {
-                errors.push({
-                    token: token,
-                    message: "Missing entry: value",
-                });
-                return undefined;
-            }
-            const valueJson = //
-             this.valueToDenseJson(enumValue.value, variant.type, errors);
-            if (valueJson === undefined) {
-                return undefined;
-            }
-            value.record = expectedEnum;
-            // Return an array of length 2.
-            return [variant.number, valueJson];
-        }
-        else {
-            // The value is neither a string nor an object. It can't be of enum type.
-            errors.push({
-                token: token,
-                expected: "string or object",
-            });
-            return undefined;
-        }
-    }
-    getDefaultJson(type) {
-        switch (type.kind) {
-            case "primitive": {
-                switch (type.primitive) {
-                    case "bool":
-                    case "int32":
-                    case "int64":
-                    case "hash64":
-                    case "float32":
-                    case "float64":
-                    case "timestamp":
-                        return 0;
-                    case "string":
-                    case "bytes":
-                        return "";
-                    default: {
-                        const _ = type.primitive;
-                        throw new TypeError(_);
-                    }
-                }
-            }
-            case "array":
-                return [];
-            case "optional":
-                return null;
-            case "record": {
-                const record = this.recordMap.get(type.key);
-                switch (record.record.recordType) {
-                    case "struct":
-                        return [];
-                    case "enum":
-                        return 0;
-                }
-            }
-        }
-    }
-    finalize() {
-        const modules = new Map();
-        for (const [modulePath, moduleBundle] of this.moduleBundles) {
-            const { module, tokens } = moduleBundle;
-            const moduleErrors = tokens.errors.length ? tokens.errors : module.errors;
-            modules.set(modulePath, {
-                result: module.result,
-                errors: [...moduleErrors],
-            });
-        }
-        // Look for duplicate method numbers.
-        for (const methods of this.registry.numberToMethods.values()) {
-            if (methods.length <= 1) {
-                continue;
-            }
-            const pushError = (method, other) => {
-                const modulePath = method.name.line.modulePath;
-                const moduleResult = modules.get(modulePath);
-                const otherMethodName = other.name.text;
-                const otherModulePath = other.name.line.modulePath;
-                moduleResult.errors.push({
-                    token: method.name,
-                    message: `Same number as ${otherMethodName} in ${otherModulePath}`,
-                });
-            };
-            pushError(methods[0], methods[1]);
-            for (let i = 1; i < methods.length; ++i) {
-                pushError(methods[i], methods[0]);
-            }
-        }
-        // Look for duplicate record numbers.
-        for (const records of this.registry.numberToRecords.values()) {
-            if (records.length <= 1) {
-                continue;
-            }
-            const pushError = (recordKey, otherKey) => {
-                const record = this.registry.recordMap.get(recordKey);
-                const other = this.registry.recordMap.get(otherKey);
-                const modulePath = record.record.name.line.modulePath;
-                const moduleResult = modules.get(modulePath);
-                const otherRecordName = other.record.name.text;
-                const otherModulePath = other.modulePath;
-                moduleResult.errors.push({
-                    token: record.record.name,
-                    message: `Same number as ${otherRecordName} in ${otherModulePath}`,
-                });
-            };
-            pushError(records[0], records[1]);
-            for (let i = 1; i < records.length; ++i) {
-                pushError(records[i], records[0]);
-            }
-        }
-        // Aggregate errors across all modules.
-        const errors = [];
-        for (const moduleBundle of modules.values()) {
-            errors.push(...moduleBundle.errors);
-        }
-        return {
-            modules: modules,
-            errors: errors,
-        };
-    }
-    // END PROPERTIES
-    findRecordByNumber(recordNumber) {
-        const { numberToRecords, recordMap } = this.registry;
-        const recordKeys = numberToRecords.get(recordNumber);
-        return recordKeys?.length === 1 ? recordMap.get(recordKeys[0]) : undefined;
-    }
-    findMethodByNumber(methodNumber) {
-        const { numberToMethods } = this.registry;
-        const methods = numberToMethods.get(methodNumber);
-        return methods?.length === 1 ? methods[0] : undefined;
-    }
-    get recordMap() {
-        return this.registry.recordMap;
-    }
-    get errors() {
-        return this.finalizationResult.errors;
-    }
-    get modules() {
-        return this.finalizationResult.modules;
-    }
-}
-/**
- * If the array type is keyed, the array value must satisfy two conditions.
- * First: the key field of every item must be set.
- * Second: not two items can have the same key.
- */
-function validateKeyedItems(items, fieldPath, errors) {
-    const { keyType, path } = fieldPath;
-    const tryExtractKeyFromItem = (item) => {
-        let value = item;
-        for (const pathItem of path) {
-            const fieldName = pathItem.name;
-            if (value.kind === "literal" && fieldName.text === "kind") {
-                // An enum constant.
-                return value;
-            }
-            if (value.kind !== "object") {
-                // An error was already registered.
-                return undefined;
-            }
-            const entry = value.entries[fieldName.text];
-            if (!entry) {
-                errors.push({
-                    token: value.token,
-                    message: `Missing entry: ${fieldName.text}`,
-                });
-                return;
-            }
-            value = entry.value;
-        }
-        return value;
-    };
-    const keyIdentityToKeys = new Map();
-    for (const item of items) {
-        const key = tryExtractKeyFromItem(item);
-        if (!key) {
-            return;
-        }
-        if (key.kind !== "literal") {
-            // Cannot happen.
-            return;
-        }
-        let keyIdentity;
-        const keyToken = key.token.text;
-        if (keyType.kind === "primitive") {
-            const { primitive } = keyType;
-            if (!valueHasPrimitiveType(keyToken, primitive)) {
-                continue;
-            }
-            keyIdentity = literalValueToIdentity(keyToken, primitive);
-        }
-        else {
-            // The key is an enum, use the enum field name as the key identity.
-            if (!isStringLiteral(keyToken)) {
-                continue;
-            }
-            keyIdentity = unquoteAndUnescape(keyToken);
-        }
-        if (keyIdentityToKeys.has(keyIdentity)) {
-            keyIdentityToKeys.get(keyIdentity).push(key);
-        }
-        else {
-            keyIdentityToKeys.set(keyIdentity, [key]);
-        }
-    }
-    // Verify that every key in `keyIdentityToItems` has a single value.
-    for (const duplicateKeys of keyIdentityToKeys.values()) {
-        if (duplicateKeys.length <= 1) {
-            continue;
-        }
-        for (const key of duplicateKeys) {
-            errors.push({
-                token: key.token,
-                message: "Duplicate key",
-            });
-        }
-    }
-}
-class TypeResolver {
-    constructor(module, moduleBundles, 
-    /** For automatic imports in completion mode. */
-    topLevelNameToRecordLocations, usedImports, errors) {
-        this.module = module;
-        this.moduleBundles = moduleBundles;
-        this.topLevelNameToRecordLocations = topLevelNameToRecordLocations;
-        this.usedImports = usedImports;
-        this.errors = errors;
-    }
-    resolve(input, recordOrigin) {
-        switch (input.kind) {
-            case "primitive":
-                return input;
-            case "array": {
-                const item = this.resolve(input.item, recordOrigin);
-                if (!item) {
-                    return undefined;
-                }
-                return { kind: "array", item: item, key: input.key };
-            }
-            case "optional": {
-                const value = this.resolve(input.other, recordOrigin);
-                if (!value) {
-                    return undefined;
-                }
-                return { kind: "optional", other: value };
-            }
-            case "record": {
-                return this.resolveRecordRef(input, recordOrigin);
-            }
-        }
-    }
-    /**
-     * Finds the definition of the actual record referenced from a value type.
-     * This is where we implement the name resolution algorithm.
-     */
-    resolveRecordRef(recordRef, recordOrigin) {
-        const firstNamePart = recordRef.nameParts[0];
-        const makeNotARecordError = (name) => ({
-            token: name,
-            message: "Does not refer to a struct or an enum",
-        });
-        const makeCannotFindNameError = (name, expectedNames) => ({
-            token: name,
-            message: `Cannot find name '${name.text}'`,
-            expectedNames: expectedNames,
-        });
-        const { errors, module, moduleBundles, usedImports } = this;
-        // The most nested record/module which contains the first name in the record
-        // reference, or the module if the record reference is absolute (starts with
-        // a dot).
-        let start;
-        const expectedNamesCollector = new ExpectedNamesCollector();
-        if (recordOrigin !== "top-level" && !recordRef.absolute) {
-            // Traverse the chain of ancestors from most nested to top-level.
-            for (const fromRecord of [...recordOrigin.recordAncestors].reverse()) {
-                const matchMaybe = fromRecord.nameToDeclaration[firstNamePart.text];
-                if (matchMaybe && matchMaybe.kind === "record") {
-                    start = fromRecord;
-                    break;
-                }
-                else {
-                    expectedNamesCollector.collect(declarationsToExpectedNames(fromRecord.nameToDeclaration, (d) => d.kind === "record"));
-                }
-            }
-        }
-        if (start === undefined) {
-            const maybeMatch = module.nameToDeclaration[firstNamePart.text];
-            if (!maybeMatch) {
-                expectedNamesCollector.collect(declarationsToExpectedNames(module.nameToDeclaration, (d) => d.kind === "record" ||
-                    d.kind === "import" ||
-                    d.kind === "import-alias"));
-                // For automatic imports.
-                expectedNamesCollector.collect(this.topLevelNameToRecordLocations
-                    ?.get(firstNamePart.text)
-                    ?.filter((l) => l.modulePath !== module.path) ?? []);
-                errors.push(makeCannotFindNameError(firstNamePart, expectedNamesCollector.expectedNames));
-                return undefined;
-            }
-            start = module;
-        }
-        let it = start;
-        const nameParts = [];
-        for (let i = 0; i < recordRef.nameParts.length; ++i) {
-            const namePart = recordRef.nameParts[i];
-            const name = namePart.text;
-            let newIt = it.nameToDeclaration[name];
-            if (newIt === undefined) {
-                errors.push(makeCannotFindNameError(namePart, declarationsToExpectedNames(it.nameToDeclaration, (d) => d.kind === "record" ||
-                    (i === 0 && d.kind === "import-alias") ||
-                    (i === 0 && d.kind === "import"))));
-                return undefined;
-            }
-            else if (newIt.kind === "record") {
-                it = newIt;
-            }
-            else if (newIt.kind === "import" || newIt.kind === "import-alias") {
-                const transitiveImportError = () => ({
-                    token: namePart,
-                    message: "Cannot refer to imports of imported module",
-                });
-                if (i !== 0) {
-                    errors.push(transitiveImportError());
-                    return undefined;
-                }
-                usedImports.add(name);
-                const newModulePath = newIt.resolvedModulePath;
-                if (newModulePath === undefined) {
-                    return undefined;
-                }
-                const newModuleResult = moduleBundles.get(newModulePath);
-                if (!newModuleResult) {
-                    // The module was not found or has errors: an error was already
-                    // registered, no need to register a new one.
-                    return undefined;
-                }
-                const newModule = newModuleResult.module.result;
-                if (newIt.kind === "import") {
-                    newIt = newModule.nameToDeclaration[name];
-                    if (!newIt) {
-                        errors.push(makeCannotFindNameError(namePart, declarationsToExpectedNames(newModule.nameToDeclaration, (d) => d.kind === "record")));
-                        return undefined;
-                    }
-                    if (newIt.kind !== "record") {
-                        this.errors.push(newIt.kind === "import" || newIt.kind === "import-alias"
-                            ? transitiveImportError()
-                            : makeNotARecordError(namePart));
-                        return undefined;
-                    }
-                    it = newIt;
-                }
-                else {
-                    it = newModule;
-                }
-            }
-            else {
-                this.errors.push(makeNotARecordError(namePart));
-                return undefined;
-            }
-            nameParts.push({ token: namePart, declaration: newIt });
-        }
-        if (it.kind !== "record") {
-            const name = recordRef.nameParts[0];
-            this.errors.push(makeNotARecordError(name));
-            return undefined;
-        }
-        return {
-            kind: "record",
-            key: it.key,
-            recordType: it.recordType,
-            nameParts: nameParts,
-            refToken: recordRef.nameParts.at(-1),
-        };
-    }
-}
-class Cache {
-    constructor(modulePathToNewContent, modulePathToOldBundle, registry) {
-        this.registry = registry;
-        this.modulePathToCacheResult = new Map();
-        const unchangedModulePaths = new Set();
-        for (const [modulePath, newContent] of modulePathToNewContent) {
-            const oldBundle = modulePathToOldBundle.get(modulePath);
-            if (oldBundle?.tokens.result.sourceCode === newContent) {
-                unchangedModulePaths.add(modulePath);
-            }
-        }
-        const classify = (modulePath) => {
-            const oldBundle = modulePathToOldBundle.get(modulePath);
-            if (!oldBundle) {
-                return { kind: "no-cache" };
-            }
-            {
-                const inMap = this.modulePathToCacheResult.get(modulePath);
-                if (inMap) {
-                    return inMap;
-                }
-            }
-            let result;
-            const newContent = modulePathToNewContent.get(modulePath);
-            if (newContent === oldBundle.tokens.result.sourceCode) {
-                // Assume best case, may downgrade later.
-                this.modulePathToCacheResult.set(modulePath, {
-                    kind: "module-bundle",
-                    bundle: oldBundle,
-                });
-                const directDependencies = Object.keys(oldBundle.module.result?.pathToImportedNames);
-                result = directDependencies.every((dep) => classify(dep).kind === "module-bundle")
-                    ? { kind: "module-bundle", bundle: oldBundle }
-                    : { kind: "module-tokens", tokens: oldBundle.tokens };
-            }
-            else {
-                result = { kind: "no-cache" };
-            }
-            this.modulePathToCacheResult.set(modulePath, result);
-            return result;
-        };
-        for (const modulePath of modulePathToOldBundle.keys()) {
-            classify(modulePath);
-        }
-    }
-    getModuleCacheResult(modulePath) {
-        return this.modulePathToCacheResult.get(modulePath) ?? { kind: "no-cache" };
-    }
-}
-/** Registry of declarations possibly across multiple modules. */
-class DeclarationRegistry {
-    constructor() {
-        this.recordMap = new Map();
-        this.numberToRecords = new Map();
-        this.numberToMethods = new Map();
-        /**
-         * Key: name of a record defined at the top level of a module
-         * Value: array of record locations (record name, doc, module path)
-         */
-        this.topLevelNameToRecordLocations = new Map();
-    }
-    mergeFrom(other) {
-        for (const [key, value] of other.recordMap) {
-            this.recordMap.set(key, value);
-        }
-        for (const [number, value] of other.numberToRecords) {
-            let existing = this.numberToRecords.get(number);
-            if (!existing) {
-                existing = [];
-                this.numberToRecords.set(number, existing);
-            }
-            existing.push(...value);
-        }
-        for (const [number, value] of other.numberToMethods) {
-            let existing = this.numberToMethods.get(number);
-            if (!existing) {
-                existing = [];
-                this.numberToMethods.set(number, existing);
-            }
-            existing.push(...value);
-        }
-        for (const [topLevelName, recordLocations,] of other.topLevelNameToRecordLocations) {
-            let existing = this.topLevelNameToRecordLocations.get(topLevelName);
-            if (!existing) {
-                existing = [];
-                this.topLevelNameToRecordLocations.set(topLevelName, existing);
-            }
-            existing.push(...recordLocations);
-        }
-    }
-    pushNumberRecord(number, record) {
-        let value = this.numberToRecords.get(number);
-        if (!value) {
-            value = [];
-            this.numberToRecords.set(number, value);
-        }
-        value.push(record);
-    }
-    pushNumberMethod(number, method) {
-        let value = this.numberToMethods.get(number);
-        if (!value) {
-            value = [];
-            this.numberToMethods.set(number, value);
-        }
-        value.push(method);
-    }
-    pushTopLevelNames(recordLocations) {
-        for (const recordName of recordLocations) {
-            let value = this.topLevelNameToRecordLocations.get(recordName.name);
-            if (!value) {
-                value = [];
-                this.topLevelNameToRecordLocations.set(recordName.name, value);
-            }
-            value.push(recordName);
-        }
-    }
-}
-class ModuleBundle {
-    constructor(tokens, module) {
-        this.tokens = tokens;
-        this.module = module;
-        /**
-         * Registry of declarations found in this module only.
-         * Will be merged into the "global" registry.
-         */
-        this.registry = new DeclarationRegistry();
-    }
-}
-function ensureAllImportsAreUsed(module, usedImports, errors) {
-    for (const declaration of module.declarations) {
-        if (declaration.kind === "import") {
-            for (const importedName of declaration.importedNames) {
-                if (!usedImports.has(importedName.text)) {
-                    errors.push({
-                        token: importedName,
-                        message: "Unused import",
-                    });
-                }
-            }
-        }
-        else if (declaration.kind === "import-alias") {
-            if (!usedImports.has(declaration.name.text)) {
-                errors.push({
-                    token: declaration.name,
-                    message: "Unused import alias",
-                });
-            }
-        }
-    }
-}
-function posixDirname(p) {
-    const i = p.lastIndexOf("/");
-    return i >= 0 ? p.slice(0, i) : "";
-}
-function posixJoin(base, rel) {
-    const parts = (base + "/" + rel).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.join("/");
-}
-function posixRelative(from, to) {
-    const fromParts = from === "" ? [] : from.split("/");
-    const toParts = to === "" ? [] : to.split("/");
-    let commonLen = 0;
-    while (commonLen < fromParts.length &&
-        commonLen < toParts.length &&
-        fromParts[commonLen] === toParts[commonLen]) {
-        commonLen++;
-    }
-    const upCount = fromParts.length - commonLen;
-    const downParts = toParts.slice(commonLen);
-    return [...Array(upCount).fill(".."), ...downParts].join("/");
-}
-/**
- * Returns suggested module paths for import auto-completion.
- *
- * Given the partial path the user has typed, returns suggestions from
- * `modulePathToContent`. For paths where there is more after the matched
- * segment, the suggestion is truncated at the next "/" and a trailing "/" is
- * appended to signal that it is a directory, not a file.
- *
- * Handles both absolute paths (e.g. "bb/ee") and relative paths (e.g.
- * "./other", "../sibling").
- */
-function suggestModulePaths(typedPath, originModulePath, modulePathToContent) {
-    const isRelative = typedPath.startsWith("./") || typedPath.startsWith("../");
-    // Compute the absolute path prefix to match against all module paths.
-    let absolutePrefix;
-    if (isRelative) {
-        // Split at the last "/" so that the directory component (fully typed) can
-        // be resolved cleanly, while the tail (partial filename/dir prefix) is
-        // appended afterwards.
-        const lastSlash = typedPath.lastIndexOf("/");
-        const dirComponent = typedPath.slice(0, lastSlash + 1);
-        const filePrefix = typedPath.slice(lastSlash + 1);
-        // Append a dummy filename so Paths.join/normalize treat the directory
-        // component as a file path (avoids trailing-slash edge-cases), then strip
-        // it off again.
-        const dummy = dirComponent + "__dummy__";
-        const resolvedDummy = posixJoin(posixDirname(originModulePath), dummy.startsWith("./") ? dummy.slice(2) : dummy);
-        const absoluteDir = resolvedDummy.slice(0, resolvedDummy.length - "__dummy__".length);
-        absolutePrefix = absoluteDir + filePrefix;
-    }
-    else if (originModulePath.startsWith("@") && !typedPath.startsWith("@")) {
-        absolutePrefix = extractPackagePrefix(originModulePath) + typedPath;
-    }
-    else {
-        absolutePrefix = typedPath;
-    }
-    absolutePrefix = absolutePrefix.replace(/\\/g, "/");
-    if (absolutePrefix.startsWith("../")) {
-        // Typed path escapes the root; no valid suggestions.
-        return [];
-    }
-    const originBaseDir = posixDirname(originModulePath);
-    const suggestions = new Set();
-    for (const path of modulePathToContent) {
-        if (!path.startsWith(absolutePrefix))
-            continue;
-        if (path === originModulePath)
-            continue;
-        // When the user typed a relative path, never suggest modules that live
-        // under a package root ("@...") — those must be imported with an absolute
-        // path.
-        if (isRelative && path.startsWith("@"))
-            continue;
-        const remaining = path.slice(absolutePrefix.length);
-        const slashIndex = remaining.indexOf("/");
-        // If there is a sub-path after the matched prefix, collapse to the next
-        // directory segment and append "/". Otherwise use the full path.
-        const absoluteSuggestion = slashIndex >= 0
-            ? absolutePrefix + remaining.slice(0, slashIndex + 1)
-            : path;
-        if (isRelative) {
-            const isDir = absoluteSuggestion.endsWith("/");
-            const absPath = isDir
-                ? absoluteSuggestion.slice(0, -1)
-                : absoluteSuggestion;
-            let rel = posixRelative(originBaseDir, absPath);
-            // Paths.relative returns "" when both paths are the same; normalise to
-            // "." so the subsequent prefix-check and directory-slash logic work
-            // correctly (avoids producing the invalid path ".//" for same-dir cases).
-            if (rel === "") {
-                rel = ".";
-            }
-            if (!rel.startsWith(".")) {
-                rel = "./" + rel;
-            }
-            const suggestion = isDir ? rel + "/" : rel;
-            // When the user typed "../", don't suggest "./" — they would have typed
-            // "./" directly if they wanted files in their own directory.
-            if (typedPath.startsWith("../") && suggestion === "./")
-                continue;
-            suggestions.add(suggestion);
-        }
-        else {
-            suggestions.add(absoluteSuggestion);
-        }
-    }
-    return [...suggestions].map((name) => ({ name }));
-}
-//# sourceMappingURL=module_set.js.map