semantifold 0.13.0 → 0.15.0

package/src/backends/shared.js

@@ -27,7 +27,7 @@ const binaryOperationSyntax = Object.freeze({
   StringEqual: Object.freeze({default: "==", strict: "==="}),
   StringNotEqual: Object.freeze({default: "!=", strict: "!=="})
 })
-const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "c", "dart", "zig"])
+const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "c", "dart", "zig", "python"])
 const task006Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task007Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task008Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
@@ -38,6 +38,7 @@ const task014Languages = new Set(["php", "ruby", "javascript", "typescript", "ja
 const task032Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task033Languages = new Set(["php", "ruby", "javascript", "typescript", "java"])
 const task048ConditionalLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"])
+const boundedSubtypingLanguages = new Set(["php"])
 const javaReferenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait"])
 const javascriptReferenceMethodHooks = new Set([
   "__defineGetter__", "__defineSetter__", "__lookupGetter__", "__lookupSetter__", "__proto__", "constructor",
@@ -56,7 +57,7 @@ const javaObjectInstanceMethodSignatures = new Set([
  * Checks the intentionally narrow backend contract.
  * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
  * @param {import("../semantic/types.js").BackendLanguage} language - Backend language or binary target.
- * @param {{externalDeclarationIds?: Set<string>, program?: boolean, visibleFunctions?: Map<string, import("../semantic/types.js").FunctionDeclaration>, visibleRecords?: Map<string, import("../semantic/types.js").RecordDeclaration>, visibleClasses?: Map<string, import("../semantic/types.js").ClassDeclaration>, visibleErrors?: Map<string, import("../semantic/types.js").ErrorDeclaration>, visibleCallEffects?: Map<string, Set<string>>}} [options] - Resolved program validation context.
+ * @param {{externalDeclarationIds?: Set<string>, program?: boolean, visibleFunctions?: Map<string, import("../semantic/types.js").FunctionDeclaration>, visibleRecords?: Map<string, import("../semantic/types.js").RecordDeclaration>, visibleClasses?: Map<string, import("../semantic/types.js").ClassDeclaration>, visibleInterfaces?: Map<string, import("../semantic/types.js").InterfaceDeclaration>, visibleErrors?: Map<string, import("../semantic/types.js").ErrorDeclaration>, visibleCallEffects?: Map<string, Set<string>>}} [options] - Resolved program validation context.
  * @returns {void}
  */
 export function validateBackendModule(module, language, options = {}) {
@@ -89,11 +90,19 @@ export function validateBackendModule(module, language, options = {}) {
   if (classes.length > 0 && !task033Languages.has(language)) {
     unsupportedCapability(language, "Task 033 reference classes, methods, and constructors", classes[0]?.location ?? module.location)
   }
+  const declaredInterfaces = module.interfaces
+  const interfaces = declaredInterfaces === undefined ? [] : declaredInterfaces
+
+  if (!Array.isArray(interfaces)) unsupportedCapability(language, "missing or invalid interface declarations", module.location)
+  if (interfaces.length > 0 && !boundedSubtypingLanguages.has(language)) {
+    unsupportedCapability(language, "Task 048 bounded subtyping interfaces", interfaces[0]?.location ?? module.location)
+  }
   if (!task011Languages.has(language)) rejectTypedErrors(module, language)
   if (!task032Languages.has(language)) rejectConditionControlledLoops(module, language)
   if (!task014Languages.has(language)) rejectOrderedMapCapability(module, language)
   validateRecordTargets(records, module.functions, language, module.location)
-  validateReferenceClassTargets(classes, records, errors, module.functions, language, module.location)
+  validateInterfaceTargets(interfaces, records, errors, module.functions, language, module.location)
+  validateReferenceClassTargets(classes, records, errors, module.functions, interfaces, language, module.location)
   if (!task008Languages.has(language)) rejectIterationStatements(module, language)
   if (!task007Languages.has(language)) rejectOptionalTypes(module, language)
   if (!task006Languages.has(language)) rejectCollectionTypes(module, language)
@@ -163,6 +172,7 @@ export function validateBackendModule(module, language, options = {}) {
     classes: options.visibleClasses,
     errors: options.visibleErrors,
     functions: options.visibleFunctions,
+    interfaces: options.visibleInterfaces,
     records: options.visibleRecords
   })
 }
@@ -382,7 +392,99 @@ function validateRecordTargets(records, functions, language, moduleLocation) {
  * @param {import("../semantic/types.js").SourceLocation | undefined} moduleLocation - Fallback location.
  * @returns {void}
  */
-function validateReferenceClassTargets(classes, records, errors, functions, language, moduleLocation) {
+/**
+ * Validates the exact target-visible shape of every interface and its override contracts before output allocation.
+ * @param {import("../semantic/types.js").InterfaceDeclaration[]} interfaces - Candidate interfaces.
+ * @param {import("../semantic/types.js").RecordDeclaration[]} records - Existing records.
+ * @param {import("../semantic/types.js").ErrorDeclaration[]} errors - Existing typed errors.
+ * @param {import("../semantic/types.js").FunctionDeclaration[]} functions - Existing functions.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} moduleLocation - Fallback location.
+ * @returns {void}
+ */
+function validateInterfaceTargets(interfaces, records, errors, functions, language, moduleLocation) {
+  if (interfaces.length == 0) return
+  const byId = new Map(interfaces.map((declaration) => [declaration.id, declaration]))
+  const targetNames = new Set()
+
+  for (const declaration of [...records, ...errors, ...functions]) {
+    if (!declaration || typeof declaration != "object" || Array.isArray(declaration)) continue
+    const name = Reflect.get(declaration, "name")
+
+    if (typeof name == "string") targetNames.add(language == "php" ? name.toLowerCase() : name)
+  }
+
+  for (let interfaceIndex = 0; interfaceIndex < interfaces.length; interfaceIndex += 1) {
+    const declaration = interfaces[interfaceIndex]
+    const location = diagnosticLocation(declaration?.location, moduleLocation)
+    const keys = declaration && typeof declaration == "object" && !Array.isArray(declaration)
+      ? Object.keys(declaration).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+    if (!declaration || declaration.kind != "InterfaceDeclaration" ||
+      !["extends,id,kind,location,methods,name", "id,kind,location,methods,name"].includes(keys) ||
+      !isDenseArray(declaration.methods) ||
+      !new RegExp(`^(?:[a-z][a-z0-9._-]*#)?interface:${interfaceIndex}$`, "u").test(String(declaration.id))) {
+      unsupportedCapability(language, "missing or invalid interface declaration", location)
+    }
+    const declarationLocation = requireSemanticLocation(declaration.location, language, "interface declaration location", location)
+
+    validateTargetTypeIdentifier(language, declaration.name, declarationLocation)
+    const targetName = language == "php" ? declaration.name.toLowerCase() : declaration.name
+
+    if (targetNames.has(targetName)) unsupportedCapability(language, `interface collision '${declaration.name}'`, declarationLocation)
+    targetNames.add(targetName)
+    const methodNames = new Set()
+
+    for (let methodIndex = 0; methodIndex < declaration.methods.length; methodIndex += 1) {
+      const method = declaration.methods[methodIndex]
+      const methodLocation = diagnosticLocation(method?.location, declarationLocation)
+      const methodKeys = method && typeof method == "object" && !Array.isArray(method)
+        ? Object.keys(method).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!method || method.kind != "InterfaceMethodDeclaration" || methodKeys != "id,kind,location,name,parameters,returnType" ||
+        method.id != `${declaration.id}:method:${methodIndex}` || !isDenseArray(method.parameters)) {
+        unsupportedCapability(language, "missing or invalid interface method declaration", methodLocation)
+      }
+      const exactMethodLocation = requireSemanticLocation(method.location, language, "interface method declaration location", declarationLocation)
+
+      validateTargetIdentifier(language, method.name, "interface method", exactMethodLocation)
+      const normalized = language == "php" ? method.name.toLowerCase() : method.name
+
+      if (methodNames.has(normalized)) unsupportedCapability(language, `duplicate interface method '${method.name}'`, exactMethodLocation)
+      methodNames.add(normalized)
+      validateReferenceClassParameters(method.parameters, "interface method", language, exactMethodLocation)
+    }
+    const parents = declaration.extends ?? []
+
+    for (const parent of parents) {
+      const parentKeys = parent && typeof parent == "object" && !Array.isArray(parent)
+        ? Object.keys(parent).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!parent || parent.kind != "InterfaceType" || parentKeys != "declarationId,kind" ||
+        !byId.has(parent.declarationId)) {
+        unsupportedCapability(language, "missing or invalid interface parent reference", declarationLocation)
+      }
+    }
+  }
+  for (const declaration of interfaces) {
+    for (const parent of declaration.extends ?? []) {
+      if (parent.declarationId == declaration.id) unsupportedCapability(language, "interface extends itself", declaration.location)
+    }
+  }
+}
+
+/**
+ * Validates the exact target-visible shape of every reference class before output allocation.
+ * @param {import("../semantic/types.js").ClassDeclaration[]} classes - Candidate classes.
+ * @param {import("../semantic/types.js").RecordDeclaration[]} records - Existing records.
+ * @param {import("../semantic/types.js").ErrorDeclaration[]} errors - Existing typed errors.
+ * @param {import("../semantic/types.js").FunctionDeclaration[]} functions - Existing functions.
+ * @param {import("../semantic/types.js").InterfaceDeclaration[]} interfaces - Existing interfaces.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} moduleLocation - Fallback location.
+ * @returns {void}
+ */
+function validateReferenceClassTargets(classes, records, errors, functions, interfaces, language, moduleLocation) {
   const targetNames = new Set()
 
   for (const declaration of [...records, ...errors, ...functions]) {
@@ -400,7 +502,8 @@ function validateReferenceClassTargets(classes, records, errors, functions, lang
       ? Object.keys(declaration).filter((key) => key != "sourceProvenance").sort().join(",") : ""
 
     if (!declaration || declaration.kind != "ClassDeclaration" ||
-      !["constructor,fields,id,kind,location,methods,name", "constructor,fields,id,kind,location,methods,name,ownership"].includes(keys) ||
+      !["constructor,fields,id,implements,kind,location,methods,name", "constructor,fields,id,implements,kind,location,methods,name,ownership",
+        "constructor,fields,id,kind,location,methods,name", "constructor,fields,id,kind,location,methods,name,ownership"].includes(keys) ||
       !isDenseArray(declaration.fields) || declaration.fields.length == 0 || !isDenseArray(declaration.methods) ||
       !new RegExp(`^(?:[a-z][a-z0-9._-]*#)?class:${classIndex}$`, "u").test(String(declaration.id))) {
       unsupportedCapability(language, "missing or invalid reference class declaration", location)
@@ -459,7 +562,9 @@ function validateReferenceClassTargets(classes, records, errors, functions, lang
         ? Object.keys(method).filter((key) => key != "sourceProvenance").sort().join(",") : ""
 
       if (!method || method.kind != "MethodDeclaration" ||
-        !["body,id,kind,location,name,parameters,returnType",
+        !["body,id,implements,kind,location,name,parameters,returnType",
+          "body,effects,failureIds,id,implements,kind,location,name,parameters,returnType",
+          "body,id,kind,location,name,parameters,returnType",
           "body,effects,failureIds,id,kind,location,name,parameters,returnType"].includes(methodKeys) ||
         method.id != `${declaration.id}:method:${methodIndex}` || !isDenseArray(method.parameters)) {
         unsupportedCapability(language, "missing or invalid method declaration", methodLocation)
@@ -492,13 +597,104 @@ function validateReferenceClassTargets(classes, records, errors, functions, lang
       methodNames.add(normalized)
       validateReferenceClassParameters(method.parameters, "method", language, exactMethodLocation)
     }
+    const implemented = declaration.implements ?? []
+
+    for (const reference of implemented) {
+      const referenceKeys = reference && typeof reference == "object" && !Array.isArray(reference)
+        ? Object.keys(reference).filter((key) => key != "sourceProvenance").sort().join(",") : ""
+
+      if (!reference || reference.kind != "InterfaceType" || referenceKeys != "declarationId,kind" ||
+        !interfaces.some((candidate) => candidate.id == reference.declarationId)) {
+        unsupportedCapability(language, "missing or invalid implemented interface reference", location)
+      }
+    }
+    const satisfied = new Set()
+
+    for (const reference of implemented) {
+      for (const member of flattenedTargetInterfaceMembers(reference.declarationId, interfaces, language, location)) {
+        const method = declaration.methods.find((candidate) => candidate.name == member.name)
+
+        if (!method) unsupportedCapability(language, `interface method '${member.name}' is not implemented`, location)
+        if (satisfied.has(member.name)) unsupportedCapability(language, `duplicate interface implementation '${member.name}'`, location)
+        if (method.parameters.length != member.parameters.length ||
+          method.parameters.some((parameter, index) => !sameTargetType(parameter.type, member.parameters[index].type))) {
+          unsupportedCapability(language, `interface method signature mismatch '${member.name}'`, location)
+        }
+        if (!sameTargetType(method.returnType, member.returnType)) {
+          unsupportedCapability(language, `interface method return mismatch '${member.name}'`, location)
+        }
+        satisfied.add(member.name)
+      }
+    }
+  }
+}
+
+/**
+ * Flattens one target-validated interface signature set in declaration order.
+ * @param {string} interfaceId - Interface identity.
+ * @param {import("../semantic/types.js").InterfaceDeclaration[]} interfaces - Interfaces in declaration order.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Diagnostic location.
+ * @param {Set<string>} [active] - Active extends path.
+ * @returns {import("../semantic/types.js").InterfaceMethodDeclaration[]} Flattened members.
+ */
+function flattenedTargetInterfaceMembers(interfaceId, interfaces, language, location, active = new Set()) {
+  const declaration = interfaces.find((candidate) => candidate.id == interfaceId)
+
+  if (!declaration) unsupportedCapability(language, "missing or invalid implemented interface reference", location)
+  if (active.has(interfaceId)) unsupportedCapability(language, "interface extends itself", declaration.location)
+  active.add(interfaceId)
+  /** @type {import("../semantic/types.js").InterfaceMethodDeclaration[]} */
+  const members = []
+
+  for (const parent of declaration.extends ?? []) {
+    for (const member of flattenedTargetInterfaceMembers(parent.declarationId, interfaces, language, location, active)) {
+      if (!members.some((candidate) => candidate.name == member.name)) members.push(member)
+    }
+  }
+  for (const method of declaration.methods) {
+    if (!members.some((candidate) => candidate.name == method.name)) members.push(method)
   }
+  active.delete(interfaceId)
+
+  return members
+}
+
+/**
+ * Compares two backend-validated semantic types structurally.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} left - First type.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} right - Second type.
+ * @returns {boolean} Whether the types are identical.
+ */
+function sameTargetType(left, right) {
+  return JSON.stringify(targetTypeIdentity(left)) == JSON.stringify(targetTypeIdentity(right))
+}
+
+/**
+ * Reduces one semantic type to its comparable target identity.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @returns {unknown} Comparable identity.
+ */
+function targetTypeIdentity(type) {
+  if (typeof type == "string") return type
+  if (type.kind == "TypeReference") return type.name
+  if (type.kind == "TypeVariableReference") return {kind: "TypeVariableReference", parameterId: type.parameterId}
+  if (type.kind == "RecordType") return {declarationId: type.declarationId, kind: "RecordType"}
+  if (type.kind == "ReferenceType") return {declarationId: type.declarationId, kind: "ReferenceType"}
+  if (type.kind == "InterfaceType") return {declarationId: type.declarationId, kind: "InterfaceType"}
+  if (type.kind == "OwnedResourceType") return {kind: "OwnedResourceType", resourceId: type.resourceId}
+  if (type.kind == "OwnedReferenceType") return {declarationId: type.declarationId, kind: "OwnedReferenceType"}
+  if (type.kind == "ListType") return {elementType: targetTypeIdentity(type.elementType), kind: "ListType"}
+  if (type.kind == "OptionalType") return {kind: "OptionalType", valueType: targetTypeIdentity(type.valueType)}
+  if (type.kind == "OrderedMapType") return {keyType: targetTypeIdentity(type.keyType), kind: "OrderedMapType", valueType: targetTypeIdentity(type.valueType)}
+
+  return {keyType: targetTypeIdentity(type.keyType), kind: "MapType", valueType: targetTypeIdentity(type.valueType)}
 }
 
 /**
  * Validates one reference callable's exact parameter shape and target names.
  * @param {import("../semantic/types.js").Parameter[]} parameters - Candidate parameters.
- * @param {"constructor" | "method"} owner - Callable kind.
+ * @param {"constructor" | "interface method" | "method"} owner - Callable kind.
  * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
  * @param {import("../semantic/types.js").SourceLocation | undefined} ownerLocation - Fallback location.
  * @returns {void}
@@ -2095,6 +2291,14 @@ export function emitType(writer, type, path, language, javaBoxed = false) {
     })
     return
   }
+  if (type.kind == "InterfaceType") {
+    const declaration = writer.interfaceForId(type.declarationId)
+
+    writer.mapped(writer.interfaceNameForId(type.declarationId), {
+      mappingKind: "exact", name: declaration.name, node: type, path, role: "type"
+    })
+    return
+  }
   if (type.kind == "OwnedResourceType") {
     const resource = writer.resourceForId(type.resourceId)
     writer.mapped(writer.capabilityNominalName(resource.name), {mappingKind: "exact", name: resource.name, node: type, path, role: "type"})

package/src/backends/writer.js

@@ -106,6 +106,7 @@ export class SourceWriter {
     this.stdlibProviderShims = stdlibProviderShims
     const programRecords = program?.modules.flatMap((programModule) => programModule.records ?? []) ?? module.records ?? []
     const programClasses = program?.modules.flatMap((programModule) => programModule.classes ?? []) ?? module.classes ?? []
+    const programInterfaces = program?.modules.flatMap((programModule) => programModule.interfaces ?? []) ?? module.interfaces ?? []
     const capabilityFailures = module.capabilities?.flatMap(({failures}) => failures) ?? []
     const programErrors = program?.modules.flatMap((programModule) => [
       ...(programModule.errors ?? []),
@@ -115,6 +116,7 @@ export class SourceWriter {
 
     this.records = new Map(programRecords.map((record) => [record.id, record]))
     this.classes = new Map(programClasses.map((declaration) => [declaration.id, declaration]))
+    this.interfaces = new Map(programInterfaces.map((declaration) => [declaration.id, declaration]))
     this.errors = new Map(programErrors.map((error) => [error.id, error]))
     this.resources = new Map((module.capabilities?.flatMap(({resources}) => resources) ?? []).map((resource) => [resource.id, resource]))
     this.effectOperations = new Map((module.capabilities?.flatMap(({operations}) => operations) ?? []).map((operation) => [operation.id, operation]))
@@ -123,7 +125,14 @@ export class SourceWriter {
     this.fields = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, field])))
     this.fieldRecords = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, record])))
     this.privateFields = new Map(programClasses.flatMap((declaration) => declaration.fields.map((field) => [field.id, field])))
-    this.methods = new Map(programClasses.flatMap((declaration) => declaration.methods.map((method) => [method.id, method])))
+    /** @type {Map<string, import("../semantic/types.js").InterfaceMethodDeclaration | import("../semantic/types.js").MethodDeclaration>} */
+    this.methods = new Map()
+    for (const declaration of programClasses) {
+      for (const method of declaration.methods) this.methods.set(/** @type {string} */ (method.id), method)
+    }
+    for (const declaration of programInterfaces) {
+      for (const method of declaration.methods) this.methods.set(/** @type {string} */ (method.id), method)
+    }
     this.typeParameters = new Map([...programRecords, ...programFunctions].flatMap((declaration) =>
       (declaration.typeParameters ?? []).map((parameter) => [parameter.id, parameter])))
     this.referenceClassEmissionDepth = 0
@@ -131,6 +140,7 @@ export class SourceWriter {
     this.declarationModules = new Map(program?.modules.flatMap((programModule) => [
       ...(programModule.records ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
       ...(programModule.classes ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+      ...(programModule.interfaces ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
       ...(programModule.errors ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
       ...programModule.functions.map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule]))
     ]) ?? [])
@@ -282,6 +292,34 @@ export class SourceWriter {
     return declaration.name
   }
 
+  /**
+   * Resolves one validated interface declaration.
+   * @param {string} declarationId - Stable interface identity.
+   * @returns {import("../semantic/types.js").InterfaceDeclaration} Interface declaration.
+   */
+  interfaceForId(declarationId) {
+    const declaration = this.interfaces.get(declarationId)
+
+    if (!declaration) throw new RangeError(`Unknown validated interface identity '${declarationId}'.`)
+
+    return declaration
+  }
+
+  /**
+   * Returns the target spelling of one interface.
+   * @param {string} declarationId - Stable interface declaration identity.
+   * @returns {string} Target spelling.
+   */
+  interfaceNameForId(declarationId) {
+    const declaration = this.interfaceForId(declarationId)
+    const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId)
+
+    if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+      return this.importNameFor(imported)
+    }
+    return declaration.name
+  }
+
   /**
    * Resolves one validated owned-resource declaration.
    * @param {string} resourceId - Stable resource identity.
@@ -318,9 +356,9 @@ export class SourceWriter {
   }
 
   /**
-   * Resolves one validated receiver method.
+   * Resolves one validated receiver method, class-owned or interface-declared.
    * @param {string} methodId - Stable method identity.
-   * @returns {import("../semantic/types.js").MethodDeclaration} Method declaration.
+   * @returns {import("../semantic/types.js").MethodDeclaration | import("../semantic/types.js").InterfaceMethodDeclaration} Method declaration.
    */
   methodForId(methodId) {
     const method = this.methods.get(methodId)

package/src/frontends/java.js

@@ -49,7 +49,7 @@ const referenceMethodHooks = new Set(["clone", "equals", "finalize", "getClass",
  * @property {Map<string, import("../semantic/types.js").ErrorDeclaration>} errors - Errors by identity.
  * @property {Set<string>} erasedBindingNames - Source bindings consumed by exact semantic folds in this scope.
  * @property {Map<string, JavaFunctionSignature>} functions - Explicit module function signatures.
- * @property {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} recordNames - Nominal declarations by source name.
+ * @property {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} recordNames - Nominal declarations by source name.
  * @property {Map<string, import("../semantic/types.js").RecordDeclaration>} records - Records by identity.
  * @property {import("../semantic/types.js").SemanticFunctionReturnType | undefined} returnType - Enclosing return type.
  * @property {Map<string, import("../semantic/types.js").TypeParameter>} [typeParameters] - Declaration-scoped parameters.
@@ -260,6 +260,9 @@ function convertExpression(node, filename, source, context, expectedType) {
       kind: /** @type {const} */ ("ReferenceConstruction"), location,
       reference: referenceType(/** @type {string} */ (declaration.id), classLocation)}, {class: classLocation})
     }
+    if (declaration.kind == "InterfaceDeclaration") {
+      return unsupportedSyntax("java", "construction of an interface", nodeLocation(typeNode, filename, source))
+    }
     if (declaration.kind == "EffectResourceDeclaration") {
       return unsupportedSyntax("java", "owned resource construction", nodeLocation(typeNode, filename, source))
     }
@@ -1583,7 +1586,7 @@ function convertJavaOrderedMapSequence(statements, start, filename, source, cont
  * @param {import("../semantic/types.js").SourceLocation} location - Source location.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} [recordNames] - Nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} [recordNames] - Nominal declarations by source name.
  * @param {Map<string, import("../semantic/types.js").TypeParameter>} [typeParameters] - Declaration-scoped parameters.
  * @returns {import("../semantic/types.js").SemanticValueType} Semantic type.
  */
@@ -1685,7 +1688,7 @@ function convertType(sourceType, subject, location, filename, source, recordName
  * @param {import("../semantic/types.js").SourceLocation} location - Owning location.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} [recordNames] - Nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} [recordNames] - Nominal declarations by source name.
  * @param {Map<string, import("../semantic/types.js").TypeParameter>} [typeParameters] - Declaration-scoped parameters.
  * @returns {import("../semantic/types.js").SemanticValueType} Semantic type.
  */
@@ -1717,7 +1720,7 @@ function convertJavaTypeArgument(node, subject, location, filename, source, reco
  * @param {import("../semantic/types.js").SourceLocation} location - Function location.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} [recordNames] - Nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} [recordNames] - Nominal declarations by source name.
  * @param {Map<string, import("../semantic/types.js").TypeParameter>} [typeParameters] - Declaration-scoped parameters.
  * @returns {import("../semantic/types.js").SemanticFunctionReturnType} Semantic return type.
  */
@@ -1773,7 +1776,7 @@ function convertJavaTypeParameters(node, ownerId, filename, source) {
  * @param {import("@lezer/common").SyntaxNode} node - Method declaration.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} recordNames - Nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} recordNames - Nominal declarations by source name.
  * @param {boolean} [programFunction] - Whether the canonical project profile admits explicit public or private visibility.
  * @param {string} [ownerId] - Stable function identity.
  * @param {boolean} [referenceModule] - Whether package-visible static functions are required by sibling reference classes.
@@ -1843,7 +1846,7 @@ function convertFunctionSignature(node, filename, source, recordNames, programFu
  * @param {import("@lezer/common").SyntaxNode} node - Method declaration.
  * @param {JavaFunctionSignature} signature - Preconverted function signature.
  * @param {Map<string, JavaFunctionSignature>} functions - Module function signatures.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} recordNames - Nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} recordNames - Nominal declarations by source name.
  * @param {Map<string, import("../semantic/types.js").RecordDeclaration>} records - Record declarations by identity.
  * @param {Map<string, import("../semantic/types.js").ClassDeclaration>} classes - Reference classes by identity.
  * @param {Map<string, import("../semantic/types.js").ErrorDeclaration>} errorNames - Error declarations by source name.
@@ -1932,7 +1935,7 @@ function convertJavaError(node, declaration, filename, source, programError = fa
  * Reads one package-private Java reference constructor or instance-method signature.
  * @param {import("@lezer/common").SyntaxNode} node - Constructor or method declaration.
  * @param {import("../semantic/types.js").ClassDeclaration} declaration - Declaring class.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} nominalNames - Visible nominal declarations.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} nominalNames - Visible nominal declarations.
  * @param {boolean} constructor - Whether this is the sole constructor.
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
@@ -1978,7 +1981,7 @@ function convertJavaClassCallableSignature(node, declaration, nominalNames, cons
  * Converts the bounded final/private-field Java reference-class profile.
  * @param {import("@lezer/common").SyntaxNode} node - Class declaration.
  * @param {import("../semantic/types.js").ClassDeclaration} declaration - Predeclared class identity.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} nominalNames - Visible nominal declarations.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} nominalNames - Visible nominal declarations.
  * @param {Map<string, import("../semantic/types.js").RecordDeclaration>} records - Records by identity.
  * @param {Map<string, import("../semantic/types.js").ClassDeclaration>} classes - Classes by identity.
  * @param {Map<string, JavaFunctionSignature>} functions - Top-level signatures.
@@ -2276,7 +2279,7 @@ function convertWhile(node, filename, source, context) {
  * @param {string} filename - Source filename.
  * @param {string} source - Complete source.
  * @param {Map<string, JavaFunctionSignature>} functions - Module function signatures.
- * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} recordNames - Nominal declarations by source name.
+ * @param {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} recordNames - Nominal declarations by source name.
  * @param {Map<string, import("../semantic/types.js").RecordDeclaration>} records - Record declarations by identity.
  * @param {Map<string, import("../semantic/types.js").ClassDeclaration>} classes - Reference classes by identity.
  * @param {Map<string, import("../semantic/types.js").ErrorDeclaration>} errorNames - Error declarations by source name.
@@ -2442,7 +2445,7 @@ export function parseJava({capabilities = [], filename, source, program}) {
     kind: /** @type {const} */ ("ClassDeclaration"), location: nodeLocation(classNode, filename, source), methods: [],
     name: nodeText(requiredChild(classNode, "Definition", filename, source), source)
   }))
-  const recordNames = /** @type {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration>} */ (
+  const recordNames = /** @type {Map<string, import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").EffectResourceDeclaration | import("../semantic/types.js").InterfaceDeclaration>} */ (
     new Map(recordDeclarations.map((declaration) => /** @type {const} */ ([declaration.name, declaration]))))
   for (const resource of capabilities.flatMap(({resources}) => resources)) recordNames.set(resource.name, resource)
   for (const declaration of referenceDeclarations) recordNames.set(declaration.name, declaration)