XL-2 LoweringOccurrenceProjection 3b: census consumes occurrence roles; typed excluded populations; typed missing paths; repin (stacked on #12317)

dag/gunbc/namespace/namespace_xl2_rehearsal_census.dag

@@ -140,9 +140,33 @@ data xl2_native_requalification_walls: List<Xl2NativeRequalificationWall> = [
 // because the census's resolved arm (v2.compiler.compile NativeCensusModuleResolved) keeps no
 // resolved tree to count from; counting it needs the census to carry ResolvedToKernelSymbol
 // occurrences, which is the trigger for adding a count here.
-type Xl2ExcludedPopulation = | Xl2KernelCanonicalReferencesUncounted
-
-data xl2_excluded_populations: List<Xl2ExcludedPopulation> = [Xl2KernelCanonicalReferencesUncounted]
+//
+// HEADER SEGMENTS ARE NOT REFUSAL SITES. A module header's segments name the module itself; the
+// graft consumes them and resolve never looks one up, so stripping imports cannot make resolve
+// refuse at one. Measured on this composition (xl2_rehearse_stripped over supplied sources): a
+// module whose header names a path that no module declares yields residual rows only at its body
+// references, none at a header segment. Counted where the census has the atoms:
+// v2.compiler.reference_conservation header_channel.
+//
+// NESTING-SCOPED REFERENCES SURVIVE THE STRIP, UNCOUNTED. Measured on the same composition: a
+// module declared as v2.xl2_control_provider.shadow resolves the provider's function with its
+// import stripped, because nesting under a namespace grants that namespace's scope. Such a
+// reference is invisible to this census exactly as a kernel canonical one is -- no residual row
+// is not evidence the cut covers it. It is carried UNCOUNTED for the same reason: the resolved arm
+// keeps no resolved tree to count from, so counting it needs the census to carry which scope
+// resolved each reference, which is the trigger for adding a count here. OPEN QUESTION, not
+// answered by this row: whether the root-authority cut (XL-6) is meant to keep nesting-granted
+// scope; if it is not, these references become residual and this arm dissolves.
+type Xl2ExcludedPopulation
+  = Xl2KernelCanonicalReferencesUncounted
+  | HeaderSegmentsNotRefusalSites
+  | NestingScopedReferencesUncounted
+
+data xl2_excluded_populations: List<Xl2ExcludedPopulation> = [
+  Xl2KernelCanonicalReferencesUncounted,
+  HeaderSegmentsNotRefusalSites,
+  NestingScopedReferencesUncounted
+]
 
 type Xl2RehearsalRun
   = Xl2RehearsalBaseUnobserved { cause: Step0SubjectPinRefusal }

dag/test/claim/namespace_xl2_rehearsal_census_witness_test.dag

@@ -17,6 +17,9 @@ import gunbc.namespace_xl2_rehearsal_census {
   Xl2ResidualChain,
   Xl2ScopeUnobserved,
   Xl2Strip,
+  Xl2KernelCanonicalReferencesUncounted,
+  HeaderSegmentsNotRefusalSites,
+  NestingScopedReferencesUncounted,
   Xl2StrippedMember,
   xl2_rehearse_stripped,
   xl2_strip_members
@@ -56,6 +59,12 @@ data xl2_residual_control_source: String = "module v2.xl2_control_residual\n\nim
 
 data xl2_two_failure_control_source: String = "module v2.xl2_control_two\n\nimport v2.std.logic { Bool }\nimport v2.xl2_control_provider { xl2_control_provider_flag, xl2_control_provider_other }\n\nfn xl2_control_two_first(p: Bool) -> Bool { xl2_control_provider_flag }\n\nfn xl2_control_two_second(p: Bool) -> Bool { xl2_control_provider_other }\n"
 
+// THE NESTED CONTROL: a module declared UNDER the provider's namespace, naming the provider's
+// function through an import the strip removes. It is the specimen behind
+// NestingScopedReferencesUncounted: stripped, it still resolves, because nesting grants the
+// namespace's scope, so the cut leaves no residual row for its reference.
+data xl2_nested_control_source: String = "module v2.xl2_control_provider.nested\n\nimport v2.std.logic { Bool }\nimport v2.xl2_control_provider { xl2_control_provider_flag }\n\nfn xl2_control_nested_value(p: Bool) -> Bool { xl2_control_provider_flag }\n"
+
 data xl2_clean_control_source: String = "module v2.xl2_control_clean\n\nimport v2.std.logic { Bool }\n\nfn xl2_control_clean_value(p: Bool) -> Bool { p }\n"
 
 fn xl2_control_source(path: String, content: String) -> FixtureSource {
@@ -87,9 +96,10 @@ type Xl2ControlRuns {
   two: Xl2RehearsalRun
   pre_cut: Xl2RehearsalRun
   duplicated: Xl2RehearsalRun
+  nesting: Xl2RehearsalRun
 }
 
-// ONE NULLARY PRODUCER, WARM, FOR ALL FOUR RUNS (v2.workflow.floor_pure_producer_share carries its
+// ONE NULLARY PRODUCER, WARM, FOR ALL FIVE RUNS (v2.workflow.floor_pure_producer_share carries its
 // row): each run is a front end plus its resolves, more than one claim's budget, and the first cut
 // of this file paid two of them inside claims and was refused over budget on the floor.
 fn xl2_control_runs() -> Xl2ControlRuns {
@@ -107,6 +117,10 @@ fn xl2_control_runs() -> Xl2ControlRuns {
       xl2_control_source(path: "dag/xl2_control_shared.dag", content: xl2_residual_control_source),
       xl2_control_source(path: "dag/xl2_control_shared.dag", content: xl2_clean_control_source),
       clean
+    ])),
+    nesting: xl2_control_rehearse(strip: xl2_strip_members(sources: [
+      provider,
+      xl2_control_source(path: "dag/xl2_control_nested.dag", content: xl2_nested_control_source)
     ]))
   }
 }
@@ -189,7 +203,11 @@ test fn xl2_two_failures_in_one_module_are_two_rows_holds() -> Bool {
 // completeness refusals (the refusal type cannot carry them).
 test fn xl2_control_names_the_native_requalification_walls_holds() -> Bool {
   match xl2_control_runs().cut {
-    Xl2RehearsalObserved { native_requalification: walls, excluded: excluded } => count(walls) == 2 && count(excluded) == 1
+    Xl2RehearsalObserved { native_requalification: walls, excluded: excluded } =>
+      count(walls) == 2 && count(excluded) == 3
+        && any(excluded, e => e == Xl2KernelCanonicalReferencesUncounted)
+        && any(excluded, e => e == HeaderSegmentsNotRefusalSites)
+        && any(excluded, e => e == NestingScopedReferencesUncounted)
     _ => false
   }
 }
@@ -208,3 +226,13 @@ test fn xl2_duplicated_path_is_withheld_not_chosen_holds() -> Bool {
     _ => false
   }
 }
+
+// A NESTED MODULE'S REFERENCE SURVIVES THE STRIP: the provider and the module nested under its
+// namespace both resolve after the import is removed, and no residual row is emitted. This is why
+// NestingScopedReferencesUncounted is carried: the cut's residual cannot see this reference.
+test fn xl2_nested_reference_survives_the_strip_holds() -> Bool {
+  match xl2_control_runs().nesting {
+    Xl2RehearsalObserved { residual: residual, resolved_module_count: n } => count(residual) == 0 && n == 2
+    _ => false
+  }
+}

src/v2/compiler/occurrence_role.dag

@@ -359,7 +359,12 @@ fn roles_walk(acc: OccurrenceRoles, node: Node, by_emitted: Map<Symbol, NameProd
 }
 
 fn occurrence_roles_of_tree(tree: Node, root: GrammarRoot, rows: List<NameProductionRow>) -> OccurrenceRoleOutcome {
-  match name_production_table_admission(root: root, rows: rows) {
+  occurrence_roles_of_admitted(tree: tree, admission: name_production_table_admission(root: root, rows: rows))
+}
+
+// The walk against a table already admitted, so a caller that walks many trees admits once.
+fn occurrence_roles_of_admitted(tree: Node, admission: NameProductionTableAdmission) -> OccurrenceRoleOutcome {
+  match admission {
     NameProductionTableRefused { unlisted: u, unknown: k, unkeyed: x } => OccurrenceRoleTableRefused { unlisted: u, unknown: k, unkeyed: x }
     NameProductionTableAdmitted { by_emitted: by_emitted } =>
       OccurrenceRolesRead { roles: roles_walk(acc: occurrence_roles_empty(), node: tree, by_emitted: by_emitted) }
@@ -370,7 +375,32 @@ fn occurrence_role_index(roles: OccurrenceRoles) -> Map<OccurrenceId, AtomOccurr
   fold_list(xs: roles.roles, empty: empty_map(), cons: fn(acc, r) { map_insert(m: acc, key: r.occurrence, value: r) })
 }
 
+// The emitted identities of the `.dag` table's productions: the keys its per-production counters
+// (not_yet_read, reader_refused) can carry, derived from the grammar, so a consumer can total them.
+fn dag_name_production_emitted_symbols() -> List<Symbol> {
+  let listed = fold(dag_name_production_rows(), init: empty_map(), f: fn(acc, row) { map_insert(m: acc, key: row.production, value: true) })
+  fold(dag_grammar_root().productions, init: Empty, f: fn(acc, p) {
+    match map_lookup(m: listed, key: p.name) {
+      Absent => acc
+      Present { value: _ } =>
+        match node_atom_identity_optional(node: p.emitted) {
+          Present { value: e } => list_snoc_item(xs: acc, item: e)
+          Absent => acc
+        }
+    }
+  })
+}
+
+// THE `.dag` TABLE, ADMITTED ONCE, AS ONE NULLARY VALUE. Admission re-derives the whole grammar
+// root and folds every production's expression, which costs more than one module's walk; the result
+// depends on nothing but the language, so it is enrolled WARM in v2.workflow.floor_pure_producer_share
+// (beside v2.compiler.reference_conservation dag_declared_token_classes) and paid once per floor, not
+// once per census claim. dag_name_production_emitted_symbols below is enrolled the same way.
+fn dag_name_table_admission() -> NameProductionTableAdmission {
+  name_production_table_admission(root: dag_grammar_root(), rows: dag_name_production_rows())
+}
+
 // The `.dag` language's roles for one parsed module.
 fn dag_occurrence_roles(artifact: ParseArtifact) -> OccurrenceRoleOutcome {
-  occurrence_roles_of_tree(tree: artifact.tree, root: dag_grammar_root(), rows: dag_name_production_rows())
+  occurrence_roles_of_admitted(tree: artifact.tree, admission: dag_name_table_admission())
 }