skir-internal 0.0.1

package/dist/module_set.js

@@ -0,0 +1,1178 @@
+import * as paths from "path";
+import { isStringLiteral, literalValueToDenseJson, literalValueToIdentity, unquoteAndUnescape, valueHasPrimitiveType, } from "./literals.js";
+import { parseModule } from "./parser.js";
+import { tokenizeModule } from "./tokenizer.js";
+export class ModuleSet {
+    static create(fileReader, rootPath) {
+        return new ModuleSet(new DefaultModuleParser(fileReader, rootPath));
+    }
+    static fromMap(map) {
+        const result = new ModuleSet(new MapBasedModuleParser(map));
+        for (const modulePath of map.keys()) {
+            result.parseAndResolve(modulePath);
+        }
+        return result;
+    }
+    constructor(moduleParser) {
+        this.moduleParser = moduleParser;
+        this.modules = new Map();
+        this.mutableRecordMap = new Map();
+        this.mutableResolvedModules = [];
+        this.numberToRecord = new Map();
+        this.numberToMethod = new Map();
+        this.mutableErrors = [];
+    }
+    parseAndResolve(modulePath, inProgressSet) {
+        const inMap = this.modules.get(modulePath);
+        if (inMap !== undefined) {
+            return inMap;
+        }
+        const result = this.doParseAndResolve(modulePath, inProgressSet || new Set());
+        this.modules.set(modulePath, result);
+        this.mutableErrors.push(...result.errors);
+        return result;
+    }
+    /** Called by `parseAndResolve` when the module is not in the map already. */
+    doParseAndResolve(modulePath, inProgressSet) {
+        const errors = [];
+        let module;
+        {
+            const parseResult = this.moduleParser.parseModule(modulePath);
+            if (parseResult.result === null) {
+                return parseResult;
+            }
+            errors.push(...parseResult.errors);
+            module = parseResult.result;
+        }
+        // Process all imports.
+        const pathToImports = new Map();
+        for (const declaration of module.declarations) {
+            if (declaration.kind !== "import" &&
+                declaration.kind !== "import-alias") {
+                continue;
+            }
+            const otherModulePath = resolveModulePath(declaration.modulePath, modulePath, errors);
+            declaration.resolvedModulePath = otherModulePath;
+            if (otherModulePath === undefined) {
+                // An error was already registered.
+                continue;
+            }
+            let imports = pathToImports.get(otherModulePath);
+            if (!imports) {
+                imports = [];
+                pathToImports.set(otherModulePath, imports);
+            }
+            imports.push(declaration);
+            // 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.result === null) {
+                errors.push({
+                    token: declaration.modulePath,
+                    message: "Module not found",
+                });
+            }
+            else if (otherModule.errors.length !== 0) {
+                const hasCircularDependency = otherModule.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.result.nameToDeclaration[importedName.text];
+                    if (importedDeclaration === undefined) {
+                        errors.push({
+                            token: importedName,
+                            message: "Not found",
+                        });
+                    }
+                    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",
+                        });
+                    }
+                }
+            }
+        }
+        const pathToImportedNames = module.pathToImportedNames;
+        for (const [path, imports] of pathToImports.entries()) {
+            const importsNoAlias = imports.filter((i) => i.kind === "import");
+            const importsWithAlias = imports.filter((i) => i.kind === "import-alias");
+            if (importsNoAlias.length && importsWithAlias.length) {
+                for (const importNoAlias of importsNoAlias) {
+                    errors.push({
+                        token: importNoAlias.modulePath,
+                        message: "Module already imported with an alias",
+                    });
+                }
+                continue;
+            }
+            if (importsWithAlias.length >= 2) {
+                for (const importWithAlias of importsWithAlias.slice(1)) {
+                    errors.push({
+                        token: importWithAlias.modulePath,
+                        message: "Module already imported with a different alias",
+                    });
+                }
+                continue;
+            }
+            if (importsNoAlias.length) {
+                const names = new Set();
+                for (const importNoAlias of importsNoAlias) {
+                    for (const importedName of importNoAlias.importedNames) {
+                        names.add(importedName.text);
+                    }
+                }
+                pathToImportedNames[path] = {
+                    kind: "some",
+                    names: names,
+                };
+            }
+            else {
+                const alias = importsWithAlias[0].name.text;
+                pathToImportedNames[path] = {
+                    kind: "all",
+                    alias: alias,
+                };
+            }
+        }
+        const result = {
+            result: module,
+            errors: errors,
+        };
+        if (errors.length) {
+            return result;
+        }
+        this.mutableResolvedModules.push(module);
+        // 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.mutableRecordMap.set(key, record);
+            const { recordNumber } = record.record;
+            if (recordNumber != null) {
+                const existing = this.numberToRecord.get(recordNumber);
+                if (existing === undefined) {
+                    this.numberToRecord.set(recordNumber, key);
+                }
+                else {
+                    const otherRecord = this.recordMap.get(existing);
+                    const otherRecordName = otherRecord.record.name.text;
+                    const otherModulePath = otherRecord.modulePath;
+                    errors.push({
+                        token: record.record.name,
+                        message: `Same number as ${otherRecordName} in ${otherModulePath}`,
+                    });
+                }
+            }
+        }
+        // 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.modules, usedImports, errors);
+        for (const record of module.records) {
+            this.storeResolvedFieldTypes(record, typeResolver);
+        }
+        // Loop 3: once all the types of record fields have been resolved.
+        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.
+                this.resolveDocReferences({
+                    kind: "field",
+                    field: field,
+                    record: record,
+                }, module, errors);
+            }
+            // Resolve the references in the doc comments of the record.
+            this.resolveDocReferences(record, module, errors);
+        }
+        // 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 request = method.unresolvedRequestType;
+                const requestType = typeResolver.resolve(request, "top-level");
+                method.requestType = requestType;
+                if (requestType) {
+                    this.validateArrayKeys(requestType, errors);
+                }
+            }
+            {
+                const response = method.unresolvedResponseType;
+                const responseType = typeResolver.resolve(response, "top-level");
+                method.responseType = responseType;
+                if (responseType) {
+                    this.validateArrayKeys(responseType, errors);
+                }
+            }
+            const { number } = method;
+            const existing = this.numberToMethod.get(number);
+            if (existing === undefined) {
+                this.numberToMethod.set(number, method);
+            }
+            else {
+                const otherMethodName = existing.name.text;
+                const otherModulePath = existing.name.line.modulePath;
+                errors.push({
+                    token: method.name,
+                    message: `Same number as ${otherMethodName} in ${otherModulePath}`,
+                });
+            }
+            // Resolve the references in the doc comments of the method.
+            this.resolveDocReferences(method, module, errors);
+        }
+        // Resolve every constant type. Store the result in the constant object.
+        for (const constant of module.constants) {
+            const { unresolvedType } = constant;
+            const type = typeResolver.resolve(unresolvedType, "top-level");
+            constant.type = type;
+            if (type) {
+                this.validateArrayKeys(type, errors);
+                constant.valueAsDenseJson = //
+                    this.valueToDenseJson(constant.value, type, errors);
+            }
+            // Resolve the references in the doc comments of the constant.
+            this.resolveDocReferences(constant, module, errors);
+        }
+        ensureAllImportsAreUsed(module, usedImports, errors);
+        return result;
+    }
+    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", "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": {
+                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 (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 === "hard")
+                    break;
+                this.collectTypeDeps(input.item, mode, out);
+                break;
+            }
+            case "optional": {
+                if (mode === "hard")
+                    break;
+                this.collectTypeDeps(input.other, mode, out);
+                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.recordType === "struct") {
+                    const field = record.nameToDeclaration[fieldName.text];
+                    if (!field || field.kind !== "field") {
+                        errors.push({
+                            token: fieldName,
+                            message: `Field not found in struct ${record.name.text}`,
+                        });
+                        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'",
+                        });
+                        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;
+        for (const [fieldName, fieldEntry] of Object.entries(value.entries)) {
+            const field = expectedStruct.nameToDeclaration[fieldName];
+            if (!field || field.kind !== "field") {
+                errors.push({
+                    token: fieldEntry.name,
+                    message: `Field not found in struct ${expectedStruct.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) {
+                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 === "uint64") &&
+                        valueJson === "0");
+            if (!hasDefaultValue) {
+                arrayLen = Math.max(arrayLen, field.number + 1);
+            }
+        }
+        if (!allGood) {
+            return undefined;
+        }
+        value.type = expectedStruct.key;
+        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 === "?") {
+                // Present on every enum.
+                return 0;
+            }
+            const field = expectedEnum.nameToDeclaration[fieldName];
+            if (!field || field.kind !== "field") {
+                errors.push({
+                    token: token,
+                    message: `Field not found in enum ${expectedEnum.name.text}`,
+                });
+                return undefined;
+            }
+            if (field.type) {
+                errors.push({
+                    token: token,
+                    message: "Refers to a wrapper field",
+                });
+                return undefined;
+            }
+            value.type = {
+                kind: "enum",
+                key: expectedEnum.key,
+            };
+            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 fields defined in
+            //     the enum
+            //   · 'value' must match the type of the wrapper field
+            const entries = { ...value.entries };
+            const kindEntry = entries.kind;
+            if (!kindEntry) {
+                errors.push({
+                    token: token,
+                    message: "Missing entry: kind",
+                });
+                return undefined;
+            }
+            delete entries.kind;
+            const kindValueToken = kindEntry.value.token;
+            if (kindEntry.value.kind !== "literal" ||
+                !isStringLiteral(kindValueToken.text)) {
+                errors.push({
+                    token: kindValueToken,
+                    expected: "string",
+                });
+                return undefined;
+            }
+            const fieldName = unquoteAndUnescape(kindValueToken.text);
+            const field = expectedEnum.nameToDeclaration[fieldName];
+            if (!field || field.kind !== "field") {
+                errors.push({
+                    token: kindValueToken,
+                    message: `Field not found in enum ${expectedEnum.name.text}`,
+                });
+                return undefined;
+            }
+            if (!field.type) {
+                errors.push({
+                    token: kindValueToken,
+                    message: "Refers to a constant field",
+                });
+                return undefined;
+            }
+            const enumValue = entries.value;
+            if (!enumValue) {
+                errors.push({
+                    token: token,
+                    message: "Missing entry: value",
+                });
+                return undefined;
+            }
+            delete entries.value;
+            const valueJson = //
+             this.valueToDenseJson(enumValue.value, field.type, errors);
+            if (valueJson === undefined) {
+                return undefined;
+            }
+            const extraEntries = Object.values(entries);
+            if (extraEntries.length !== 0) {
+                const extraEntry = extraEntries[0];
+                errors.push({
+                    token: extraEntry.name,
+                    message: "Extraneous entry",
+                });
+                return undefined;
+            }
+            value.type = expectedEnum.key;
+            // Return an array of length 2.
+            return [field.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 "uint64":
+                    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;
+                }
+            }
+        }
+    }
+    /** Resolve the references in the doc comments of the given declaration. */
+    resolveDocReferences(documentee, module, errors) {
+        const doc = documentee.kind === "field" ? documentee.field.doc : documentee.doc;
+        const docReferences = doc.pieces.filter((p) => p.kind === "reference");
+        if (docReferences.length <= 0) {
+            return;
+        }
+        // Try to resolve a reference by looking it up in the given scope.
+        // Returns true if resolved, false otherwise.
+        const tryResolveReference = (ref, nameChain, scope) => {
+            if (ref.absolute && scope !== module) {
+                return false;
+            }
+            const firstName = nameChain[0];
+            const match = scope.nameToDeclaration[firstName.text];
+            if (!match) {
+                return false;
+            }
+            if (nameChain.length === 1) {
+                // Single name: must refer to a declaration.
+                switch (match.kind) {
+                    case "constant":
+                    case "method":
+                    case "record": {
+                        ref.referee = match;
+                        return true;
+                    }
+                    case "field": {
+                        if (scope.kind !== "record") {
+                            throw new TypeError(scope.kind);
+                        }
+                        ref.referee = {
+                            kind: "field",
+                            field: match,
+                            record: scope,
+                        };
+                        return true;
+                    }
+                    case "import":
+                    case "import-alias":
+                    case "removed":
+                        return false;
+                }
+            }
+            else {
+                // Multi-part name: first part must be a naming scope.
+                switch (match.kind) {
+                    case "record":
+                        return tryResolveReference(ref, nameChain.slice(1), match);
+                    case "import":
+                    case "import-alias": {
+                        if (scope !== module) {
+                            // Cannot refer to other module's imports.
+                            return false;
+                        }
+                        const { resolvedModulePath } = match;
+                        if (!resolvedModulePath) {
+                            return false;
+                        }
+                        const importedModule = this.modules.get(resolvedModulePath);
+                        if (!importedModule?.result) {
+                            return false;
+                        }
+                        const newNameChain = nameChain.slice(match.kind === "import" ? 0 : 1);
+                        return tryResolveReference(ref, newNameChain, importedModule.result);
+                    }
+                    case "constant":
+                    case "field":
+                    case "method":
+                    case "removed":
+                        return false;
+                }
+            }
+        };
+        const { recordMap } = this;
+        // Build list of naming scopes to search, in order of priority.
+        const scopes = [];
+        const pushRecordAncestorsToScopes = (record) => {
+            const { key } = record;
+            const location = recordMap.get(key);
+            const ancestors = [...location.recordAncestors].reverse();
+            for (const ancestor of ancestors) {
+                scopes.push(ancestor);
+            }
+        };
+        const pushTypeToScopes = (type) => {
+            if (type) {
+                const recordKey = tryFindRecordForType(type);
+                if (recordKey) {
+                    const { record } = recordMap.get(recordKey);
+                    scopes.push(record);
+                }
+            }
+        };
+        switch (documentee.kind) {
+            case "constant": {
+                scopes.push(module);
+                pushTypeToScopes(documentee.type);
+                break;
+            }
+            case "field": {
+                const { field, record } = documentee;
+                pushRecordAncestorsToScopes(record);
+                scopes.push(module);
+                pushTypeToScopes(field.type);
+                break;
+            }
+            case "method": {
+                scopes.push(module);
+                pushTypeToScopes(documentee.requestType);
+                pushTypeToScopes(documentee.responseType);
+                break;
+            }
+            case "record": {
+                pushRecordAncestorsToScopes(documentee);
+                scopes.push(module);
+                break;
+            }
+        }
+        // Resolve each reference by searching through scopes in priority order.
+        for (const reference of docReferences) {
+            const { nameChain } = reference;
+            if (nameChain.length <= 0) {
+                continue;
+            }
+            let resolved = false;
+            for (const scope of scopes) {
+                if (tryResolveReference(reference, nameChain, scope)) {
+                    resolved = true;
+                    break;
+                }
+            }
+            if (!resolved) {
+                errors.push({
+                    token: reference.referenceRange,
+                    message: "Cannot resolve reference",
+                });
+            }
+        }
+    }
+    get recordMap() {
+        return this.mutableRecordMap;
+    }
+    get resolvedModules() {
+        return this.mutableResolvedModules;
+    }
+    findRecordByNumber(recordNumber) {
+        const recordKey = this.numberToRecord.get(recordNumber);
+        if (recordKey === undefined) {
+            return undefined;
+        }
+        return this.recordMap.get(recordKey);
+    }
+    findMethodByNumber(methodNumber) {
+        return this.numberToMethod.get(methodNumber);
+    }
+    get errors() {
+        return this.mutableErrors;
+    }
+}
+/**
+ * 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, modules, usedImports, errors) {
+        this.module = module;
+        this.modules = modules;
+        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];
+        // 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 { errors, module, modules, usedImports } = this;
+        if (recordOrigin !== "top-level") {
+            if (!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;
+                    }
+                }
+            }
+            if (!start) {
+                start = module;
+            }
+        }
+        else {
+            start = module;
+        }
+        const makeNotARecordError = (name) => ({
+            token: name,
+            message: "Does not refer to a struct or an enum",
+        });
+        const makeCannotFindNameError = (name) => ({
+            token: name,
+            message: `Cannot find name '${name.text}'`,
+        });
+        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));
+                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 = modules.get(newModulePath);
+                if (newModuleResult === undefined || newModuleResult.result === null) {
+                    // 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.result;
+                if (newIt.kind === "import") {
+                    newIt = newModule.nameToDeclaration[name];
+                    if (!newIt) {
+                        errors.push(makeCannotFindNameError(namePart));
+                        return undefined;
+                    }
+                    if (!newIt || 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),
+        };
+    }
+}
+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",
+                });
+            }
+        }
+    }
+}
+class ModuleParserBase {
+    parseModule(modulePath) {
+        const code = this.readSourceCode(modulePath);
+        if (code === undefined) {
+            return {
+                result: null,
+                errors: [],
+            };
+        }
+        const tokens = tokenizeModule(code, modulePath);
+        if (tokens.errors.length !== 0) {
+            return {
+                result: null,
+                errors: tokens.errors,
+            };
+        }
+        return parseModule(tokens.result);
+    }
+}
+class DefaultModuleParser extends ModuleParserBase {
+    constructor(fileReader, rootPath) {
+        super();
+        this.fileReader = fileReader;
+        this.rootPath = rootPath;
+    }
+    readSourceCode(modulePath) {
+        return this.fileReader.readTextFile(paths.join(this.rootPath, modulePath));
+    }
+}
+class MapBasedModuleParser extends ModuleParserBase {
+    constructor(moduleMap) {
+        super();
+        this.moduleMap = moduleMap;
+    }
+    readSourceCode(modulePath) {
+        return this.moduleMap.get(modulePath);
+    }
+}
+function resolveModulePath(pathToken, originModulePath, errors) {
+    let modulePath = unquoteAndUnescape(pathToken.text);
+    if (/\\/.test(modulePath)) {
+        errors.push({
+            token: pathToken,
+            message: "Replace backslash with slash",
+        });
+        return undefined;
+    }
+    if (modulePath.startsWith("./") || modulePath.startsWith("../")) {
+        // This is a relative path from the module. Let's transform it into a
+        // relative path from root.
+        modulePath = paths.join(originModulePath, "..", modulePath);
+    }
+    // "a/./b/../c" => "a/c"
+    // Note that `paths.normalize` will use backslashes on Windows.
+    // We don't want that.
+    modulePath = paths.normalize(modulePath).replace(/\\/g, "/");
+    if (modulePath.startsWith(`../`)) {
+        errors.push({
+            token: pathToken,
+            message: "Module path must point to a file within root",
+        });
+        return undefined;
+    }
+    return modulePath;
+}
+function tryFindRecordForType(type) {
+    switch (type.kind) {
+        case "array":
+            return tryFindRecordForType(type.item);
+        case "optional":
+            return tryFindRecordForType(type.other);
+        case "record":
+            return type.key;
+        case "primitive":
+            return null;
+    }
+}
+//# sourceMappingURL=module_set.js.map