Grammar lane G1: qualified module projection resolve — value/type/pattern positions resolve container.member via SymbolIndex walk (not value field-access); v1 compile-clean witness on stripped fixture; unblocks Wave-0 (c) homonym qualify + Wave-1 strip CI

src/v1/02_parse.dag

@@ -1252,7 +1252,7 @@ fn parse_type_body_after_eq(tokens: TokenStream, ctx: ParseContext, name: String
     ItemResult { item: item, tokens: skip_newlines(tokens: rest.tokens), ctx: rest.ctx, err: none }
   EatUnchanged { tokens: _ } =>
   if tok_is_ident(tok: token_stream_first(stream: tokens)) {
-    let r = expect_ident(tokens: tokens)
+    let r = parse_dotted_ident(tokens: tokens)
     if has_err(err: r.err) { return ItemResult { item: dummy, tokens: r.tokens, ctx: ctx, err: r.err } }
     let first_name = r.name
     let first_name_span = r.span
@@ -1519,8 +1519,16 @@ fn parse_type_expr(tokens: TokenStream, ctx: ParseContext) -> TypeResult {
       }
     }
     Present { value: ShIdent } => {
-      let n = tok.value.text
-      finish_type_expr_from_name(tokens: token_stream_advance(stream: tokens, n: 1), ctx: ctx, type_name: n, start_span: span)
+      let r = parse_dotted_ident(tokens: tokens)
+      if has_err(err: r.err) {
+        return TypeResult {
+          type_expr: leaf_type_node(name: "", span: span),
+          tokens: r.tokens,
+          ctx: ctx,
+          err: r.err
+        }
+      }
+      finish_type_expr_from_name(tokens: r.tokens, ctx: ctx, type_name: r.name, start_span: r.span)
     }
     _ => TypeResult { type_expr: leaf_type_node(name: "", span: span), tokens: tokens, ctx: ctx, err: Present { value: parse_error(msg: "expected type expression", span: span) } }
   }

src/v1/04_env.dag

@@ -16,6 +16,7 @@ type TypeEnv {
   intern_table: InternTable
   source_visible_names: Map<String, Bool>
   global_bare: Map<String, GlobalBareLookupState>
+  symbol_index: SymbolIndex
 }
 
 type TypeBinding {
@@ -26,6 +27,8 @@ type TypeBinding {
 
 data global_bare_fallback_invariant: String = "Corpus-wide bare-name census (namespace-resolution-design.md §8 PR-4): keyed on the bare declared name, one authority built once by build_global_bare_census over graph.modules before any module typechecks (order-independent — mirrors v2's symbol_index_global_bare, docs/plans/namespace-resolution-design.md §7.5). lookup_binding_by_name consults it only after str_bindings/ancestry_str_bindings/intern+bindings all miss, and only a GlobalBareUniqueBinding resolves; GlobalBareAmbiguousBinding stays Absent (fail-closed, never guesses — §5). This is what unblocks the src/v1 import strip: a bare reference that used to resolve via a deleted import chain still resolves here iff its name is globally unique in the corpus."
 
+data qualified_module_projection_invariant: String = "Grammar lane G1: container.member module projection in type positions resolves via symbol_index_lookup on the full qualified path (module projection), not value field-access — v2 resolve: TypeNode Conj QN spines; v1 typecheck: lookup_binding_by_name after global_bare. build_symbol_index_census materializes declared-module paths once; lookup_qualified_module_projection runs only when the reference carries a dot (fail-closed on miss — never widens to field-access semantics)."
+
 type GlobalBareLookupState
   = GlobalBareUniqueBinding { binding: TypeBinding }
   | GlobalBareAmbiguousBinding
@@ -371,10 +374,35 @@ fn lookup_binding_by_name(env: TypeEnv, name: String) -> TypeBinding? {
           match intern_find(table: env.intern_table, s: name) {
             Present { value: id } => match map_get(env.bindings, id) {
               Present { value: binding } => Present { value: binding }
-              Absent => global_bare_lookup(env: env, name: name)
+              Absent => lookup_binding_after_global_bare(env: env, name: name)
+            }
+            Absent => lookup_binding_after_global_bare(env: env, name: name)
+          }
+      }
+  }
+}
+
+fn lookup_binding_after_global_bare(env: TypeEnv, name: String) -> TypeBinding? {
+  match global_bare_lookup(env: env, name: name) {
+    Present { value: binding } => Present { value: binding }
+    Absent => lookup_qualified_module_projection(env: env, name: name)
+  }
+}
+
+fn lookup_qualified_module_projection(env: TypeEnv, name: String) -> TypeBinding? {
+  match contains(name, ".") {
+    false => Absent
+    true =>
+      match symbol_index_lookup(index: env.symbol_index, qualified_name: name) {
+        Present { value: resolved } =>
+          Present {
+            value: TypeBinding {
+              name: name,
+              resolved: resolved,
+              provenance: SubValueUnknown
             }
-            Absent => global_bare_lookup(env: env, name: name)
           }
+        Absent => Absent
       }
   }
 }

