semantifold 0.3.0 → 0.4.0

package/src/semantic/provenance.js

@@ -30,6 +30,16 @@ export function withParserRanges(node, ranges) {
   return node
 }
 
+/**
+ * Returns one parser-owned token range while frontend validation is still in progress.
+ * @param {object} node - Semantic node or type reference.
+ * @param {string} role - Exact semantic token role.
+ * @returns {import("./types.js").SourceLocation | undefined} Parser range when present.
+ */
+export function parserRangeFor(node, role) {
+  return parserRanges.get(node)?.[role]
+}
+
 /**
  * Adds deterministic provenance to a validated frontend module.
  * @param {import("./types.js").SemanticModule} module - Validated semantic module.
@@ -50,8 +60,14 @@ export function annotateParsedModule(module, {filename, language, source}) {
   for (const [index, entry] of entries.entries()) {
     const ranges = parserRanges.get(entry.node) ?? {}
     const location = "location" in entry.node ? entry.node.location : ranges.type ?? entry.ownerLocation
+    const related = {location, sourceId: "source:0"}
+    const origin = entry.path.startsWith("/capabilities/")
+      ? {kind: /** @type {const} */ ("synthetic"), reason: "compiler-authorized capability", relatedOrigins: [related]}
+      : entry.node.kind == "OwnedMoveExpression" || entry.node.kind == "OwnedBorrowExpression"
+        ? {kind: /** @type {const} */ ("derived"), origins: [related]}
+        : {kind: /** @type {const} */ ("source"), location, sourceId: "source:0"}
     const sourceProvenance = /** @type {import("./types.js").SemanticNodeSourceProvenance} */ ({
-      origin: {kind: "source", location, sourceId: "source:0"},
+      origin,
       ranges,
       schema: "SemantifoldNodeProvenance",
       version: 1
@@ -66,7 +82,7 @@ export function annotateParsedModule(module, {filename, language, source}) {
 
     records.push(record)
     recordsByPath.set(entry.path, record)
-    entry.node.sourceProvenance = sourceProvenance
+    if (Object.isExtensible(entry.node)) Reflect.set(entry.node, "sourceProvenance", sourceProvenance)
   }
 
   const symbols = resolveSymbols(module, recordsByPath)
@@ -121,13 +137,16 @@ export function createGenerationIndex(module, providedSources = []) {
 
   for (const [index, entry] of entries.entries()) {
     const located = "location" in entry.node ? entry.node.location : entry.ownerLocation
-    const associated = usableNodeProvenance(entry.node.sourceProvenance)
+    const associated = usableNodeProvenance(Reflect.get(entry.node, "sourceProvenance"))
     const ranges = associated ? validRanges(associated.ranges, verifiableSources) : {}
     const normalizedOrigin = associated
       ? normalizeOrigin(associated.origin, priorSourcesById, verifiableSources)
       : undefined
     const fallbackSource = sourceForLocation(located, sources)
-    const origin = normalizedOrigin ?? sourceOrigin(fallbackSource, located)
+    const origin = entry.path.startsWith("/capabilities/")
+      ? {kind: /** @type {const} */ ("synthetic"), reason: "compiler-authorized capability",
+        relatedOrigins: [{location: located, sourceId: fallbackSource.id}]}
+      : normalizedOrigin ?? sourceOrigin(fallbackSource, located)
 
     const record = {
       id: `node:${index}`,
@@ -185,7 +204,7 @@ export function createGenerationIndex(module, providedSources = []) {
    */
   function addSource(filename, content, language) {
     if (typeof filename != "string" || content !== null && typeof content != "string" ||
-      language !== null && !["php", "ruby", "javascript", "typescript", "java", "python", "csharp", "go", "c", "cpp"].includes(language)) {
+      language !== null && !["php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"].includes(language)) {
       throw new TypeError("Malformed semantic source registry entry.")
     }
 
@@ -242,7 +261,7 @@ function usableSourceProvenance(provenance) {
     if (!source || typeof source.id != "string" || sourceIds.has(source.id) || typeof source.filename != "string" ||
       source.filename.length == 0 ||
       source.content !== null && typeof source.content != "string" || source.language !== null &&
-      !["php", "ruby", "javascript", "typescript", "java", "python", "csharp", "go", "c", "cpp"].includes(source.language)) return undefined
+      !["php", "ruby", "javascript", "typescript", "java", "kotlin", "python", "csharp", "go", "c", "cpp", "rust", "swift", "dart"].includes(source.language)) return undefined
     sourceIds.add(source.id)
   }
 
@@ -445,7 +464,7 @@ function requireProvenance(module) {
 
 /**
  * Traverses public semantic nodes in one stable order.
- * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {import("./types.js").SemanticModule | import("./types.js").SemanticProgramModule} module - Semantic module.
  * @returns {{node: import("./types.js").SemanticNode, ownerLocation: import("./types.js").SourceLocation, path: string}[]} Entries.
  */
 export function semanticEntries(module) {
@@ -469,9 +488,47 @@ export function semanticEntries(module) {
     entries.push({node, ownerLocation: location, path})
 
     if (node.kind == "Module") {
+      if ("imports" in node) {
+        node.imports.forEach((child, index) => visit(child, `/imports/${index}`, location))
+      }
+      ;(node.records ?? []).forEach((child, index) => visit(child, `/records/${index}`, location))
+      if (!("sourceFilename" in node) || Reflect.get(node, "stdlibFacade") !== undefined) {
+        ;(node.classes ?? []).forEach((child, index) => visit(child, `/classes/${index}`, location))
+      }
+      ;(node.errors ?? []).forEach((child, index) => visit(child, `/errors/${index}`, location))
+      ;(node.capabilities ?? []).forEach((child, index) => visit(child, `/capabilities/${index}`, location))
       node.functions.forEach((child, index) => visit(child, `/functions/${index}`, location))
-      visit(node.entryPoint, "/entryPoint", location)
+      if ("exports" in node) {
+        node.exports.forEach((child, index) => visit(child, `/exports/${index}`, location))
+      }
+      if (node.entryPoint) visit(node.entryPoint, "/entryPoint", location)
+    } else if (node.kind == "RecordDeclaration") {
+      ;(node.typeParameters ?? []).forEach((child, index) => visit(child, `${path}/typeParameters/${index}`, location))
+      node.fields.forEach((child, index) => visit(child, `${path}/fields/${index}`, location))
+    } else if (node.kind == "EffectCapabilityDeclaration") {
+      node.resources.forEach((child, index) => visit(child, `${path}/resources/${index}`, location))
+      node.failures.forEach((child, index) => visit(child, `${path}/failures/${index}`, location))
+      node.operations.forEach((child, index) => visit(child, `${path}/operations/${index}`, location))
+    } else if (node.kind == "EffectOperationDeclaration") {
+      node.parameters.forEach((child, index) => visit(child.type, `${path}/parameters/${index}/type`, location))
+      visit(node.returnType, `${path}/returnType`, location)
+    } else if (node.kind == "ClassDeclaration") {
+      node.fields.forEach((child, index) => visit(child, `${path}/fields/${index}`, location))
+      visit(node.constructor, `${path}/constructor`, location)
+      node.methods.forEach((child, index) => visit(child, `${path}/methods/${index}`, location))
+    } else if (node.kind == "PrivateField") {
+      visit(node.type, `${path}/type`, location)
+    } else if (node.kind == "ConstructorDeclaration") {
+      node.parameters.forEach((child, index) => visit(child, `${path}/parameters/${index}`, location))
+      visit(node.body, `${path}/body`, location)
+    } else if (node.kind == "MethodDeclaration") {
+      node.parameters.forEach((child, index) => visit(child, `${path}/parameters/${index}`, location))
+      visit(node.returnType, `${path}/returnType`, location)
+      visit(node.body, `${path}/body`, location)
+    } else if (node.kind == "RecordField") {
+      visit(node.type, `${path}/type`, location)
     } else if (node.kind == "FunctionDeclaration") {
+      ;(node.typeParameters ?? []).forEach((child, index) => visit(child, `${path}/typeParameters/${index}`, location))
       node.parameters.forEach((child, index) => visit(child, `${path}/parameters/${index}`, location))
       visit(node.returnType, `${path}/returnType`, location)
       visit(node.body, `${path}/body`, location)
@@ -479,18 +536,55 @@ export function semanticEntries(module) {
       node.statements.forEach((child, index) => visit(child, `${path}/statements/${index}`, location))
     } else if (node.kind == "Parameter") {
       visit(node.type, `${path}/type`, location)
+    } else if (node.kind == "ValueBinding") {
+      visit(node.type, `${path}/type`, location)
+    } else if (node.kind == "CatchBinding") {
+      visit(node.type, `${path}/type`, location)
+    } else if (node.kind == "ListType") {
+      visit(node.elementType, `${path}/elementType`, location)
+    } else if (node.kind == "MapType" || node.kind == "OrderedMapType") {
+      visit(node.keyType, `${path}/keyType`, location)
+      visit(node.valueType, `${path}/valueType`, location)
+    } else if (node.kind == "OptionalType") {
+      visit(node.valueType, `${path}/valueType`, location)
+    } else if (node.kind == "RecordType") {
+      ;(node.arguments ?? []).forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))
     } else if (node.kind == "LocalDeclaration") {
       visit(node.type, `${path}/type`, location)
       visit(node.initializer, `${path}/initializer`, location)
     } else if (node.kind == "AssignmentStatement") {
       visit(node.target, `${path}/target`, location)
       visit(node.expression, `${path}/expression`, location)
-    } else if (node.kind == "ReturnStatement" || node.kind == "PrintStatement") {
+    } else if (node.kind == "PrivateFieldWriteStatement") {
+      visit(node.receiver, `${path}/receiver`, location)
+      visit(node.expression, `${path}/expression`, location)
+    } else if (node.kind == "ReturnStatement") {
+      if (node.expression) visit(node.expression, `${path}/expression`, location)
+    } else if (node.kind == "ExpressionStatement" || node.kind == "PrintStatement") {
       visit(node.expression, `${path}/expression`, location)
     } else if (node.kind == "IfStatement") {
       visit(node.condition, `${path}/condition`, location)
       visit(node.consequent, `${path}/consequent`, location)
       if (node.alternate) visit(node.alternate, `${path}/alternate`, location)
+    } else if (node.kind == "ForEachStatement") {
+      visit(node.list, `${path}/list`, location)
+      visit(node.valueBinding, `${path}/valueBinding`, location)
+      visit(node.body, `${path}/body`, location)
+    } else if (node.kind == "ForEachMapStatement") {
+      visit(node.map, `${path}/map`, location)
+      visit(node.keyBinding, `${path}/keyBinding`, location)
+      visit(node.valueBinding, `${path}/valueBinding`, location)
+      visit(node.body, `${path}/body`, location)
+    } else if (node.kind == "WhileStatement") {
+      visit(node.condition, `${path}/condition`, location)
+      visit(node.body, `${path}/body`, location)
+    } else if (node.kind == "RaiseStatement") {
+      visit(node.error, `${path}/error`, location)
+    } else if (node.kind == "TryStatement") {
+      visit(node.body, `${path}/body`, location)
+      visit(node.catchType, `${path}/catchType`, location)
+      visit(node.catchBinding, `${path}/catchBinding`, location)
+      visit(node.catchBody, `${path}/catchBody`, location)
     } else if (node.kind == "EntryPoint") {
       visit(node.body, `${path}/body`, location)
     } else if (node.kind == "UnaryExpression") {
@@ -498,8 +592,47 @@ export function semanticEntries(module) {
     } else if (node.kind == "BinaryExpression") {
       visit(node.left, `${path}/left`, location)
       visit(node.right, `${path}/right`, location)
-    } else if (node.kind == "CallExpression") {
+    } else if (node.kind == "CallExpression" || node.kind == "EffectCallExpression") {
       node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))
+    } else if (node.kind == "OwnedMoveExpression" || node.kind == "OwnedBorrowExpression") {
+      visit(node.expression, `${path}/expression`, location)
+    } else if (node.kind == "MethodCallExpression") {
+      visit(node.receiver, `${path}/receiver`, location)
+      node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))
+    } else if (node.kind == "ReferenceConstruction") {
+      visit(node.reference, `${path}/reference`, location)
+      node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))
+    } else if (node.kind == "RecordConstruction") {
+      visit(node.record, `${path}/record`, location)
+      node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))
+    } else if (node.kind == "MemberRead") {
+      visit(node.receiver, `${path}/receiver`, location)
+    } else if (node.kind == "PrivateFieldRead") {
+      visit(node.receiver, `${path}/receiver`, location)
+    } else if (node.kind == "ErrorConstruction") {
+      visit(node.error, `${path}/error`, location)
+      visit(node.message, `${path}/message`, location)
+    } else if (node.kind == "ErrorMessageRead") {
+      visit(node.receiver, `${path}/receiver`, location)
+    } else if (node.kind == "ListLiteral") {
+      node.elements.forEach((child, index) => visit(child, `${path}/elements/${index}`, location))
+    } else if (node.kind == "MapLiteral" || node.kind == "OrderedMapLiteral") {
+      node.entries.forEach((child, index) => visit(child, `${path}/entries/${index}`, location))
+    } else if (node.kind == "MapEntry") {
+      visit(node.key, `${path}/key`, location)
+      visit(node.value, `${path}/value`, location)
+    } else if (node.kind == "ListIndexExpression") {
+      visit(node.collection, `${path}/collection`, location)
+      visit(node.index, `${path}/index`, location)
+    } else if (node.kind == "MapLookupExpression") {
+      visit(node.collection, `${path}/collection`, location)
+      visit(node.key, `${path}/key`, location)
+    } else if (node.kind == "CollectionSizeExpression") {
+      visit(node.collection, `${path}/collection`, location)
+    } else if (node.kind == "OptionalSome") {
+      visit(node.value, `${path}/value`, location)
+    } else if (node.kind == "OptionalIsPresent" || node.kind == "OptionalUnwrap") {
+      visit(node.operand, `${path}/operand`, location)
     }
   }
 }
