Carry occurrence identity on every semantic v1 Node

dag/test/claim/required_record_field_omission_witness_test.dag

@@ -0,0 +1,69 @@
+module test.claim.required_record_field_omission_witness
+
+import v2.std.live_tree { LiveTreeDisposition, SubstrateInputsOnly }
+import tools.multi_module_compile_fixture {
+  MultiModuleCompileFixture,
+  MultiModuleCompileFixtureOutcome,
+  FixtureInstrumentRefused,
+  FixtureCompileRefused,
+  FixtureCompileCompleted,
+  fixture_source,
+  compile_fixture,
+  fixture_blocking_rows,
+  fixture_rows_of_class,
+}
+
+data live_tree_disposition: LiveTreeDisposition = SubstrateInputsOnly
+
+data required_record_field_omission_witness_note: String = "Construction control for the v1 NodeOccurrenceIdentity carrier. The negative and positive manifests differ only in whether the required `occurrence_identity` field is supplied. The negative reaches the isolated v1-to-Rust compiler and observes exactly one blocking MissingField row naming occurrence_identity; FixtureInstrumentRefused cannot impersonate that refusal. The positive reaches Rust emission with no diagnostics and a nonempty artifact population. Both measured arms carry nonempty source and compiler digests, binding the receipt to the ordered manifest and running transform. This instrument does not assert interpreter behavior or any non-Rust render target."
+
+fn required_record_field_fixture(source: String) -> MultiModuleCompileFixtureOutcome {
+  compile_fixture(MultiModuleCompileFixture {
+    sources: [fixture_source("required_field/entry.dag", source)],
+    entry: "required_field/entry.dag",
+  })
+}
+
+fn required_record_field_omission_run() -> MultiModuleCompileFixtureOutcome {
+  required_record_field_fixture(
+    source: "module required_field.entry\ntype Pair { occurrence_identity: Int, label: String }\ndata pair: Pair = Pair { label: \"red\" }\n"
+  )
+}
+
+fn required_record_fields_supplied_run() -> MultiModuleCompileFixtureOutcome {
+  required_record_field_fixture(
+    source: "module required_field.entry\ntype Pair { occurrence_identity: Int, label: String }\ndata pair: Pair = Pair { occurrence_identity: 1, label: \"green\" }\n"
+  )
+}
+
+test fn omitted_required_record_field_refuses() -> Bool {
+  match required_record_field_omission_run() {
+    FixtureCompileRefused { module_count: _, diagnostics: rows, source_digest: source_digest, compiler_digest: compiler_digest } =>
+      let blocking = fixture_blocking_rows(rows)
+      let missing = fixture_rows_of_class(rows, "MissingField")
+      match first(missing) {
+        Present { value: row } =>
+          count(blocking) == 1
+            && count(missing) == 1
+            && row.subject_name == "occurrence_identity"
+            && row.count == 1
+            && count(source_digest as String) > 0
+            && count(compiler_digest as String) > 0
+        Absent => false
+      }
+    FixtureCompileCompleted { module_count: _, emitted_files: _, diagnostics: _, source_digest: _, compiler_digest: _ } => false
+    FixtureInstrumentRefused { cause: _ } => false
+  }
+}
+
+test fn complete_required_record_literal_accepts() -> Bool {
+  match required_record_fields_supplied_run() {
+    FixtureCompileCompleted { module_count: _, emitted_files: files, diagnostics: rows, source_digest: source_digest, compiler_digest: compiler_digest } =>
+      count(rows) == 0
+        && count(files) > 0
+        && count(source_digest as String) > 0
+        && count(compiler_digest as String) > 0
+    FixtureCompileRefused { module_count: _, diagnostics: _, source_digest: _, compiler_digest: _ } => false
+    FixtureInstrumentRefused { cause: _ } => false
+  }
+}

src/v1/04_env.dag

@@ -1,5 +1,7 @@
 module v1.compiler.infer_env
 
+import std.occurrence_identity { OccurrenceSynthetic }
+
 import v1.std.core { Node, NewlineIndex, InternTable, empty_intern_table, merge_intern_tables, intern, intern_find, intern_str, source_text_at, authored_name_at, find_child_named, Cardinality, Connective, ExprData, InferredNode, kernel_span, module_path_segments, param_node_name_at, param_node_type_expr, CompilerDiagnostic, AmbiguousReference, UnresolvedType }
 import v1.compiler.type_head_exposure { TypeHeadExposure }
 
@@ -725,7 +727,7 @@ fn qualify_borrowed_type_names(n: Node, owner_module_path: String, env: TypeEnv,
       } else {
         let qname = concat(mp, ".", name)
         Node {
-          name: qname, span: n.span, ident_span: Present { value: kernel_span(name: qname) },
+          occurrence_identity: OccurrenceSynthetic, name: qname, span: n.span, ident_span: Present { value: kernel_span(name: qname) },
           children: qualified_children, connective: n.connective, params: n.params,
           inferred: n.inferred, return_cardinality: n.return_cardinality, uses: n.uses,
           body: n.body, transport: n.transport, properties: n.properties,
@@ -740,7 +742,7 @@ fn qualify_borrowed_type_names(n: Node, owner_module_path: String, env: TypeEnv,
 
 fn node_with_children(n: Node, children: List<Node>) -> Node {
   Node {
-    name: n.name, ident: n.ident, span: n.span, ident_span: n.ident_span,
+    occurrence_identity: OccurrenceSynthetic, name: n.name, ident: n.ident, span: n.span, ident_span: n.ident_span,
     children: children, connective: n.connective, params: n.params,
     inferred: n.inferred, return_cardinality: n.return_cardinality, uses: n.uses,
     body: n.body, transport: n.transport, properties: n.properties,
@@ -752,7 +754,7 @@ fn node_with_children(n: Node, children: List<Node>) -> Node {
 
 fn node_with_inferred(n: Node, inferred: InferredNode?) -> Node {
   Node {
-    name: n.name, ident: n.ident, span: n.span, ident_span: n.ident_span,
+    occurrence_identity: OccurrenceSynthetic, name: n.name, ident: n.ident, span: n.span, ident_span: n.ident_span,
     children: n.children, connective: n.connective, params: n.params,
     inferred: inferred, return_cardinality: n.return_cardinality, uses: n.uses,
     body: n.body, transport: n.transport, properties: n.properties,
@@ -1068,7 +1070,7 @@ fn env_with_type_variable_bindings(env: TypeEnv, tp_names: List<String>) -> Type
   fold(tp_names, init: env, f: (e, tp_name) =>
     let tp_binding = TypeBinding {
       name: tp_name,
-      resolved: Node { name: tp_name, span: kernel_span(name: tp_name), ident_span: Present { value: kernel_span(name: tp_name) }, children: [], connective: NoConnective, params: [], inferred: Present { value: TypeVariable { id: tp_name } }, return_cardinality: Required, uses: [], body: none, transport: none, properties: [], type_annotation: none, is_self_recursive: false, has_non_tail_self_call: false, match_pattern: none, expr_data: NoExprData },
+      resolved: Node { occurrence_identity: OccurrenceSynthetic, name: tp_name, span: kernel_span(name: tp_name), ident_span: Present { value: kernel_span(name: tp_name) }, children: [], connective: NoConnective, params: [], inferred: Present { value: TypeVariable { id: tp_name } }, return_cardinality: Required, uses: [], body: none, transport: none, properties: [], type_annotation: none, is_self_recursive: false, has_non_tail_self_call: false, match_pattern: none, expr_data: NoExprData },
       provenance: SubValueUnknown
     }
     TypeEnv { module_path: e.module_path,