src/v1/04_resolve.dag

@@ -980,7 +980,8 @@ fn resolve_item_types(item: Node, env: TypeEnv, module_name: String) -> ItemReso
       source_indices: e.source_indices,
       intern_table: e.intern_table,
       source_visible_names: map_insert(e.source_visible_names, tp_name, true),
-      global_bare: e.global_bare
+      global_bare: e.global_bare,
+      symbol_index: e.symbol_index
     }
   )
   let param_results = map(item.params, p => resolve_param(param: p, env: env, module_name: module_name))

src/v1/05_emit.dag

@@ -46,7 +46,7 @@ import v1.std.core {
   CardOptional
 }
 
-import v1.compiler.infer_env { TypeEnv, TypeBinding, authored_name, GlobalBareLookupState }
+import v1.compiler.infer_env { TypeEnv, TypeBinding, authored_name, GlobalBareLookupState, empty_symbol_index }
 import std.induction { InductiveField, SubValueUnknown }
 import v1.compiler.infer_types { resolved_type, child_type_node, emit_map_has, node_is_collection, node_is_keyed_collection, node_is_element_collection, normalize_access_type_node, for_each_element_type_node, is_unit_like, is_declared_container_alias_spelling }
 import std.types { is_container_type, container_template_algebra }
@@ -270,7 +270,7 @@ fn emit_simple_string_interp(parts: List<StringPart>, target: RenderTarget, sour
 
 fn empty_emit_scope() -> InferScope {
   InferScope {
-    type_env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: empty_map(), intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map() },
+    type_env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: empty_map(), intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map(), symbol_index: empty_symbol_index() },
     func_env: ResolvedFuncEnv { local: empty_map(), parents: [] },
     locals: empty_map(),
     match_bound_names: empty_map(),

src/v1/05_emit_rust.dag

@@ -72,7 +72,7 @@ import v1.compiler.coercion { coerce_primitive_type, is_copy, lookup_checkpoint
 
 import std.types { is_container_type, is_kernel_type }
 import std.serialization { CoproductWireContract, VariantEncoding, VariantNaming }
-import v1.compiler.infer_env { TypeEnv, TypeBinding, authored_name, lookup_type_by_name, lookup_type_for, GlobalBareLookupState }
+import v1.compiler.infer_env { TypeEnv, TypeBinding, authored_name, lookup_type_by_name, lookup_type_for, GlobalBareLookupState, empty_symbol_index }
 import v1.compiler.infer_types {
   resolved_type, normalize_access_type_node, for_each_element_type_node,
   child_type_node, emit_map_has,
@@ -154,7 +154,7 @@ fn render_rust_type(n: Node, shared_types: Set<String>, corpus_repr: RustCorpusR
       match find_property(props: n.properties, prop_name: "__applied_type_args", source_indices: source_indices) {
         Present { value: applied } =>
           if applied.children |> count > 0 {
-            render_rust_applied_type_shared(n: applied, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map() })
+            render_rust_applied_type_shared(n: applied, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map(), symbol_index: empty_symbol_index() })
           } else {
             render_rust_type_without_applied_binding(n: n, shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices)
           }
@@ -166,7 +166,7 @@ fn render_rust_type(n: Node, shared_types: Set<String>, corpus_repr: RustCorpusR
 fn render_rust_type_without_applied_binding(n: Node, shared_types: Set<String>, corpus_repr: RustCorpusRepr, source_indices: Map<String, NewlineIndex>) -> String {
   if is_host_text_carrier_type(n: n, source_indices: source_indices, corpus_repr: corpus_repr) { return rust_carrier_optional_wrap(n: n, rendered: "String") }
   if n.connective == NoConnective && n.children |> count > 0 && !is_container_type(name: authored_name_at(source_indices: source_indices, node: n)) {
-    render_rust_applied_type_shared(n: n, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map() })
+    render_rust_applied_type_shared(n: n, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map(), symbol_index: empty_symbol_index() })
   } else if node_is_set_collection(n: n, source_indices: source_indices) {
     match n.children |> first {
       Present { value: elem_child } =>
@@ -3435,10 +3435,10 @@ fn render_rust_type_with_applied_binding(n: Node, shared_types: Set<String>, cor
           } else if set_contains(shared_types, outer_name) {
             render_rust_shared_type_with_optional(n: n, type_name: outer_name, rendered: outer_name, shared_types: shared_types)
           } else {
-            render_rust_applied_type_shared(n: applied, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map() })
+            render_rust_applied_type_shared(n: applied, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map(), symbol_index: empty_symbol_index() })
           }
         } else {
-          render_rust_applied_type_shared(n: applied, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map() })
+          render_rust_applied_type_shared(n: applied, generic_param_names: [], shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices, variant_to_enum: empty_map(), env: TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map(), symbol_index: empty_symbol_index() })
         }
       } else {
         render_rust_type(n: n, shared_types: shared_types, corpus_repr: corpus_repr, source_indices: source_indices)
@@ -8328,7 +8328,7 @@ fn emit_test_file(module_name: String, projections: List<TestProjection>, corpus
 }
 
 fn rust_test_signature_comment(projection: TestProjection, corpus_repr: RustCorpusRepr) -> String {
-  let stub_env = TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: projection.source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map() }
+  let stub_env = TypeEnv { bindings: empty_map(), str_bindings: empty_map(), ancestry_str_bindings: empty_map(), parents: [], recursive_types: [], recursive_type_set: empty_map(), inductive_fields: empty_map(), source_indices: projection.source_indices, intern_table: empty_intern_table(), source_visible_names: empty_map(), global_bare: empty_map(), symbol_index: empty_symbol_index() }
   let params_str = projection.params
     |> map(p => concat(param_node_name_at(n: p, source_indices: projection.source_indices), ": ", emit_rust_param_type(n: param_node_type_expr(n: p), generic_param_names: [], shared_types: empty_set(), corpus_repr: corpus_repr, source_indices: projection.source_indices, variant_to_enum: empty_map(), env: stub_env)))
     |> join(separator: ", ")

src/v1/compiler_tests_rust.dag

@@ -1167,6 +1167,7 @@ fn ct_profile_reconcile_test() -> String {
     "                        source_indices.clone(),\n",
     "                        intern_table.clone(),\n",
     "                        std::rc::Rc::new(HashMap::new()),\n",
+    "                        crate::v1_compiler_infer_env::empty_symbol_index(),\n",
     "                    );\n",
     "                    let env_elapsed = t_env.elapsed();\n",
     "                    let rss_after_env = get_rss_bytes();\n",
@@ -1202,6 +1203,7 @@ fn ct_profile_reconcile_test() -> String {
     "                        source_indices.clone(),\n",
     "                        intern_table.clone(),\n",
     "                        std::rc::Rc::new(HashMap::new()),\n",
+    "                        crate::v1_compiler_infer_env::empty_symbol_index(),\n",
     "                    );\n",
     "                    let full_elapsed = t_full.elapsed();\n",
     "                    let rss_after = get_rss_bytes();\n",

src/v1/stage0/src/bin/infer_semantics_witness.rs

@@ -323,6 +323,7 @@ fn empty_type_env() -> Rc<TypeEnv> {
         intern_table: v1_compiler::v1_std_core::empty_intern_table(),
         source_visible_names: Rc::new(im_rc::HashMap::new()),
         global_bare: Rc::new(im_rc::HashMap::new()),
+        symbol_index: v1_compiler::v1_compiler_infer_env::empty_symbol_index(),
     })
 }
 
@@ -1005,6 +1006,7 @@ fn optional_match_exhaustiveness_reports_missing_absent() {
             intern_table: v1_compiler::v1_std_core::empty_intern_table(),
             source_visible_names: Rc::new(im_rc::HashMap::new()),
             global_bare: Rc::new(im_rc::HashMap::new()),
+            symbol_index: v1_compiler::v1_compiler_infer_env::empty_symbol_index(),
         }),
         zero_span(),
         "test".to_string(),
