semantifold 0.3.0 → 0.5.0

package/build/src/frontends/types.js

@@ -0,0 +1,634 @@
+// @ts-check
+import { missingType, unsupportedSyntax } from "../diagnostic.js";
+import { recordTypeSubstitutions, substituteValueType, typeContainsAnyVariable } from "../semantic/generics.js";
+import { locationFromOffsets } from "../semantic/location.js";
+import { parserRangeFor, setParserRanges } from "../semantic/provenance.js";
+import { sourceScalarType } from "./scalars.js";
+/**
+ * Resolves the value presented to list iteration after canonical optional unwrap.
+ * Semantic validation remains responsible for requiring the matching presence proof.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType | import("../semantic/types.js").ErrorType | undefined} type - Parser-resolved operand type.
+ * @returns {import("../semantic/types.js").SemanticFunctionReturnType | import("../semantic/types.js").ErrorType | undefined} Iterated value type.
+ */
+export function iterationOperandType(type) {
+    return type?.kind == "OptionalType" ? type.valueType : type;
+}
+/**
+ * Copies a resolved list element type for one parser-owned iteration binding.
+ * The binding location is its own deterministic derived type anchor.
+ * @param {import("../semantic/types.js").SemanticValueType} type - Resolved element type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Binding token location.
+ * @returns {import("../semantic/types.js").SemanticValueType} Detached semantic type.
+ */
+export function iterationBindingType(type, location) {
+    if (type.kind == "TypeReference") {
+        const copied = { kind: /** @type {const} */ ("TypeReference"), name: type.name };
+        setParserRanges(copied, { type: location });
+        return copied;
+    }
+    if (type.kind == "TypeVariableReference")
+        return typeVariable(type.parameterId, location);
+    if (type.kind == "ListType") {
+        return listType(iterationBindingType(type.elementType, location), location, location);
+    }
+    if (type.kind == "MapType" || type.kind == "OrderedMapType") {
+        const keyType = iterationBindingType(type.keyType, location);
+        return type.kind == "OrderedMapType" ? orderedMapType(
+        /** @type {import("../semantic/types.js").TypeReference} */ (keyType), iterationBindingType(type.valueType, location), location, location, location) : mapType(
+        /** @type {import("../semantic/types.js").TypeReference} */ (keyType), iterationBindingType(type.valueType, location), location, location, location);
+    }
+    if (type.kind == "RecordType")
+        return recordType(type.declarationId, location, type.arguments?.map((argument) => iterationBindingType(argument, location)));
+    if (type.kind == "ReferenceType")
+        return referenceType(type.declarationId, location);
+    if (type.kind == "OwnedResourceType")
+        return ownedResourceType(type.resourceId, location);
+    if (type.kind == "OwnedReferenceType")
+        return ownedReferenceType(type.declarationId, location);
+    return optionalType(iterationBindingType(type.valueType, location), location, location);
+}
+/**
+ * Builds one recursive semantic list type with parser-owned constituent ranges.
+ * @param {import("../semantic/types.js").SemanticValueType} elementType - Element type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Complete type-expression range.
+ * @param {import("../semantic/types.js").SourceLocation} elementLocation - Element type-expression range.
+ * @returns {import("../semantic/types.js").ListType} List type.
+ */
+export function listType(elementType, location, elementLocation) {
+    const type = { elementType, kind: /** @type {const} */ ("ListType") };
+    setParserRanges(type, { elementType: elementLocation, type: location });
+    return type;
+}
+/**
+ * Builds one recursive semantic map type with parser-owned constituent ranges.
+ * @param {import("../semantic/types.js").TypeReference} keyType - Key type.
+ * @param {import("../semantic/types.js").SemanticValueType} valueType - Value type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Complete type-expression range.
+ * @param {import("../semantic/types.js").SourceLocation} keyLocation - Key type-expression range.
+ * @param {import("../semantic/types.js").SourceLocation} valueLocation - Value type-expression range.
+ * @returns {import("../semantic/types.js").MapType} Map type.
+ */
+export function mapType(keyType, valueType, location, keyLocation, valueLocation) {
+    const type = { keyType, kind: /** @type {const} */ ("MapType"), valueType };
+    setParserRanges(type, { keyType: keyLocation, type: location, valueType: valueLocation });
+    return type;
+}
+/**
+ * Builds one insertion-ordered recursive semantic map type.
+ * @param {import("../semantic/types.js").TypeReference} keyType - Key type.
+ * @param {import("../semantic/types.js").SemanticValueType} valueType - Value type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Complete type range.
+ * @param {import("../semantic/types.js").SourceLocation} keyLocation - Key range.
+ * @param {import("../semantic/types.js").SourceLocation} valueLocation - Value range.
+ * @returns {import("../semantic/types.js").OrderedMapType} Ordered-map type.
+ */
+export function orderedMapType(keyType, valueType, location, keyLocation, valueLocation) {
+    const type = { keyType, kind: /** @type {const} */ ("OrderedMapType"), order: /** @type {const} */ ("insertion"), valueType };
+    setParserRanges(type, { keyType: keyLocation, type: location, valueType: valueLocation });
+    return type;
+}
+/**
+ * Promotes one parser-proven ordinary map annotation into the distinct ordered-map capability.
+ * @param {import("../semantic/types.js").MapType} type - Parsed homogeneous map type.
+ * @param {import("../semantic/types.js").SourceLocation} fallbackLocation - Owning declaration location.
+ * @returns {import("../semantic/types.js").OrderedMapType} Ordered counterpart with the same parser ranges.
+ */
+export function orderedMapTypeFromMap(type, fallbackLocation) {
+    const ranges = type.sourceProvenance?.ranges;
+    return orderedMapType(type.keyType, type.valueType, ranges?.type ?? fallbackLocation, ranges?.keyType ?? fallbackLocation, ranges?.valueType ?? fallbackLocation);
+}
+/**
+ * Builds one recursive semantic optional type with parser-owned constituent ranges.
+ * @param {import("../semantic/types.js").SemanticValueType} valueType - Present-value type.
+ * @param {import("../semantic/types.js").SourceLocation} location - Complete type-expression range.
+ * @param {import("../semantic/types.js").SourceLocation} valueLocation - Present-value type range.
+ * @returns {import("../semantic/types.js").OptionalType} Optional type.
+ */
+export function optionalType(valueType, location, valueLocation) {
+    const type = { kind: /** @type {const} */ ("OptionalType"), valueType };
+    setParserRanges(type, { type: location, valueType: valueLocation });
+    return type;
+}
+/**
+ * Builds one nominal semantic record type with a parser-owned name range.
+ * @param {string} declarationId - Stable declaration identity.
+ * @param {import("../semantic/types.js").SourceLocation} location - Record type-name range.
+ * @param {import("../semantic/types.js").SemanticValueType[]} [arguments_] - Exact generic arguments.
+ * @returns {import("../semantic/types.js").RecordType} Record type.
+ */
+export function recordType(declarationId, location, arguments_) {
+    const type = { declarationId, kind: /** @type {const} */ ("RecordType"), ...(arguments_ ? { arguments: arguments_ } : {}) };
+    setParserRanges(type, { type: location });
+    return type;
+}
+/**
+ * Builds one nominal reference-class type with a parser-owned name range.
+ * @param {string} declarationId - Stable class identity.
+ * @param {import("../semantic/types.js").SourceLocation} location - Class type-name range.
+ * @returns {import("../semantic/types.js").ReferenceType} Reference type.
+ */
+export function referenceType(declarationId, location) {
+    const type = { declarationId, kind: /** @type {const} */ ("ReferenceType") };
+    setParserRanges(type, { type: location });
+    return type;
+}
+/**
+ * Builds one compiler-owned resource type with a parser-owned name range.
+ * @param {string} resourceId - Stable capability resource identity.
+ * @param {import("../semantic/types.js").SourceLocation} location - Resource type-name range.
+ * @returns {import("../semantic/types.js").OwnedResourceType} Owned resource type.
+ */
+export function ownedResourceType(resourceId, location) {
+    const type = { kind: /** @type {const} */ ("OwnedResourceType"), resourceId };
+    setParserRanges(type, { type: location });
+    return type;
+}
+/**
+ * Builds one linear owned-reference type with a parser-owned name range.
+ * @param {string} declarationId - Stable owned class identity.
+ * @param {import("../semantic/types.js").SourceLocation} location - Class type-name range.
+ * @returns {import("../semantic/types.js").OwnedReferenceType} Owned reference type.
+ */
+export function ownedReferenceType(declarationId, location) {
+    const type = { declarationId, kind: /** @type {const} */ ("OwnedReferenceType") };
+    setParserRanges(type, { type: location });
+    return type;
+}
+/**
+ * Builds parser-context signatures for compiler-authorized operations without exposing a source declaration.
+ * @param {readonly import("../semantic/types.js").EffectCapabilityDeclaration[]} capabilities - Authorized declarations.
+ * @param {import("../semantic/types.js").SourceLocation} location - Synthetic parser-context anchor.
+ * @returns {Map<string, {location: import("../semantic/types.js").SourceLocation, nameLocation: import("../semantic/types.js").SourceLocation, name: string, parameters: import("../semantic/types.js").Parameter[], returnType: import("../semantic/types.js").SemanticFunctionReturnType, typeParameters?: import("../semantic/types.js").TypeParameter[]}>} Signatures by source spelling.
+ */
+export function capabilityFunctionSignatures(capabilities, location) {
+    return new Map(capabilities.flatMap(({ operations }) => operations).map((operation) => [operation.name, {
+            location,
+            name: operation.name,
+            nameLocation: location,
+            parameters: operation.parameters.map((parameter) => ({ kind: /** @type {const} */ ("Parameter"), location, ...parameter })),
+            returnType: operation.returnType
+        }]));
+}
+/**
+ * Builds one declaration-scoped type-variable reference.
+ * @param {string} parameterId - Stable type-parameter identity.
+ * @param {import("../semantic/types.js").SourceLocation} location - Exact reference range.
+ * @returns {import("../semantic/types.js").TypeVariableReference} Type-variable reference.
+ */
+export function typeVariable(parameterId, location) {
+    const type = { kind: /** @type {const} */ ("TypeVariableReference"), location, parameterId };
+    setParserRanges(type, { type: location });
+    return type;
+}
+/**
+ * Compares semantic type expressions while ignoring parser-owned locations.
+ * @param {import("../semantic/types.js").SemanticValueType} left - Left type.
+ * @param {import("../semantic/types.js").SemanticValueType} right - Right type.
+ * @returns {boolean} Whether the semantic structures are identical.
+ */
+export function sameValueType(left, right) {
+    if (left.kind != right.kind)
+        return false;
+    if (left.kind == "TypeReference" && right.kind == "TypeReference")
+        return left.name == right.name;
+    if (left.kind == "TypeVariableReference" && right.kind == "TypeVariableReference")
+        return left.parameterId == right.parameterId;
+    if (left.kind == "ListType" && right.kind == "ListType")
+        return sameValueType(left.elementType, right.elementType);
+    if (left.kind == "OptionalType" && right.kind == "OptionalType")
+        return sameValueType(left.valueType, right.valueType);
+    if ((left.kind == "MapType" && right.kind == "MapType") ||
+        (left.kind == "OrderedMapType" && right.kind == "OrderedMapType")) {
+        return sameValueType(left.keyType, right.keyType) && sameValueType(left.valueType, right.valueType);
+    }
+    if (left.kind == "RecordType" && right.kind == "RecordType") {
+        const leftArguments = left.arguments ?? [];
+        const rightArguments = right.arguments ?? [];
+        return left.declarationId == right.declarationId && leftArguments.length == rightArguments.length &&
+            leftArguments.every((argument, index) => sameValueType(argument, rightArguments[index]));
+    }
+    if (left.kind == "ReferenceType" && right.kind == "ReferenceType")
+        return left.declarationId == right.declarationId;
+    if (left.kind == "OwnedResourceType" && right.kind == "OwnedResourceType")
+        return left.resourceId == right.resourceId;
+    if (left.kind == "OwnedReferenceType" && right.kind == "OwnedReferenceType")
+        return left.declarationId == right.declarationId;
+    return false;
+}
+/**
+ * Resolves one generic record field against a complete application for parser
+ * contextual conversion. Invalid/raw applications remain unchanged so the
+ * semantic validator owns their stable diagnostic.
+ * @param {import("../semantic/types.js").RecordDeclaration} declaration - Resolved record declaration.
+ * @param {import("../semantic/types.js").SemanticValueType[] | undefined} arguments_ - Parsed application arguments.
+ * @param {number} index - Constructor field index.
+ * @returns {import("../semantic/types.js").SemanticValueType | undefined} Closed field type when available.
+ */
+export function instantiatedRecordFieldType(declaration, arguments_, index) {
+    const field = declaration.fields[index];
+    const parameters = declaration.typeParameters ?? [];
+    if (!field || parameters.length == 0 || !arguments_ || arguments_.length != parameters.length)
+        return field?.type;
+    const application = /** @type {import("../semantic/types.js").RecordType} */ ({
+        arguments: arguments_,
+        declarationId: /** @type {string} */ (declaration.id),
+        kind: "RecordType"
+    });
+    return substituteValueType(field.type, recordTypeSubstitutions(application, declaration));
+}
+/**
+ * Applies parser-known generic-call argument evidence to its declared return.
+ * An unresolved variable remains open: this is conservative context discovery
+ * only, while semantic validation still performs authoritative inference.
+ * @param {{parameters: import("../semantic/types.js").Parameter[], returnType: import("../semantic/types.js").SemanticFunctionReturnType}} signature - Declared signature.
+ * @param {(import("../semantic/types.js").SemanticFunctionReturnType | import("../semantic/types.js").ErrorType | undefined)[]} arguments_ - Parser-known argument types.
+ * @returns {import("../semantic/types.js").SemanticFunctionReturnType | undefined} Known result with available substitutions.
+ */
+export function knownCallReturnType(signature, arguments_) {
+    if (signature.returnType.kind == "TypeReference" && signature.returnType.name == "void")
+        return signature.returnType;
+    const substitutions = knownCallSubstitutions(signature, arguments_);
+    return substitutions ? substituteValueType(signature.returnType, substitutions) : undefined;
+}
+/**
+ * Applies conservative parser-known call evidence to every parameter context.
+ * Unresolved variables remain open for the language frontend to handle only in
+ * a matching lexical type-parameter scope.
+ * @param {{parameters: import("../semantic/types.js").Parameter[]}} signature - Declared signature.
+ * @param {(import("../semantic/types.js").SemanticFunctionReturnType | import("../semantic/types.js").ErrorType | undefined)[]} arguments_ - Parser-known argument types.
+ * @returns {import("../semantic/types.js").SemanticValueType[] | undefined} Substituted parameter contexts.
+ */
+export function knownCallParameterTypes(signature, arguments_) {
+    const substitutions = knownCallSubstitutions(signature, arguments_);
+    return substitutions
+        ? signature.parameters.map((parameter) => substituteValueType(parameter.type, substitutions))
+        : undefined;
+}
+/**
+ * Collects conservative parser-known substitutions once for call context and
+ * result classification. Semantic validation remains authoritative.
+ * @param {{parameters: import("../semantic/types.js").Parameter[]}} signature - Declared signature.
+ * @param {(import("../semantic/types.js").SemanticFunctionReturnType | import("../semantic/types.js").ErrorType | undefined)[]} arguments_ - Parser-known argument types.
+ * @returns {Map<string, import("../semantic/types.js").SemanticValueType> | undefined} Compatible substitutions.
+ */
+function knownCallSubstitutions(signature, arguments_) {
+    /** @type {Map<string, import("../semantic/types.js").SemanticValueType>} */
+    const substitutions = new Map();
+    for (let index = 0; index < signature.parameters.length; index += 1) {
+        const actual = arguments_[index];
+        if (actual && actual.kind != "ErrorType" && !(actual.kind == "TypeReference" && actual.name == "void") &&
+            !collectKnownSubstitutions(signature.parameters[index].type, 
+            /** @type {import("../semantic/types.js").SemanticValueType} */ (actual), substitutions)) {
+            return undefined;
+        }
+    }
+    return substitutions;
+}
+/**
+ * Preserves an optional binding when a generic formal needs its wrapped type as
+ * argument-only inference evidence. The semantic validator remains the sole
+ * authority for unification and presence-proof checks.
+ * @param {{parameters: import("../semantic/types.js").Parameter[], typeParameters?: import("../semantic/types.js").TypeParameter[]} | undefined} signature - Known direct-call signature.
+ * @param {number} index - Argument index.
+ * @returns {boolean} Whether frontend conversion must retain optionality.
+ */
+export function preservesGenericOptionalEvidence(signature, index) {
+    const formal = signature?.parameters[index]?.type;
+    return Boolean(signature?.typeParameters?.length && formal && typeContainsAnyVariable(formal));
+}
+/**
+ * Conservatively collects structurally matching parser-known substitutions.
+ * @param {import("../semantic/types.js").SemanticValueType} formal - Open formal type.
+ * @param {import("../semantic/types.js").SemanticValueType} actual - Known argument type.
+ * @param {Map<string, import("../semantic/types.js").SemanticValueType>} substitutions - Collected substitutions.
+ * @returns {boolean} Whether the known structures remain compatible.
+ */
+function collectKnownSubstitutions(formal, actual, substitutions) {
+    if (formal.kind == "TypeVariableReference") {
+        const prior = substitutions.get(formal.parameterId);
+        if (prior)
+            return sameValueType(prior, actual);
+        substitutions.set(formal.parameterId, actual);
+        return true;
+    }
+    if (formal.kind == "OptionalType") {
+        return collectKnownSubstitutions(formal.valueType, actual.kind == "OptionalType" ? actual.valueType : actual, substitutions);
+    }
+    if (formal.kind != actual.kind)
+        return false;
+    if (formal.kind == "TypeReference")
+        return sameValueType(formal, actual);
+    if (formal.kind == "ReferenceType" && actual.kind == "ReferenceType")
+        return sameValueType(formal, actual);
+    if (formal.kind == "OwnedResourceType" && actual.kind == "OwnedResourceType")
+        return sameValueType(formal, actual);
+    if (formal.kind == "OwnedReferenceType" && actual.kind == "OwnedReferenceType")
+        return sameValueType(formal, actual);
+    if (formal.kind == "RecordType" && actual.kind == "RecordType") {
+        if (formal.declarationId != actual.declarationId || (formal.arguments?.length ?? 0) != (actual.arguments?.length ?? 0))
+            return false;
+        return (formal.arguments ?? []).every((argument, index) => collectKnownSubstitutions(argument, /** @type {import("../semantic/types.js").SemanticValueType} */ (actual.arguments?.[index]), substitutions));
+    }
+    if (formal.kind == "ListType" && actual.kind == "ListType") {
+        return collectKnownSubstitutions(formal.elementType, actual.elementType, substitutions);
+    }
+    if ((formal.kind == "MapType" && actual.kind == "MapType") ||
+        (formal.kind == "OrderedMapType" && actual.kind == "OrderedMapType")) {
+        return collectKnownSubstitutions(formal.keyType, actual.keyType, substitutions) &&
+            collectKnownSubstitutions(formal.valueType, actual.valueType, substitutions);
+    }
+    return false;
+}
+/**
+ * Converts one parser/comment-parser-owned bounded type expression. This parser
+ * recognizes only Task 006's concrete scalar/list/map grammar; it never scans
+ * source outside the already-associated type token.
+ * @param {object} input - Documented type input.
+ * @param {"javascript" | "php" | "ruby"} input.language - Comment profile.
+ * @param {import("../semantic/types.js").SourceLocation} input.location - Exact type token range.
+ * @param {import("../semantic/types.js").SourceLocation} input.ownerLocation - Owning declaration range.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} [input.records] - Available nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").TypeParameter>} [input.typeParameters] - Declaration-scoped parameters by name.
+ * @param {string} input.source - Complete parser input for exact subranges.
+ * @param {string | undefined} input.sourceType - Exact comment-parser/Prism-owned type token.
+ * @param {string} input.subject - Diagnostic subject.
+ * @returns {import("../semantic/types.js").SemanticValueType} Semantic value type.
+ */
+export function documentedValueType({ language, location, ownerLocation, records = new Map(), source, sourceType, subject, typeParameters = new Map() }) {
+    if (!sourceType)
+        return missingType(language, subject, ownerLocation);
+    if (language == "php" && sourceType.startsWith("?")) {
+        const valueText = sourceType.slice(1);
+        const valueLocation = locationFromOffsets(location.filename, source, location.start.offset + 1, location.end.offset);
+        return optionalType(documentedValueType({ language, location: valueLocation, ownerLocation, records, source, sourceType: valueText, subject, typeParameters }), location, valueLocation);
+    }
+    if (language == "php" && sourceType.includes("|")) {
+        return unsupportedSyntax(language, "arbitrary union type", location);
+    }
+    if (language == "javascript" && sourceType.endsWith("|null") && sourceType.indexOf("|") == sourceType.length - "|null".length) {
+        const valueText = sourceType.slice(0, -"|null".length);
+        const valueLocation = locationFromOffsets(location.filename, source, location.start.offset, location.start.offset + valueText.length);
+        return optionalType(documentedValueType({ language, location: valueLocation, ownerLocation, records, source, sourceType: valueText, subject, typeParameters }), location, valueLocation);
+    }
+    if (language == "javascript" && sourceType.includes("|") &&
+        !sourceType.startsWith("ReadonlyArray") && !sourceType.startsWith("ReadonlyMap") &&
+        !records.has(sourceType.slice(0, sourceType.indexOf("<") < 0 ? sourceType.length : sourceType.indexOf("<")))) {
+        return unsupportedSyntax(language, "arbitrary union type", location);
+    }
+    const scalar = sourceScalarType(language, sourceType, location);
+    if (scalar)
+        return scalar;
+    const unwrappedName = language == "ruby" && sourceType.startsWith("[") && sourceType.endsWith("]")
+        ? sourceType.slice(1, -1)
+        : sourceType;
+    const directRecord = records.get(unwrappedName);
+    if (directRecord?.id)
+        return directRecord.kind == "ClassDeclaration"
+            ? referenceType(directRecord.id, location)
+            : directRecord.kind == "EffectResourceDeclaration"
+                ? ownedResourceType(directRecord.id, location)
+                : recordType(directRecord.id, location);
+    const directTypeParameter = typeParameters.get(unwrappedName);
+    if (directTypeParameter?.id)
+        return typeVariable(directTypeParameter.id, location);
+    const collectionPrefixes = language == "ruby" ? ["[Array", "[Hash", "[Integer?", "[bool?", "[String?"] :
+        language == "php" ? ["list", "array"] : ["ReadonlyArray", "ReadonlyMap"];
+    const optionalRecord = language == "ruby" && sourceType.startsWith("[") && sourceType.endsWith("?]") &&
+        records.has(sourceType.slice(1, -2));
+    const possibleName = unwrappedName.slice(0, unwrappedName.search(/[<[?]/u) < 0 ? unwrappedName.length : unwrappedName.search(/[<[?]/u));
+    if (!optionalRecord && !collectionPrefixes.some((prefix) => sourceType.startsWith(prefix)) &&
+        !records.has(possibleName) && !typeParameters.has(possibleName)) {
+        return missingType(language, subject, ownerLocation);
+    }
+    const parser = new DocumentedTypeParser(language, sourceType, location, source, records, typeParameters);
+    const type = parser.parse();
+    if (!parser.atEnd())
+        return unsupportedSyntax(language, "unsupported collection type", parser.remainingLocation());
+    return type;
+}
+class DocumentedTypeParser {
+    /**
+     * Creates a bounded parser over one parser/comment-parser-owned token.
+     * @param {"javascript" | "php" | "ruby"} language - Exact comment profile.
+     * @param {string} text - Parser-owned type text.
+     * @param {import("../semantic/types.js").SourceLocation} location - Whole token location.
+     * @param {string} source - Complete source.
+     * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} records - Available nominal declarations.
+     * @param {Map<string, import("../semantic/types.js").TypeParameter>} typeParameters - Declaration-scoped parameters.
+     */
+    constructor(language, text, location, source, records, typeParameters) {
+        this.language = language;
+        this.text = text;
+        this.location = location;
+        this.source = source;
+        this.records = records;
+        this.typeParameters = typeParameters;
+        this.offset = 0;
+    }
+    /**
+     * Parses the complete documented type.
+     * @returns {import("../semantic/types.js").SemanticValueType} Parsed type.
+     */
+    parse() {
+        this.skipWhitespace();
+        if (this.language == "ruby") {
+            if (!this.consume("["))
+                return this.failure();
+            const type = this.parseNamedType();
+            this.skipWhitespace();
+            if (!this.consume("]"))
+                return this.failure();
+            this.skipWhitespace();
+            return type;
+        }
+        const type = this.parseNamedType();
+        this.skipWhitespace();
+        return type;
+    }
+    /**
+     * Parses one nested type expression.
+     * @returns {import("../semantic/types.js").SemanticValueType} Parsed nested type.
+     */
+    parseNamedType() {
+        this.skipWhitespace();
+        const start = this.offset;
+        if (this.language == "php" && this.consume("?")) {
+            const valueStart = this.offset;
+            const valueType = this.parseNamedType();
+            return optionalType(valueType, this.range(start, this.offset), this.typeRange(valueType, valueStart, this.offset));
+        }
+        while (isTypeIdentifierCharacter(this.text[this.offset]) || this.language == "ruby" &&
+            this.text[this.offset] == ":" && this.text[this.offset + 1] == ":" &&
+            isTypeIdentifierCharacter(this.text[this.offset + 2])) {
+            this.offset += this.text[this.offset] == ":" ? 2 : 1;
+        }
+        const nameEnd = this.offset;
+        const name = this.text.slice(start, nameEnd);
+        if (!name)
+            return this.failure();
+        const scalarSpelling = this.language == "ruby" ? `[${name}]` : name;
+        const scalar = sourceScalarType(this.language, scalarSpelling, this.range(start, nameEnd));
+        this.skipWhitespace();
+        if (scalar && this.text[this.offset] != "<" && this.text[this.offset] != "[") {
+            if (this.language == "ruby" && this.consume("?")) {
+                return optionalType(scalar, this.range(start, this.offset), this.typeRange(scalar, start, nameEnd));
+            }
+            if (this.language == "javascript" && this.consume("|null")) {
+                return optionalType(scalar, this.range(start, this.offset), this.typeRange(scalar, start, nameEnd));
+            }
+            return scalar;
+        }
+        const record = this.records.get(name);
+        const typeParameter = this.typeParameters.get(name);
+        if (typeParameter?.id && this.text[this.offset] != "<" && this.text[this.offset] != "[") {
+            const type = typeVariable(typeParameter.id, this.range(start, nameEnd));
+            if (this.language == "ruby" && this.consume("?")) {
+                return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd));
+            }
+            if (this.language == "javascript" && this.consume("|null")) {
+                return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd));
+            }
+            return type;
+        }
+        if (record?.id && this.text[this.offset] != "<" && this.text[this.offset] != "[") {
+            const type = record.kind == "ClassDeclaration"
+                ? referenceType(record.id, this.range(start, nameEnd))
+                : record.kind == "EffectResourceDeclaration"
+                    ? ownedResourceType(record.id, this.range(start, nameEnd))
+                    : recordType(record.id, this.range(start, nameEnd));
+            if (this.language == "ruby" && this.consume("?")) {
+                return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd));
+            }
+            if (this.language == "javascript" && this.consume("|null")) {
+                return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd));
+            }
+            return type;
+        }
+        const listName = this.language == "ruby" ? "Array" : this.language == "php" ? "list" : "ReadonlyArray";
+        const mapName = this.language == "ruby" ? "Hash" : this.language == "php" ? "array" : "ReadonlyMap";
+        const opening = this.language == "ruby" ? "[" : "<";
+        const closing = this.language == "ruby" ? "]" : ">";
+        if (name != listName && name != mapName && !record || !this.consume(opening))
+            return this.failure();
+        const first = this.parseNamedType();
+        const firstEnd = this.offset;
+        this.skipWhitespace();
+        if (record?.id) {
+            const arguments_ = [first];
+            while (this.consume(","))
+                arguments_.push(this.parseNamedType());
+            if (!this.consume(closing))
+                return this.failure();
+            const applicationEnd = this.offset;
+            const type = recordType(record.id, this.range(start, nameEnd), arguments_);
+            if (this.language == "ruby" && this.consume("?")) {
+                return optionalType(type, this.range(start, this.offset), this.range(start, applicationEnd));
+            }
+            if (this.language == "javascript" && this.consume("|null")) {
+                return optionalType(type, this.range(start, this.offset), this.range(start, applicationEnd));
+            }
+            return type;
+        }
+        if (name == listName) {
+            if (!this.consume(closing))
+                return this.failure();
+            const type = listType(first, this.range(start, this.offset), this.typeRange(first, start, firstEnd));
+            if (this.language == "ruby" && this.consume("?")) {
+                return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, firstEnd));
+            }
+            if (this.language == "javascript" && this.consume("|null")) {
+                return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, firstEnd));
+            }
+            return type;
+        }
+        if (!this.consume(","))
+            return this.failure();
+        const second = this.parseNamedType();
+        const secondEnd = this.offset;
+        this.skipWhitespace();
+        if (!this.consume(closing))
+            return this.failure();
+        if (first.kind != "TypeReference") {
+            return unsupportedSyntax(this.language, "map key type other than string", this.typeRange(first, start, firstEnd));
+        }
+        const type = mapType(first, second, this.range(start, this.offset), this.typeRange(first, start, firstEnd), this.typeRange(second, firstEnd, secondEnd));
+        if (this.language == "ruby" && this.consume("?")) {
+            return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, secondEnd));
+        }
+        if (this.language == "javascript" && this.consume("|null")) {
+            return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, secondEnd));
+        }
+        return type;
+    }
+    /**
+     * Reports whether the complete token was consumed.
+     * @returns {boolean} Whether the whole token was consumed.
+     */
+    atEnd() {
+        return this.offset == this.text.length;
+    }
+    /**
+     * Locates the remaining invalid suffix.
+     * @returns {import("../semantic/types.js").SourceLocation} Remaining invalid range.
+     */
+    remainingLocation() {
+        return this.range(this.offset, Math.max(this.offset + 1, this.text.length));
+    }
+    /**
+     * Consumes one exact punctuation token.
+     * @param {string} token - Exact punctuation.
+     * @returns {boolean} Whether consumed.
+     */
+    consume(token) {
+        this.skipWhitespace();
+        if (!this.text.startsWith(token, this.offset))
+            return false;
+        this.offset += token.length;
+        return true;
+    }
+    /**
+     * Skips bounded type-expression whitespace.
+     * @returns {void}
+     */
+    skipWhitespace() {
+        while ([" ", "\t", "\r", "\n"].includes(this.text[this.offset]))
+            this.offset++;
+    }
+    /**
+     * Converts relative offsets into parser-owned source coordinates.
+     * @param {number} start - Relative start.
+     * @param {number} end - Relative end.
+     * @returns {import("../semantic/types.js").SourceLocation} Exact source range.
+     */
+    range(start, end) {
+        return locationFromOffsets(this.location.filename, this.source, this.location.start.offset + start, this.location.start.offset + Math.min(end, this.text.length));
+    }
+    /**
+     * Returns a nested type's parser range.
+     * @param {import("../semantic/types.js").SemanticValueType} type - Parsed type.
+     * @param {number} start - Fallback start.
+     * @param {number} end - Fallback end.
+     * @returns {import("../semantic/types.js").SourceLocation} Exact type range.
+     */
+    typeRange(type, start, end) {
+        return parserRangeFor(type, "type") ?? this.range(start, end);
+    }
+    /**
+     * Reports a bounded type-parser failure.
+     * @returns {import("../semantic/types.js").SemanticValueType} Unreachable semantic type.
+     */
+    failure() {
+        return unsupportedSyntax(this.language, this.text.slice(this.offset).includes("|") ? "arbitrary union type" : "unsupported collection type", this.remainingLocation());
+    }
+}
+/**
+ * Checks the bounded identifier alphabet.
+ * @param {string | undefined} character - Candidate source character.
+ * @returns {boolean} Whether it belongs to the bounded ASCII type grammar.
+ */
+function isTypeIdentifierCharacter(character) {
+    return (character !== undefined && character >= "A" && character <= "Z") ||
+        (character !== undefined && character >= "a" && character <= "z") ||
+        (character !== undefined && character >= "0" && character <= "9") || character == "_";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/frontends/types.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {missingType, unsupportedSyntax} from \"../diagnostic.js\"\nimport {recordTypeSubstitutions, substituteValueType, typeContainsAnyVariable} from \"../semantic/generics.js\"\nimport {locationFromOffsets} from \"../semantic/location.js\"\nimport {parserRangeFor, setParserRanges} from \"../semantic/provenance.js\"\nimport {sourceScalarType} from \"./scalars.js\"\n\n/**\n * Resolves the value presented to list iteration after canonical optional unwrap.\n * Semantic validation remains responsible for requiring the matching presence proof.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType | import(\"../semantic/types.js\").ErrorType | undefined} type - Parser-resolved operand type.\n * @returns {import(\"../semantic/types.js\").SemanticFunctionReturnType | import(\"../semantic/types.js\").ErrorType | undefined} Iterated value type.\n */\nexport function iterationOperandType(type) {\n  return type?.kind == \"OptionalType\" ? type.valueType : type\n}\n\n/**\n * Copies a resolved list element type for one parser-owned iteration binding.\n * The binding location is its own deterministic derived type anchor.\n * @param {import(\"../semantic/types.js\").SemanticValueType} type - Resolved element type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Binding token location.\n * @returns {import(\"../semantic/types.js\").SemanticValueType} Detached semantic type.\n */\nexport function iterationBindingType(type, location) {\n  if (type.kind == \"TypeReference\") {\n    const copied = {kind: /** @type {const} */ (\"TypeReference\"), name: type.name}\n\n    setParserRanges(copied, {type: location})\n    return copied\n  }\n  if (type.kind == \"TypeVariableReference\") return typeVariable(type.parameterId, location)\n  if (type.kind == \"ListType\") {\n    return listType(iterationBindingType(type.elementType, location), location, location)\n  }\n  if (type.kind == \"MapType\" || type.kind == \"OrderedMapType\") {\n    const keyType = iterationBindingType(type.keyType, location)\n\n    return type.kind == \"OrderedMapType\" ? orderedMapType(\n      /** @type {import(\"../semantic/types.js\").TypeReference} */ (keyType),\n      iterationBindingType(type.valueType, location),\n      location,\n      location,\n      location\n    ) : mapType(\n      /** @type {import(\"../semantic/types.js\").TypeReference} */ (keyType),\n      iterationBindingType(type.valueType, location),\n      location,\n      location,\n      location\n    )\n  }\n\n  if (type.kind == \"RecordType\") return recordType(type.declarationId, location,\n    type.arguments?.map((argument) => iterationBindingType(argument, location)))\n  if (type.kind == \"ReferenceType\") return referenceType(type.declarationId, location)\n  if (type.kind == \"OwnedResourceType\") return ownedResourceType(type.resourceId, location)\n  if (type.kind == \"OwnedReferenceType\") return ownedReferenceType(type.declarationId, location)\n\n  return optionalType(iterationBindingType(type.valueType, location), location, location)\n}\n\n/**\n * Builds one recursive semantic list type with parser-owned constituent ranges.\n * @param {import(\"../semantic/types.js\").SemanticValueType} elementType - Element type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Complete type-expression range.\n * @param {import(\"../semantic/types.js\").SourceLocation} elementLocation - Element type-expression range.\n * @returns {import(\"../semantic/types.js\").ListType} List type.\n */\nexport function listType(elementType, location, elementLocation) {\n  const type = {elementType, kind: /** @type {const} */ (\"ListType\")}\n\n  setParserRanges(type, {elementType: elementLocation, type: location})\n  return type\n}\n\n/**\n * Builds one recursive semantic map type with parser-owned constituent ranges.\n * @param {import(\"../semantic/types.js\").TypeReference} keyType - Key type.\n * @param {import(\"../semantic/types.js\").SemanticValueType} valueType - Value type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Complete type-expression range.\n * @param {import(\"../semantic/types.js\").SourceLocation} keyLocation - Key type-expression range.\n * @param {import(\"../semantic/types.js\").SourceLocation} valueLocation - Value type-expression range.\n * @returns {import(\"../semantic/types.js\").MapType} Map type.\n */\nexport function mapType(keyType, valueType, location, keyLocation, valueLocation) {\n  const type = {keyType, kind: /** @type {const} */ (\"MapType\"), valueType}\n\n  setParserRanges(type, {keyType: keyLocation, type: location, valueType: valueLocation})\n  return type\n}\n\n/**\n * Builds one insertion-ordered recursive semantic map type.\n * @param {import(\"../semantic/types.js\").TypeReference} keyType - Key type.\n * @param {import(\"../semantic/types.js\").SemanticValueType} valueType - Value type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Complete type range.\n * @param {import(\"../semantic/types.js\").SourceLocation} keyLocation - Key range.\n * @param {import(\"../semantic/types.js\").SourceLocation} valueLocation - Value range.\n * @returns {import(\"../semantic/types.js\").OrderedMapType} Ordered-map type.\n */\nexport function orderedMapType(keyType, valueType, location, keyLocation, valueLocation) {\n  const type = {keyType, kind: /** @type {const} */ (\"OrderedMapType\"), order: /** @type {const} */ (\"insertion\"), valueType}\n\n  setParserRanges(type, {keyType: keyLocation, type: location, valueType: valueLocation})\n  return type\n}\n\n/**\n * Promotes one parser-proven ordinary map annotation into the distinct ordered-map capability.\n * @param {import(\"../semantic/types.js\").MapType} type - Parsed homogeneous map type.\n * @param {import(\"../semantic/types.js\").SourceLocation} fallbackLocation - Owning declaration location.\n * @returns {import(\"../semantic/types.js\").OrderedMapType} Ordered counterpart with the same parser ranges.\n */\nexport function orderedMapTypeFromMap(type, fallbackLocation) {\n  const ranges = type.sourceProvenance?.ranges\n\n  return orderedMapType(\n    type.keyType,\n    type.valueType,\n    ranges?.type ?? fallbackLocation,\n    ranges?.keyType ?? fallbackLocation,\n    ranges?.valueType ?? fallbackLocation\n  )\n}\n\n/**\n * Builds one recursive semantic optional type with parser-owned constituent ranges.\n * @param {import(\"../semantic/types.js\").SemanticValueType} valueType - Present-value type.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Complete type-expression range.\n * @param {import(\"../semantic/types.js\").SourceLocation} valueLocation - Present-value type range.\n * @returns {import(\"../semantic/types.js\").OptionalType} Optional type.\n */\nexport function optionalType(valueType, location, valueLocation) {\n  const type = {kind: /** @type {const} */ (\"OptionalType\"), valueType}\n\n  setParserRanges(type, {type: location, valueType: valueLocation})\n  return type\n}\n\n/**\n * Builds one nominal semantic record type with a parser-owned name range.\n * @param {string} declarationId - Stable declaration identity.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Record type-name range.\n * @param {import(\"../semantic/types.js\").SemanticValueType[]} [arguments_] - Exact generic arguments.\n * @returns {import(\"../semantic/types.js\").RecordType} Record type.\n */\nexport function recordType(declarationId, location, arguments_) {\n  const type = {declarationId, kind: /** @type {const} */ (\"RecordType\"), ...(arguments_ ? {arguments: arguments_} : {})}\n\n  setParserRanges(type, {type: location})\n  return type\n}\n\n/**\n * Builds one nominal reference-class type with a parser-owned name range.\n * @param {string} declarationId - Stable class identity.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Class type-name range.\n * @returns {import(\"../semantic/types.js\").ReferenceType} Reference type.\n */\nexport function referenceType(declarationId, location) {\n  const type = {declarationId, kind: /** @type {const} */ (\"ReferenceType\")}\n\n  setParserRanges(type, {type: location})\n  return type\n}\n\n/**\n * Builds one compiler-owned resource type with a parser-owned name range.\n * @param {string} resourceId - Stable capability resource identity.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Resource type-name range.\n * @returns {import(\"../semantic/types.js\").OwnedResourceType} Owned resource type.\n */\nexport function ownedResourceType(resourceId, location) {\n  const type = {kind: /** @type {const} */ (\"OwnedResourceType\"), resourceId}\n  setParserRanges(type, {type: location})\n  return type\n}\n\n/**\n * Builds one linear owned-reference type with a parser-owned name range.\n * @param {string} declarationId - Stable owned class identity.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Class type-name range.\n * @returns {import(\"../semantic/types.js\").OwnedReferenceType} Owned reference type.\n */\nexport function ownedReferenceType(declarationId, location) {\n  const type = {declarationId, kind: /** @type {const} */ (\"OwnedReferenceType\")}\n  setParserRanges(type, {type: location})\n  return type\n}\n\n/**\n * Builds parser-context signatures for compiler-authorized operations without exposing a source declaration.\n * @param {readonly import(\"../semantic/types.js\").EffectCapabilityDeclaration[]} capabilities - Authorized declarations.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Synthetic parser-context anchor.\n * @returns {Map<string, {location: import(\"../semantic/types.js\").SourceLocation, nameLocation: import(\"../semantic/types.js\").SourceLocation, name: string, parameters: import(\"../semantic/types.js\").Parameter[], returnType: import(\"../semantic/types.js\").SemanticFunctionReturnType, typeParameters?: import(\"../semantic/types.js\").TypeParameter[]}>} Signatures by source spelling.\n */\nexport function capabilityFunctionSignatures(capabilities, location) {\n  return new Map(capabilities.flatMap(({operations}) => operations).map((operation) => [operation.name, {\n    location,\n    name: operation.name,\n    nameLocation: location,\n    parameters: operation.parameters.map((parameter) => ({kind: /** @type {const} */ (\"Parameter\"), location, ...parameter})),\n    returnType: operation.returnType\n  }]))\n}\n\n/**\n * Builds one declaration-scoped type-variable reference.\n * @param {string} parameterId - Stable type-parameter identity.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Exact reference range.\n * @returns {import(\"../semantic/types.js\").TypeVariableReference} Type-variable reference.\n */\nexport function typeVariable(parameterId, location) {\n  const type = {kind: /** @type {const} */ (\"TypeVariableReference\"), location, parameterId}\n\n  setParserRanges(type, {type: location})\n  return type\n}\n\n/**\n * Compares semantic type expressions while ignoring parser-owned locations.\n * @param {import(\"../semantic/types.js\").SemanticValueType} left - Left type.\n * @param {import(\"../semantic/types.js\").SemanticValueType} right - Right type.\n * @returns {boolean} Whether the semantic structures are identical.\n */\nexport function sameValueType(left, right) {\n  if (left.kind != right.kind) return false\n  if (left.kind == \"TypeReference\" && right.kind == \"TypeReference\") return left.name == right.name\n  if (left.kind == \"TypeVariableReference\" && right.kind == \"TypeVariableReference\") return left.parameterId == right.parameterId\n  if (left.kind == \"ListType\" && right.kind == \"ListType\") return sameValueType(left.elementType, right.elementType)\n  if (left.kind == \"OptionalType\" && right.kind == \"OptionalType\") return sameValueType(left.valueType, right.valueType)\n  if ((left.kind == \"MapType\" && right.kind == \"MapType\") ||\n    (left.kind == \"OrderedMapType\" && right.kind == \"OrderedMapType\")) {\n    return sameValueType(left.keyType, right.keyType) && sameValueType(left.valueType, right.valueType)\n  }\n  if (left.kind == \"RecordType\" && right.kind == \"RecordType\") {\n    const leftArguments = left.arguments ?? []\n    const rightArguments = right.arguments ?? []\n\n    return left.declarationId == right.declarationId && leftArguments.length == rightArguments.length &&\n      leftArguments.every((argument, index) => sameValueType(argument, rightArguments[index]))\n  }\n  if (left.kind == \"ReferenceType\" && right.kind == \"ReferenceType\") return left.declarationId == right.declarationId\n  if (left.kind == \"OwnedResourceType\" && right.kind == \"OwnedResourceType\") return left.resourceId == right.resourceId\n  if (left.kind == \"OwnedReferenceType\" && right.kind == \"OwnedReferenceType\") return left.declarationId == right.declarationId\n\n  return false\n}\n\n/**\n * Resolves one generic record field against a complete application for parser\n * contextual conversion. Invalid/raw applications remain unchanged so the\n * semantic validator owns their stable diagnostic.\n * @param {import(\"../semantic/types.js\").RecordDeclaration} declaration - Resolved record declaration.\n * @param {import(\"../semantic/types.js\").SemanticValueType[] | undefined} arguments_ - Parsed application arguments.\n * @param {number} index - Constructor field index.\n * @returns {import(\"../semantic/types.js\").SemanticValueType | undefined} Closed field type when available.\n */\nexport function instantiatedRecordFieldType(declaration, arguments_, index) {\n  const field = declaration.fields[index]\n  const parameters = declaration.typeParameters ?? []\n\n  if (!field || parameters.length == 0 || !arguments_ || arguments_.length != parameters.length) return field?.type\n  const application = /** @type {import(\"../semantic/types.js\").RecordType} */ ({\n    arguments: arguments_,\n    declarationId: /** @type {string} */ (declaration.id),\n    kind: \"RecordType\"\n  })\n\n  return substituteValueType(field.type, recordTypeSubstitutions(application, declaration))\n}\n\n/**\n * Applies parser-known generic-call argument evidence to its declared return.\n * An unresolved variable remains open: this is conservative context discovery\n * only, while semantic validation still performs authoritative inference.\n * @param {{parameters: import(\"../semantic/types.js\").Parameter[], returnType: import(\"../semantic/types.js\").SemanticFunctionReturnType}} signature - Declared signature.\n * @param {(import(\"../semantic/types.js\").SemanticFunctionReturnType | import(\"../semantic/types.js\").ErrorType | undefined)[]} arguments_ - Parser-known argument types.\n * @returns {import(\"../semantic/types.js\").SemanticFunctionReturnType | undefined} Known result with available substitutions.\n */\nexport function knownCallReturnType(signature, arguments_) {\n  if (signature.returnType.kind == \"TypeReference\" && signature.returnType.name == \"void\") return signature.returnType\n  const substitutions = knownCallSubstitutions(signature, arguments_)\n\n  return substitutions ? substituteValueType(signature.returnType, substitutions) : undefined\n}\n\n/**\n * Applies conservative parser-known call evidence to every parameter context.\n * Unresolved variables remain open for the language frontend to handle only in\n * a matching lexical type-parameter scope.\n * @param {{parameters: import(\"../semantic/types.js\").Parameter[]}} signature - Declared signature.\n * @param {(import(\"../semantic/types.js\").SemanticFunctionReturnType | import(\"../semantic/types.js\").ErrorType | undefined)[]} arguments_ - Parser-known argument types.\n * @returns {import(\"../semantic/types.js\").SemanticValueType[] | undefined} Substituted parameter contexts.\n */\nexport function knownCallParameterTypes(signature, arguments_) {\n  const substitutions = knownCallSubstitutions(signature, arguments_)\n\n  return substitutions\n    ? signature.parameters.map((parameter) => substituteValueType(parameter.type, substitutions))\n    : undefined\n}\n\n/**\n * Collects conservative parser-known substitutions once for call context and\n * result classification. Semantic validation remains authoritative.\n * @param {{parameters: import(\"../semantic/types.js\").Parameter[]}} signature - Declared signature.\n * @param {(import(\"../semantic/types.js\").SemanticFunctionReturnType | import(\"../semantic/types.js\").ErrorType | undefined)[]} arguments_ - Parser-known argument types.\n * @returns {Map<string, import(\"../semantic/types.js\").SemanticValueType> | undefined} Compatible substitutions.\n */\nfunction knownCallSubstitutions(signature, arguments_) {\n  /** @type {Map<string, import(\"../semantic/types.js\").SemanticValueType>} */\n  const substitutions = new Map()\n\n  for (let index = 0; index < signature.parameters.length; index += 1) {\n    const actual = arguments_[index]\n\n    if (actual && actual.kind != \"ErrorType\" && !(actual.kind == \"TypeReference\" && actual.name == \"void\") &&\n      !collectKnownSubstitutions(signature.parameters[index].type,\n        /** @type {import(\"../semantic/types.js\").SemanticValueType} */ (actual), substitutions)) {\n      return undefined\n    }\n  }\n\n  return substitutions\n}\n\n/**\n * Preserves an optional binding when a generic formal needs its wrapped type as\n * argument-only inference evidence. The semantic validator remains the sole\n * authority for unification and presence-proof checks.\n * @param {{parameters: import(\"../semantic/types.js\").Parameter[], typeParameters?: import(\"../semantic/types.js\").TypeParameter[]} | undefined} signature - Known direct-call signature.\n * @param {number} index - Argument index.\n * @returns {boolean} Whether frontend conversion must retain optionality.\n */\nexport function preservesGenericOptionalEvidence(signature, index) {\n  const formal = signature?.parameters[index]?.type\n\n  return Boolean(signature?.typeParameters?.length && formal && typeContainsAnyVariable(formal))\n}\n\n/**\n * Conservatively collects structurally matching parser-known substitutions.\n * @param {import(\"../semantic/types.js\").SemanticValueType} formal - Open formal type.\n * @param {import(\"../semantic/types.js\").SemanticValueType} actual - Known argument type.\n * @param {Map<string, import(\"../semantic/types.js\").SemanticValueType>} substitutions - Collected substitutions.\n * @returns {boolean} Whether the known structures remain compatible.\n */\nfunction collectKnownSubstitutions(formal, actual, substitutions) {\n  if (formal.kind == \"TypeVariableReference\") {\n    const prior = substitutions.get(formal.parameterId)\n\n    if (prior) return sameValueType(prior, actual)\n    substitutions.set(formal.parameterId, actual)\n    return true\n  }\n  if (formal.kind == \"OptionalType\") {\n    return collectKnownSubstitutions(formal.valueType,\n      actual.kind == \"OptionalType\" ? actual.valueType : actual, substitutions)\n  }\n  if (formal.kind != actual.kind) return false\n  if (formal.kind == \"TypeReference\") return sameValueType(formal, actual)\n  if (formal.kind == \"ReferenceType\" && actual.kind == \"ReferenceType\") return sameValueType(formal, actual)\n  if (formal.kind == \"OwnedResourceType\" && actual.kind == \"OwnedResourceType\") return sameValueType(formal, actual)\n  if (formal.kind == \"OwnedReferenceType\" && actual.kind == \"OwnedReferenceType\") return sameValueType(formal, actual)\n  if (formal.kind == \"RecordType\" && actual.kind == \"RecordType\") {\n    if (formal.declarationId != actual.declarationId || (formal.arguments?.length ?? 0) != (actual.arguments?.length ?? 0)) return false\n\n    return (formal.arguments ?? []).every((argument, index) => collectKnownSubstitutions(\n      argument, /** @type {import(\"../semantic/types.js\").SemanticValueType} */ (actual.arguments?.[index]), substitutions\n    ))\n  }\n  if (formal.kind == \"ListType\" && actual.kind == \"ListType\") {\n    return collectKnownSubstitutions(formal.elementType, actual.elementType, substitutions)\n  }\n  if ((formal.kind == \"MapType\" && actual.kind == \"MapType\") ||\n    (formal.kind == \"OrderedMapType\" && actual.kind == \"OrderedMapType\")) {\n    return collectKnownSubstitutions(formal.keyType, actual.keyType, substitutions) &&\n      collectKnownSubstitutions(formal.valueType, actual.valueType, substitutions)\n  }\n\n  return false\n}\n\n/**\n * Converts one parser/comment-parser-owned bounded type expression. This parser\n * recognizes only Task 006's concrete scalar/list/map grammar; it never scans\n * source outside the already-associated type token.\n * @param {object} input - Documented type input.\n * @param {\"javascript\" | \"php\" | \"ruby\"} input.language - Comment profile.\n * @param {import(\"../semantic/types.js\").SourceLocation} input.location - Exact type token range.\n * @param {import(\"../semantic/types.js\").SourceLocation} input.ownerLocation - Owning declaration range.\n * @param {Map<string, import(\"../semantic/types.js\").RecordDeclaration | import(\"../semantic/types.js\").ClassDeclaration | import(\"../semantic/types.js\").EffectResourceDeclaration>} [input.records] - Available nominal declarations by source name.\n * @param {Map<string, import(\"../semantic/types.js\").TypeParameter>} [input.typeParameters] - Declaration-scoped parameters by name.\n * @param {string} input.source - Complete parser input for exact subranges.\n * @param {string | undefined} input.sourceType - Exact comment-parser/Prism-owned type token.\n * @param {string} input.subject - Diagnostic subject.\n * @returns {import(\"../semantic/types.js\").SemanticValueType} Semantic value type.\n */\nexport function documentedValueType({language, location, ownerLocation, records = new Map(), source, sourceType, subject, typeParameters = new Map()}) {\n  if (!sourceType) return missingType(language, subject, ownerLocation)\n\n  if (language == \"php\" && sourceType.startsWith(\"?\")) {\n    const valueText = sourceType.slice(1)\n    const valueLocation = locationFromOffsets(\n      location.filename,\n      source,\n      location.start.offset + 1,\n      location.end.offset\n    )\n\n    return optionalType(\n      documentedValueType({language, location: valueLocation, ownerLocation, records, source, sourceType: valueText, subject, typeParameters}),\n      location,\n      valueLocation\n    )\n  }\n  if (language == \"php\" && sourceType.includes(\"|\")) {\n    return unsupportedSyntax(language, \"arbitrary union type\", location)\n  }\n  if (language == \"javascript\" && sourceType.endsWith(\"|null\") && sourceType.indexOf(\"|\") == sourceType.length - \"|null\".length) {\n    const valueText = sourceType.slice(0, -\"|null\".length)\n    const valueLocation = locationFromOffsets(\n      location.filename,\n      source,\n      location.start.offset,\n      location.start.offset + valueText.length\n    )\n\n    return optionalType(\n      documentedValueType({language, location: valueLocation, ownerLocation, records, source, sourceType: valueText, subject, typeParameters}),\n      location,\n      valueLocation\n    )\n  }\n  if (language == \"javascript\" && sourceType.includes(\"|\") &&\n    !sourceType.startsWith(\"ReadonlyArray\") && !sourceType.startsWith(\"ReadonlyMap\") &&\n    !records.has(sourceType.slice(0, sourceType.indexOf(\"<\") < 0 ? sourceType.length : sourceType.indexOf(\"<\")))) {\n    return unsupportedSyntax(language, \"arbitrary union type\", location)\n  }\n\n  const scalar = sourceScalarType(language, sourceType, location)\n\n  if (scalar) return scalar\n  const unwrappedName = language == \"ruby\" && sourceType.startsWith(\"[\") && sourceType.endsWith(\"]\")\n    ? sourceType.slice(1, -1)\n    : sourceType\n  const directRecord = records.get(unwrappedName)\n\n  if (directRecord?.id) return directRecord.kind == \"ClassDeclaration\"\n    ? referenceType(directRecord.id, location)\n    : directRecord.kind == \"EffectResourceDeclaration\"\n      ? ownedResourceType(directRecord.id, location)\n      : recordType(directRecord.id, location)\n  const directTypeParameter = typeParameters.get(unwrappedName)\n\n  if (directTypeParameter?.id) return typeVariable(directTypeParameter.id, location)\n  const collectionPrefixes = language == \"ruby\" ? [\"[Array\", \"[Hash\", \"[Integer?\", \"[bool?\", \"[String?\"] :\n    language == \"php\" ? [\"list\", \"array\"] : [\"ReadonlyArray\", \"ReadonlyMap\"]\n  const optionalRecord = language == \"ruby\" && sourceType.startsWith(\"[\") && sourceType.endsWith(\"?]\") &&\n    records.has(sourceType.slice(1, -2))\n\n  const possibleName = unwrappedName.slice(0, unwrappedName.search(/[<[?]/u) < 0 ? unwrappedName.length : unwrappedName.search(/[<[?]/u))\n\n  if (!optionalRecord && !collectionPrefixes.some((prefix) => sourceType.startsWith(prefix)) &&\n    !records.has(possibleName) && !typeParameters.has(possibleName)) {\n    return missingType(language, subject, ownerLocation)\n  }\n\n  const parser = new DocumentedTypeParser(language, sourceType, location, source, records, typeParameters)\n  const type = parser.parse()\n\n  if (!parser.atEnd()) return unsupportedSyntax(language, \"unsupported collection type\", parser.remainingLocation())\n\n  return type\n}\n\nclass DocumentedTypeParser {\n  /**\n   * Creates a bounded parser over one parser/comment-parser-owned token.\n   * @param {\"javascript\" | \"php\" | \"ruby\"} language - Exact comment profile.\n   * @param {string} text - Parser-owned type text.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Whole token location.\n   * @param {string} source - Complete source.\n   * @param {Map<string, import(\"../semantic/types.js\").RecordDeclaration | import(\"../semantic/types.js\").ClassDeclaration | import(\"../semantic/types.js\").EffectResourceDeclaration>} records - Available nominal declarations.\n   * @param {Map<string, import(\"../semantic/types.js\").TypeParameter>} typeParameters - Declaration-scoped parameters.\n   */\n  constructor(language, text, location, source, records, typeParameters) {\n    this.language = language\n    this.text = text\n    this.location = location\n    this.source = source\n    this.records = records\n    this.typeParameters = typeParameters\n    this.offset = 0\n  }\n\n  /**\n   * Parses the complete documented type.\n   * @returns {import(\"../semantic/types.js\").SemanticValueType} Parsed type.\n   */\n  parse() {\n    this.skipWhitespace()\n    if (this.language == \"ruby\") {\n      if (!this.consume(\"[\")) return this.failure()\n      const type = this.parseNamedType()\n\n      this.skipWhitespace()\n      if (!this.consume(\"]\")) return this.failure()\n      this.skipWhitespace()\n      return type\n    }\n\n    const type = this.parseNamedType()\n\n    this.skipWhitespace()\n    return type\n  }\n\n  /**\n   * Parses one nested type expression.\n   * @returns {import(\"../semantic/types.js\").SemanticValueType} Parsed nested type.\n   */\n  parseNamedType() {\n    this.skipWhitespace()\n    const start = this.offset\n\n    if (this.language == \"php\" && this.consume(\"?\")) {\n      const valueStart = this.offset\n      const valueType = this.parseNamedType()\n\n      return optionalType(\n        valueType,\n        this.range(start, this.offset),\n        this.typeRange(valueType, valueStart, this.offset)\n      )\n    }\n\n    while (isTypeIdentifierCharacter(this.text[this.offset]) || this.language == \"ruby\" &&\n      this.text[this.offset] == \":\" && this.text[this.offset + 1] == \":\" &&\n      isTypeIdentifierCharacter(this.text[this.offset + 2])) {\n      this.offset += this.text[this.offset] == \":\" ? 2 : 1\n    }\n    const nameEnd = this.offset\n    const name = this.text.slice(start, nameEnd)\n\n    if (!name) return this.failure()\n    const scalarSpelling = this.language == \"ruby\" ? `[${name}]` : name\n    const scalar = sourceScalarType(this.language, scalarSpelling, this.range(start, nameEnd))\n\n    this.skipWhitespace()\n    if (scalar && this.text[this.offset] != \"<\" && this.text[this.offset] != \"[\") {\n      if (this.language == \"ruby\" && this.consume(\"?\")) {\n        return optionalType(scalar, this.range(start, this.offset), this.typeRange(scalar, start, nameEnd))\n      }\n      if (this.language == \"javascript\" && this.consume(\"|null\")) {\n        return optionalType(scalar, this.range(start, this.offset), this.typeRange(scalar, start, nameEnd))\n      }\n\n      return scalar\n    }\n    const record = this.records.get(name)\n    const typeParameter = this.typeParameters.get(name)\n\n    if (typeParameter?.id && this.text[this.offset] != \"<\" && this.text[this.offset] != \"[\") {\n      const type = typeVariable(typeParameter.id, this.range(start, nameEnd))\n\n      if (this.language == \"ruby\" && this.consume(\"?\")) {\n        return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd))\n      }\n      if (this.language == \"javascript\" && this.consume(\"|null\")) {\n        return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd))\n      }\n\n      return type\n    }\n\n    if (record?.id && this.text[this.offset] != \"<\" && this.text[this.offset] != \"[\") {\n      const type = record.kind == \"ClassDeclaration\"\n        ? referenceType(record.id, this.range(start, nameEnd))\n        : record.kind == \"EffectResourceDeclaration\"\n          ? ownedResourceType(record.id, this.range(start, nameEnd))\n          : recordType(record.id, this.range(start, nameEnd))\n\n      if (this.language == \"ruby\" && this.consume(\"?\")) {\n        return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd))\n      }\n      if (this.language == \"javascript\" && this.consume(\"|null\")) {\n        return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, nameEnd))\n      }\n\n      return type\n    }\n\n    const listName = this.language == \"ruby\" ? \"Array\" : this.language == \"php\" ? \"list\" : \"ReadonlyArray\"\n    const mapName = this.language == \"ruby\" ? \"Hash\" : this.language == \"php\" ? \"array\" : \"ReadonlyMap\"\n    const opening = this.language == \"ruby\" ? \"[\" : \"<\"\n    const closing = this.language == \"ruby\" ? \"]\" : \">\"\n\n    if (name != listName && name != mapName && !record || !this.consume(opening)) return this.failure()\n    const first = this.parseNamedType()\n    const firstEnd = this.offset\n\n    this.skipWhitespace()\n    if (record?.id) {\n      const arguments_ = [first]\n\n      while (this.consume(\",\")) arguments_.push(this.parseNamedType())\n      if (!this.consume(closing)) return this.failure()\n\n      const applicationEnd = this.offset\n      const type = recordType(record.id, this.range(start, nameEnd), arguments_)\n\n      if (this.language == \"ruby\" && this.consume(\"?\")) {\n        return optionalType(type, this.range(start, this.offset), this.range(start, applicationEnd))\n      }\n      if (this.language == \"javascript\" && this.consume(\"|null\")) {\n        return optionalType(type, this.range(start, this.offset), this.range(start, applicationEnd))\n      }\n\n      return type\n    }\n    if (name == listName) {\n      if (!this.consume(closing)) return this.failure()\n      const type = listType(first, this.range(start, this.offset), this.typeRange(first, start, firstEnd))\n\n      if (this.language == \"ruby\" && this.consume(\"?\")) {\n        return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, firstEnd))\n      }\n      if (this.language == \"javascript\" && this.consume(\"|null\")) {\n        return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, firstEnd))\n      }\n\n      return type\n    }\n    if (!this.consume(\",\")) return this.failure()\n    const second = this.parseNamedType()\n    const secondEnd = this.offset\n\n    this.skipWhitespace()\n    if (!this.consume(closing)) return this.failure()\n    if (first.kind != \"TypeReference\") {\n      return unsupportedSyntax(this.language, \"map key type other than string\", this.typeRange(first, start, firstEnd))\n    }\n\n    const type = mapType(\n      first,\n      second,\n      this.range(start, this.offset),\n      this.typeRange(first, start, firstEnd),\n      this.typeRange(second, firstEnd, secondEnd)\n    )\n\n    if (this.language == \"ruby\" && this.consume(\"?\")) {\n      return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, secondEnd))\n    }\n    if (this.language == \"javascript\" && this.consume(\"|null\")) {\n      return optionalType(type, this.range(start, this.offset), this.typeRange(type, start, secondEnd))\n    }\n\n    return type\n  }\n\n  /**\n   * Reports whether the complete token was consumed.\n   * @returns {boolean} Whether the whole token was consumed.\n   */\n  atEnd() {\n    return this.offset == this.text.length\n  }\n\n  /**\n   * Locates the remaining invalid suffix.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Remaining invalid range.\n   */\n  remainingLocation() {\n    return this.range(this.offset, Math.max(this.offset + 1, this.text.length))\n  }\n\n  /**\n   * Consumes one exact punctuation token.\n   * @param {string} token - Exact punctuation.\n   * @returns {boolean} Whether consumed.\n   */\n  consume(token) {\n    this.skipWhitespace()\n    if (!this.text.startsWith(token, this.offset)) return false\n    this.offset += token.length\n    return true\n  }\n\n  /**\n   * Skips bounded type-expression whitespace.\n   * @returns {void}\n   */\n  skipWhitespace() {\n    while ([\" \", \"\\t\", \"\\r\", \"\\n\"].includes(this.text[this.offset])) this.offset++\n  }\n\n  /**\n   * Converts relative offsets into parser-owned source coordinates.\n   * @param {number} start - Relative start.\n   * @param {number} end - Relative end.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Exact source range.\n   */\n  range(start, end) {\n    return locationFromOffsets(\n      this.location.filename,\n      this.source,\n      this.location.start.offset + start,\n      this.location.start.offset + Math.min(end, this.text.length)\n    )\n  }\n\n  /**\n   * Returns a nested type's parser range.\n   * @param {import(\"../semantic/types.js\").SemanticValueType} type - Parsed type.\n   * @param {number} start - Fallback start.\n   * @param {number} end - Fallback end.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Exact type range.\n   */\n  typeRange(type, start, end) {\n    return parserRangeFor(type, \"type\") ?? this.range(start, end)\n  }\n\n  /**\n   * Reports a bounded type-parser failure.\n   * @returns {import(\"../semantic/types.js\").SemanticValueType} Unreachable semantic type.\n   */\n  failure() {\n    return unsupportedSyntax(\n      this.language,\n      this.text.slice(this.offset).includes(\"|\") ? \"arbitrary union type\" : \"unsupported collection type\",\n      this.remainingLocation()\n    )\n  }\n}\n\n/**\n * Checks the bounded identifier alphabet.\n * @param {string | undefined} character - Candidate source character.\n * @returns {boolean} Whether it belongs to the bounded ASCII type grammar.\n */\nfunction isTypeIdentifierCharacter(character) {\n  return (character !== undefined && character >= \"A\" && character <= \"Z\") ||\n    (character !== undefined && character >= \"a\" && character <= \"z\") ||\n    (character !== undefined && character >= \"0\" && character <= \"9\") || character == \"_\"\n}\n"]}