@@ -515,9 +648,108 @@ function resolveSymbols(module, records) {
   const symbols = []
   /** @type {Map<string, string>} */
   const functions = new Map()
+  /** @type {Map<string, string>} */
+  const recordSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const errorSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const fieldSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const classSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const constructorSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const methodSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const typeParameterSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const resourceSymbols = new Map()
+  /** @type {Map<string, string>} */
+  const operationSymbols = new Map()
+
+  for (const [capabilityIndex, capability] of (module.capabilities ?? []).entries()) {
+    const capabilityPath = `/capabilities/${capabilityIndex}`
+
+    declare(capability, capability.name, "capability", capabilityPath)
+    for (const [resourceIndex, resource] of capability.resources.entries()) {
+      resourceSymbols.set(resource.id, declare(resource, resource.name, "resource", `${capabilityPath}/resources/${resourceIndex}`))
+    }
+    for (const [failureIndex, failure] of capability.failures.entries()) {
+      errorSymbols.set(failure.id, declare(failure, failure.name, "failure", `${capabilityPath}/failures/${failureIndex}`))
+    }
+    for (const [operationIndex, operation] of capability.operations.entries()) {
+      operationSymbols.set(operation.id, declare(operation, operation.name, "operation", `${capabilityPath}/operations/${operationIndex}`))
+    }
+  }
+  for (const [capabilityIndex, capability] of (module.capabilities ?? []).entries()) {
+    for (const [operationIndex, operation] of capability.operations.entries()) {
+      const operationPath = `/capabilities/${capabilityIndex}/operations/${operationIndex}`
+      operation.parameters.forEach((parameter, parameterIndex) =>
+        visitType(parameter.type, `${operationPath}/parameters/${parameterIndex}/type`))
+      visitType(operation.returnType, `${operationPath}/returnType`)
+    }
+  }
+
+  for (const [index, declaration] of (module.records ?? []).entries()) {
+    const declarationPath = `/records/${index}`
+    const symbol = declare(declaration, declaration.name, "record", declarationPath)
+
+    if (declaration.id) recordSymbols.set(declaration.id, symbol)
+    for (const [parameterIndex, parameter] of (declaration.typeParameters ?? []).entries()) {
+      const parameterSymbol = declare(parameter, parameter.name, "typeParameter", `${declarationPath}/typeParameters/${parameterIndex}`)
+
+      if (parameter.id) typeParameterSymbols.set(parameter.id, parameterSymbol)
+    }
+    for (const [fieldIndex, field] of declaration.fields.entries()) {
+      const fieldPath = `${declarationPath}/fields/${fieldIndex}`
+      const fieldSymbol = declare(field, field.name, "field", fieldPath)
+
+      if (field.id) fieldSymbols.set(field.id, fieldSymbol)
+    }
+  }
+
+  for (const [index, declaration] of (module.errors ?? []).entries()) {
+    const symbol = declare(declaration, declaration.name, "error", `/errors/${index}`)
+
+    if (declaration.id) errorSymbols.set(declaration.id, symbol)
+  }
+
+  for (const [index, declaration] of (module.classes ?? []).entries()) {
+    const declarationPath = `/classes/${index}`
+    const classSymbol = declare(declaration, declaration.name, "class", declarationPath)
+
+    if (declaration.id) classSymbols.set(declaration.id, classSymbol)
+    for (const [fieldIndex, field] of declaration.fields.entries()) {
+      const symbol = declare(field, field.name, "field", `${declarationPath}/fields/${fieldIndex}`)
+
+      if (field.id) fieldSymbols.set(field.id, symbol)
+      visitType(field.type, `${declarationPath}/fields/${fieldIndex}/type`)
+    }
+    const constructorSymbol = declare(declaration.constructor, "constructor", "constructor", `${declarationPath}/constructor`)
+
+    if (declaration.constructor.id) constructorSymbols.set(declaration.constructor.id, constructorSymbol)
+    for (const [methodIndex, method] of declaration.methods.entries()) {
+      const symbol = declare(method, method.name, "method", `${declarationPath}/methods/${methodIndex}`)
+
+      if (method.id) methodSymbols.set(method.id, symbol)
+    }
+  }
+
+  for (const [index, declaration] of (module.records ?? []).entries()) {
+    for (const [fieldIndex, field] of declaration.fields.entries()) {
+      visitType(field.type, `/records/${index}/fields/${fieldIndex}/type`)
+    }
+  }
 
   for (const [index, declaration] of module.functions.entries()) {
-    functions.set(declaration.name, declare(declaration, declaration.name, "function", `/functions/${index}`))
+    const declarationPath = `/functions/${index}`
+
+    functions.set(declaration.name, declare(declaration, declaration.name, "function", declarationPath))
+    for (const [parameterIndex, parameter] of (declaration.typeParameters ?? []).entries()) {
+      const parameterSymbol = declare(parameter, parameter.name, "typeParameter", `${declarationPath}/typeParameters/${parameterIndex}`)
+
+      if (parameter.id) typeParameterSymbols.set(parameter.id, parameterSymbol)
+    }
   }
 
   for (const [index, declaration] of module.functions.entries()) {
@@ -526,17 +758,45 @@ function resolveSymbols(module, records) {
 
     for (const [parameterIndex, parameter] of declaration.parameters.entries()) {
       scope.set(parameter.name, declare(parameter, parameter.name, "parameter", `${declarationPath}/parameters/${parameterIndex}`))
+      visitType(parameter.type, `${declarationPath}/parameters/${parameterIndex}/type`)
     }
+    visitType(declaration.returnType, `${declarationPath}/returnType`)
     visitBlock(declaration.body, scope, `${declarationPath}/body`)
   }
 
+  for (const [classIndex, declaration] of (module.classes ?? []).entries()) {
+    const declarationPath = `/classes/${classIndex}`
+    const constructorScope = new Map()
+
+    for (const [parameterIndex, parameter] of declaration.constructor.parameters.entries()) {
+      const path = `${declarationPath}/constructor/parameters/${parameterIndex}`
+
+      constructorScope.set(parameter.name, declare(parameter, parameter.name, "parameter", path))
+      visitType(parameter.type, `${path}/type`)
+    }
+    visitBlock(declaration.constructor.body, constructorScope, `${declarationPath}/constructor/body`)
+    for (const [methodIndex, method] of declaration.methods.entries()) {
+      const methodPath = `${declarationPath}/methods/${methodIndex}`
+      const scope = new Map()
+
+      for (const [parameterIndex, parameter] of method.parameters.entries()) {
+        const path = `${methodPath}/parameters/${parameterIndex}`
+
+        scope.set(parameter.name, declare(parameter, parameter.name, "parameter", path))
+        visitType(parameter.type, `${path}/type`)
+      }
+      visitType(method.returnType, `${methodPath}/returnType`)
+      visitBlock(method.body, scope, `${methodPath}/body`)
+    }
+  }
+
   visitBlock(module.entryPoint.body, new Map(), "/entryPoint/body")
 
   return symbols
 
   /**
    * Declares one canonical symbol.
-   * @param {import("./types.js").FunctionDeclaration | import("./types.js").Parameter | import("./types.js").LocalDeclaration} node - Declaration.
+   * @param {import("./types.js").EffectCapabilityDeclaration | import("./types.js").EffectResourceDeclaration | import("./types.js").EffectFailureDeclaration | import("./types.js").EffectOperationDeclaration | import("./types.js").RecordDeclaration | import("./types.js").ClassDeclaration | import("./types.js").ErrorDeclaration | import("./types.js").RecordField | import("./types.js").PrivateField | import("./types.js").ConstructorDeclaration | import("./types.js").MethodDeclaration | import("./types.js").FunctionDeclaration | import("./types.js").TypeParameter | import("./types.js").Parameter | import("./types.js").LocalDeclaration | import("./types.js").ValueBinding | import("./types.js").CatchBinding} node - Declaration.
    * @param {string} name - Symbol name.
    * @param {import("./types.js").SemanticSymbolKind} kind - Symbol kind.
    * @param {string} path - Declaration occurrence path.
@@ -547,11 +807,21 @@ function resolveSymbols(module, records) {
 
     if (!record) throw new Error(`Missing provenance for ${node.kind}.`)
 
-    const location = record.ranges.name ?? node.location
+    const location = record.ranges.name ?? ("location" in node ? node.location : primaryLocation(record.origin))
     const id = `symbol:${symbols.length}`
 
     record.symbolId = id
-    symbols.push({declarationNodeId: record.id, id, kind, location, name, references: []})
+    symbols.push({
+      declarationNodeId: record.id,
+      id,
+      kind,
+      location,
+      name,
+      references: [],
+      ...(["capability", "resource", "failure", "operation", "record", "class", "error", "field", "constructor", "method", "function", "typeParameter"].includes(kind)
+        ? {semanticDeclarationId: /** @type {{id?: string}} */ (node).id}
+        : {})
+    })
 
     return id
   }