@@ -1032,6 +1034,7 @@ fn optional_match_exhaustiveness_rejects_some_and_none() {
             intern_table: v1_compiler::v1_std_core::empty_intern_table(),
             source_visible_names: Rc::new(im_rc::HashMap::new()),
             global_bare: Rc::new(im_rc::HashMap::new()),
+            symbol_index: v1_compiler::v1_compiler_infer_env::empty_symbol_index(),
         }),
         zero_span(),
         "test".to_string(),
@@ -1059,6 +1062,7 @@ fn optional_match_exhaustiveness_accepts_present_and_absent() {
             intern_table: v1_compiler::v1_std_core::empty_intern_table(),
             source_visible_names: Rc::new(im_rc::HashMap::new()),
             global_bare: Rc::new(im_rc::HashMap::new()),
+            symbol_index: v1_compiler::v1_compiler_infer_env::empty_symbol_index(),
         }),
         zero_span(),
         "test".to_string(),
@@ -1123,6 +1127,7 @@ fn resolve_node_uses_node_name_for_lookup() {
         intern_table: user_intern.table.clone(),
         source_visible_names: Rc::new(im_rc::HashMap::new()),
         global_bare: Rc::new(im_rc::HashMap::new()),
+        symbol_index: v1_compiler::v1_compiler_infer_env::empty_symbol_index(),
     });
 
     let result = resolve_node(node_ref, env, "test".to_string());
@@ -1642,6 +1647,7 @@ fn resolve_applied_generic_struct_expands_to_conj_for_field_lookup() {
         intern_table: box_intern.table.clone(),
         source_visible_names: Rc::new(im_rc::HashMap::new()),
         global_bare: Rc::new(im_rc::HashMap::new()),
+        symbol_index: v1_compiler::v1_compiler_infer_env::empty_symbol_index(),
     });
 
     let box_nat = container_node("Box".to_string(), leaf_node("Nat".to_string()));