skir 1.2.5 → 1.2.6

package/dist/module_set.js

@@ -0,0 +1,1331 @@
+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