@@ -570,17 +840,70 @@ function resolveSymbols(module, records) {
       const statementPath = `${path}/statements/${index}`
 
       if (statement.kind == "LocalDeclaration") {
+        visitType(statement.type, `${statementPath}/type`)
         visitExpression(statement.initializer, scope, `${statementPath}/initializer`)
         scope.set(statement.name, declare(statement, statement.name, "local", statementPath))
       } else if (statement.kind == "AssignmentStatement") {
         reference(statement.target, scope.get(statement.target.name), "write", `${statementPath}/target`)
         visitExpression(statement.expression, scope, `${statementPath}/expression`)
-      } else if (statement.kind == "ReturnStatement" || statement.kind == "PrintStatement") {
+      } else if (statement.kind == "PrivateFieldWriteStatement") {
+        reference(statement, fieldSymbols.get(statement.field), "write", statementPath)
+        visitExpression(statement.receiver, scope, `${statementPath}/receiver`)
+        visitExpression(statement.expression, scope, `${statementPath}/expression`)
+      } else if (statement.kind == "ReturnStatement") {
+        if (statement.expression) visitExpression(statement.expression, scope, `${statementPath}/expression`)
+      } else if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement") {
         visitExpression(statement.expression, scope, `${statementPath}/expression`)
       } else if (statement.kind == "IfStatement") {
         visitExpression(statement.condition, scope, `${statementPath}/condition`)
         visitBlock(statement.consequent, scope, `${statementPath}/consequent`)
         if (statement.alternate) visitBlock(statement.alternate, scope, `${statementPath}/alternate`)
+      } else if (statement.kind == "ForEachStatement") {
+        visitExpression(statement.list, scope, `${statementPath}/list`)
+        const bodyScope = new Map(scope)
+
+        visitType(statement.valueBinding.type, `${statementPath}/valueBinding/type`)
+
+        bodyScope.set(statement.valueBinding.name, declare(
+          statement.valueBinding,
+          statement.valueBinding.name,
+          "iteration",
+          `${statementPath}/valueBinding`
+        ))
+        visitBlock(statement.body, bodyScope, `${statementPath}/body`)
+      } else if (statement.kind == "ForEachMapStatement") {
+        visitExpression(statement.map, scope, `${statementPath}/map`)
+        const bodyScope = new Map(scope)
+
+        visitType(statement.keyBinding.type, `${statementPath}/keyBinding/type`)
+        visitType(statement.valueBinding.type, `${statementPath}/valueBinding/type`)
+        bodyScope.set(statement.keyBinding.name, declare(
+          statement.keyBinding, statement.keyBinding.name, "iteration", `${statementPath}/keyBinding`
+        ))
+        bodyScope.set(statement.valueBinding.name, declare(
+          statement.valueBinding, statement.valueBinding.name, "iteration", `${statementPath}/valueBinding`
+        ))
+        visitBlock(statement.body, bodyScope, `${statementPath}/body`)
+      } else if (statement.kind == "WhileStatement") {
+        visitExpression(statement.condition, scope, `${statementPath}/condition`)
+        visitBlock(statement.body, scope, `${statementPath}/body`)
+      } else if (statement.kind == "RaiseStatement") {
+        visitType(statement.error.error, `${statementPath}/error/error`)
+        reference(statement.error, errorSymbols.get(statement.error.error.declarationId), "construct", `${statementPath}/error`)
+        visitExpression(statement.error.message, scope, `${statementPath}/error/message`)
+      } else if (statement.kind == "TryStatement") {
+        visitBlock(statement.body, scope, `${statementPath}/body`)
+        visitType(statement.catchType, `${statementPath}/catchType`)
+        visitType(statement.catchBinding.type, `${statementPath}/catchBinding/type`)
+        const catchScope = new Map(scope)
+
+        catchScope.set(statement.catchBinding.name, declare(
+          statement.catchBinding,
+          statement.catchBinding.name,
+          "catch",
+          `${statementPath}/catchBinding`
+        ))
+        visitBlock(statement.catchBody, catchScope, `${statementPath}/catchBody`)
       }
     }
   }
@@ -594,22 +917,89 @@ function resolveSymbols(module, records) {
    */
   function visitExpression(expression, scope, path) {
     if (expression.kind == "IdentifierExpression") reference(expression, scope.get(expression.name), "read", path)
+    else if (expression.kind == "ReceiverExpression") reference(expression, classSymbols.get(expression.classId), "read", path)
     else if (expression.kind == "CallExpression") {
-      reference(expression, functions.get(expression.callee), "call", path)
+      const declaration = module.functions.find((candidate) => candidate.id == expression.resolution?.declarationId)
+
+      reference(expression, declaration ? functions.get(declaration.name) : undefined, "call", path)
       for (const [index, argument] of expression.arguments.entries()) visitExpression(argument, scope, `${path}/arguments/${index}`)
+    } else if (expression.kind == "EffectCallExpression") {
+      reference(expression, operationSymbols.get(expression.operation), "call", path)
+      for (const [index, argument] of expression.arguments.entries()) visitExpression(argument, scope, `${path}/arguments/${index}`)
+    } else if (expression.kind == "OwnedMoveExpression" || expression.kind == "OwnedBorrowExpression") {
+      visitExpression(expression.expression, scope, `${path}/expression`)
+    } else if (expression.kind == "RecordConstruction") {
+      reference(expression, recordSymbols.get(expression.record.declarationId), "construct", path)
+      for (const [index, argument] of expression.arguments.entries()) visitExpression(argument, scope, `${path}/arguments/${index}`)
+    } else if (expression.kind == "ReferenceConstruction") {
+      reference(expression, constructorSymbols.get(/** @type {string} */ (expression.resolution?.declarationId)), "construct", path)
+      for (const [index, argument] of expression.arguments.entries()) visitExpression(argument, scope, `${path}/arguments/${index}`)
+    } else if (expression.kind == "MethodCallExpression") {
+      reference(expression, methodSymbols.get(expression.method), "call", path)
+      visitExpression(expression.receiver, scope, `${path}/receiver`)
+      for (const [index, argument] of expression.arguments.entries()) visitExpression(argument, scope, `${path}/arguments/${index}`)
+    } else if (expression.kind == "MemberRead") {
+      reference(expression, fieldSymbols.get(expression.field), "member", path)
+      visitExpression(expression.receiver, scope, `${path}/receiver`)
+    } else if (expression.kind == "PrivateFieldRead") {
+      reference(expression, fieldSymbols.get(expression.field), "member", path)
+      visitExpression(expression.receiver, scope, `${path}/receiver`)
+    } else if (expression.kind == "ErrorMessageRead") {
+      visitExpression(expression.receiver, scope, `${path}/receiver`)
     } else if (expression.kind == "UnaryExpression") {
       visitExpression(expression.operand, scope, `${path}/operand`)
     } else if (expression.kind == "BinaryExpression") {
       visitExpression(expression.left, scope, `${path}/left`)
       visitExpression(expression.right, scope, `${path}/right`)
+    } else if (expression.kind == "ListLiteral") {
+      for (const [index, element] of expression.elements.entries()) visitExpression(element, scope, `${path}/elements/${index}`)
+    } else if (expression.kind == "MapLiteral" || expression.kind == "OrderedMapLiteral") {
+      for (const [index, entry] of expression.entries.entries()) {
+        visitExpression(entry.key, scope, `${path}/entries/${index}/key`)
+        visitExpression(entry.value, scope, `${path}/entries/${index}/value`)
+      }
+    } else if (expression.kind == "ListIndexExpression") {
+      visitExpression(expression.collection, scope, `${path}/collection`)
+      visitExpression(expression.index, scope, `${path}/index`)
+    } else if (expression.kind == "MapLookupExpression") {
+      visitExpression(expression.collection, scope, `${path}/collection`)
+      visitExpression(expression.key, scope, `${path}/key`)
+    } else if (expression.kind == "CollectionSizeExpression") {
+      visitExpression(expression.collection, scope, `${path}/collection`)
+    } else if (expression.kind == "OptionalSome") {
+      visitExpression(expression.value, scope, `${path}/value`)
+    } else if (expression.kind == "OptionalIsPresent" || expression.kind == "OptionalUnwrap") {
+      visitExpression(expression.operand, scope, `${path}/operand`)
+    }
+  }
+
+  /**
+   * Resolves nominal references nested in a semantic type.
+   * @param {import("./types.js").SemanticFunctionReturnType | import("./types.js").ErrorType} type - Semantic type.
+   * @param {string} path - Type occurrence path.
+   * @returns {void}
+   */
+  function visitType(type, path) {
+    if (type.kind == "TypeVariableReference") reference(type, typeParameterSymbols.get(type.parameterId), "type", path)
+    else if (type.kind == "RecordType") {
+      reference(type, recordSymbols.get(type.declarationId), "type", path)
+      for (const [index, argument] of (type.arguments ?? []).entries()) visitType(argument, `${path}/arguments/${index}`)
     }
+    else if (type.kind == "ErrorType") reference(type, errorSymbols.get(type.declarationId), "type", path)
+    else if (type.kind == "ReferenceType" || type.kind == "OwnedReferenceType") reference(type, classSymbols.get(type.declarationId), "type", path)
+    else if (type.kind == "OwnedResourceType") reference(type, resourceSymbols.get(type.resourceId), "type", path)
+    else if (type.kind == "ListType") visitType(type.elementType, `${path}/elementType`)
+    else if (type.kind == "MapType" || type.kind == "OrderedMapType") {
+      visitType(type.keyType, `${path}/keyType`)
+      visitType(type.valueType, `${path}/valueType`)
+    } else if (type.kind == "OptionalType") visitType(type.valueType, `${path}/valueType`)
   }
 
   /**
    * Attaches one resolved symbol reference.
-   * @param {import("./types.js").IdentifierExpression | import("./types.js").CallExpression} node - Reference node.
+   * @param {import("./types.js").IdentifierExpression | import("./types.js").ReceiverExpression | import("./types.js").CallExpression | import("./types.js").EffectCallExpression | import("./types.js").MethodCallExpression | import("./types.js").TypeVariableReference | import("./types.js").RecordType | import("./types.js").ReferenceType | import("./types.js").OwnedReferenceType | import("./types.js").OwnedResourceType | import("./types.js").RecordConstruction | import("./types.js").ReferenceConstruction | import("./types.js").MemberRead | import("./types.js").PrivateFieldRead | import("./types.js").PrivateFieldWriteStatement | import("./types.js").ErrorType | import("./types.js").ErrorConstruction} node - Reference node.
    * @param {string | undefined} symbolId - Resolved symbol.
-   * @param {"read" | "write" | "call"} role - Reference role.
+   * @param {"type" | "construct" | "member" | "read" | "write" | "call"} role - Reference role.
    * @param {string} path - Reference occurrence path.
    * @returns {void}
    */
@@ -621,7 +1011,10 @@ function resolveSymbols(module, records) {
 
     if (!record || !symbol) throw new Error(`Missing provenance while resolving ${node.kind}.`)
 
-    const location = record.ranges[role == "call" ? "callee" : "name"] ?? node.location
+    const rangeRole = role == "call" ? (node.kind == "MethodCallExpression" ? "member" : "callee") :
+      role == "construct" ? (node.kind == "ErrorConstruction" ? "type" : node.kind == "ReferenceConstruction" ? "class" : "record") :
+        role == "member" || role == "write" && node.kind == "PrivateFieldWriteStatement" ? "member" : role == "type" ? "type" : "name"
+    const location = record.ranges[rangeRole] ?? ("location" in node ? node.location : primaryLocation(record.origin))
 
     record.symbolId = symbolId
     symbol.references.push({location, nodeId: record.id, role})

package/src/semantic/scalars.js

@@ -21,6 +21,23 @@ export function isScalarTypeName(name) {
   return scalarTypeNames.some((candidate) => candidate == name)
 }
 
+/**
+ * Checks a function return type name, including the non-value `void` result.
+ * @param {string} name - Candidate semantic return type name.
+ * @returns {name is import("./types.js").FunctionReturnTypeName} Whether the name is supported for a function return.
+ */
+export function isFunctionReturnTypeName(name) {
+  return name == "void" || isScalarTypeName(name)
+}
+
+/**
+ * Returns the canonical semantic void return type reference.
+ * @returns {import("./types.js").FunctionReturnTypeReference} Void return type.
+ */
+export function voidType() {
+  return {kind: "TypeReference", name: "void"}
+}
+
 /**
  * Checks that a JavaScript string contains only complete Unicode scalar values.
  * @param {string} value - Candidate Unicode string.