diff --git a/src/v2/00_core.dag b/src/v2/00_core.dag
index b3f81c1b06d..189d08bb845 100644
--- a/src/v2/00_core.dag
+++ b/src/v2/00_core.dag
@@ -376,6 +376,7 @@ type DeclaredFuncEnv {
 
 type Node {
   name: String
+  ident: Int
   span: SourceSpan
   ident_span: SourceSpan?
   // Fractal composition -- operations, capabilities, items are all children
@@ -1262,7 +1263,7 @@ fn transport_env(t: Node, source_indices: Map<String, NewlineIndex>) -> List<Nod
 
 fn map_children(node: Node, transform: fn(Node) -> Node) -> Node {
   Node {
-    name: node.name, span: node.span, ident_span: node.ident_span,
+    name: node.name, ident: node.ident, span: node.span, ident_span: node.ident_span,
     children: node.children |> map(child => transform(child)),
     connective: node.connective,
     params: node.params, inferred: node.inferred,
@@ -1653,10 +1654,16 @@ fn merge_intern_tables(tables: List<InternTable>) -> InternTable {
   )
 }
 
+fn pre_intern_tokens(tokens: List<Token>, table: InternTable) -> InternTable {
+  fold(tokens, init: table, f: (t, tok) =>
+    if tok.text != "" { intern(table: t, s: tok.text).table } else { t }
+  )
+}
+
 fn with_optional_cardinality(n: Node) -> Node {
-  Node { name: n.name, span: n.span, ident_span: n.ident_span, children: n.children, connective: n.connective, params: n.params, inferred: n.inferred, return_cardinality: CardOptional, uses: n.uses, body: n.body, transport: n.transport, properties: n.properties, type_annotation: n.type_annotation, is_self_recursive: n.is_self_recursive, has_non_tail_self_call: n.has_non_tail_self_call, match_pattern: n.match_pattern, expr_data: n.expr_data }
+  Node { name: n.name, ident: n.ident, span: n.span, ident_span: n.ident_span, children: n.children, connective: n.connective, params: n.params, inferred: n.inferred, return_cardinality: CardOptional, uses: n.uses, body: n.body, transport: n.transport, properties: n.properties, type_annotation: n.type_annotation, is_self_recursive: n.is_self_recursive, has_non_tail_self_call: n.has_non_tail_self_call, match_pattern: n.match_pattern, expr_data: n.expr_data }
 }
 
 fn with_required_cardinality(n: Node) -> Node {
-  Node { name: n.name, span: n.span, ident_span: n.ident_span, children: n.children, connective: n.connective, params: n.params, inferred: n.inferred, return_cardinality: Required, uses: n.uses, body: n.body, transport: n.transport, properties: n.properties, type_annotation: n.type_annotation, is_self_recursive: n.is_self_recursive, has_non_tail_self_call: n.has_non_tail_self_call, match_pattern: n.match_pattern, expr_data: n.expr_data }
+  Node { name: n.name, ident: n.ident, span: n.span, ident_span: n.ident_span, children: n.children, connective: n.connective, params: n.params, inferred: n.inferred, return_cardinality: Required, uses: n.uses, body: n.body, transport: n.transport, properties: n.properties, type_annotation: n.type_annotation, is_self_recursive: n.is_self_recursive, has_non_tail_self_call: n.has_non_tail_self_call, match_pattern: n.match_pattern, expr_data: n.expr_data }
 }
diff --git a/src/v2/02_parse.dag b/src/v2/02_parse.dag
index ad85a23aca9..f8fb5880187 100644
--- a/src/v2/02_parse.dag
+++ b/src/v2/02_parse.dag
@@ -61,7 +61,7 @@ import v2.std.core {
   error_type, is_compiler_error,
   node_name_span, no_span,
   NewlineIndex,
-  InternTable, InternResult, empty_intern_table, intern
+  InternTable, InternResult, empty_intern_table, intern, intern_find_or_empty, pre_intern_tokens
 }
 
 import v2.compiler.languages {
@@ -880,7 +880,8 @@ fn parse_dotted_ident_rest(tokens: List<Token>, state: ParserState, acc: String,
 // =========================================================================
 
 fn parse(tokens: List<Token>, source_indices: Map<String, NewlineIndex>) -> ParseResult {
-  let state = ParserState { pos: 0, source_indices: source_indices, intern_table: empty_intern_table() }
+  let pre_interned = pre_intern_tokens(tokens: tokens, table: empty_intern_table())
+  let state = ParserState { pos: 0, source_indices: source_indices, intern_table: pre_interned }
   let r = parse_module(tokens: tokens, state: state)
   if has_err(err: r.err) {
     ParseResult { module: none, error: r.err, intern_table: r.state.intern_table }
@@ -923,6 +924,7 @@ fn parse_module(tokens: List<Token>, state: ParserState) -> ModuleResult {
   let mod_ir = intern(table: s.intern_table, s: mod_name)
   let s = with(s, { intern_table: mod_ir.table })
   let mod = module_node(name: mod_name, imports: imports, items: items, span: start_span)
+  let mod = with(mod, { ident: mod_ir.id })
   ModuleResult { module: mod, state: s, err: none }
 }
 
@@ -986,11 +988,17 @@ fn parse_import(tokens: List<Token>, state: ParserState) -> ImportResult {
     if has_err(err: r.err) { return ImportResult { import: err_import, state: r.state, err: r.err } }
     let s = skip_newlines(tokens: tokens, state: r.state)
     let imp = import_node(module_path: mod_path, is_all: false, specific_names: names, span: start_span)
+    let imp_ir = intern(table: s.intern_table, s: mod_path)
+    let s = with(s, { intern_table: imp_ir.table })
+    let imp = with(imp, { ident: imp_ir.id })
     ImportResult { import: imp, state: s, err: none }
   } else {
     // Bare import (no braces): import all from module.
     let s = skip_newlines(tokens: tokens, state: s)
     let imp = import_node(module_path: mod_path, is_all: true, specific_names: [], span: start_span)
+    let imp_ir = intern(table: s.intern_table, s: mod_path)
+    let s = with(s, { intern_table: imp_ir.table })
+    let imp = with(imp, { ident: imp_ir.id })
     ImportResult { import: imp, state: s, err: none }
   }
 }
diff --git a/src/v2/05_emit_rust.dag b/src/v2/05_emit_rust.dag
index f6aee4b5dd7..0ed1265884f 100644
--- a/src/v2/05_emit_rust.dag
+++ b/src/v2/05_emit_rust.dag
@@ -3554,7 +3554,43 @@ fn emit_typed_record_lit(type_name: String?, fields: List<Node>, parent_enum: St
           } else { val_str }
           concat("    ", emit_ident(name: f_name, target: Rust), ": ", field_val, ",")
         )
-        let all_field_strs = field_strs
+        // Fill default values for struct fields not explicitly set in .dag source.
+        // Only emits defaults if ALL missing fields have known zero values — this avoids
+        // false positives from cross-module type name collisions in the summary registry.
+        let provided_names = fields |> map(f => field_init_node_name_at(n: f, source_indices: scope.type_env.source_indices))
+        let provided_set = fold(provided_names, init: empty_map(), f: (acc, n) => map_insert(acc, n, true))
+        let summary = lookup_emit_type_summary(emit_info: emit_info, type_name: tn)
+        let default_strs = match summary {
+          Some { value: s } =>
+            let fs = s.field_summaries
+            let ftm = s.field_type_map
+            let missing = map_keys(fs) |> filter(k => !emit_map_has(m: provided_set, key: k))
+            let all_defaultable = missing |> all(fname =>
+              let has_zv = match map_get(ftm, fname) {
+                Some { value: ft } => match rust_zero_value(type_name: ft) { Some { value: _ } => true, None => false }
+                None => false
+              }
+              has_zv || is_optional_struct_field(emit_info: emit_info, struct_name: tn, field_name: fname)
+            )
+            if all_defaultable {
+              missing |> flat_map(fname =>
+                if is_optional_struct_field(emit_info: emit_info, struct_name: tn, field_name: fname) {
+                  [concat("    ", emit_ident(name: fname, target: Rust), ": None,")]
+                } else {
+                  match map_get(ftm, fname) {
+                    Some { value: ft } =>
+                      match rust_zero_value(type_name: ft) {
+                        Some { value: zv } => [concat("    ", emit_ident(name: fname, target: Rust), ": ", zv, ",")]
+                        None => []
+                      }
+                    None => []
+                  }
+                }
+              )
+            } else { [] }
+          None => []
+        }
+        let all_field_strs = concat(field_strs, default_strs)
         let fields_str = all_field_strs |> join(separator: "\n")
         let raw = concat(display_tn, " {\n", fields_str, "\n}")
         // Rc wrapping is the caller's responsibility (data_decl_body, emit_typed_expr, etc.).
@@ -3564,6 +3600,14 @@ fn emit_typed_record_lit(type_name: String?, fields: List<Node>, parent_enum: St
   }
 }
 
+// Zero-value for a Rust type, used to fill struct fields not set in .dag source.
+// Returns none if the type has no obvious zero-value (caller must set it explicitly).
+fn rust_zero_value(type_name: String) -> String? {
+  if type_name == "Int" { Some { value: "0" } }
+  else if type_name == "Bool" { Some { value: "false" } }
+  else if type_name == "String" { Some { value: concat("\"\"", ".to_string()") } }
+  else { none }
+}
 
 fn emit_typed_bin_op(op: BinOp, algebra_field: AlgebraFieldKind?, left: Node, right: Node, registry: Map<String, ItemInfo>, scope: InferScope, depth: Int, shared_types: Map<String, Bool>, emit_info: EmitGraphInfo) -> String {
   let l_str = emit_typed_expr(texpr: left, registry: registry, scope: scope, depth: depth, shared_types: shared_types, emit_info: emit_info, fuel: 1024)
diff --git a/src/v2/stage0/src/v2_compiler_compile.rs b/src/v2/stage0/src/v2_compiler_compile.rs
index 7da39ca3d7d..6914eec75df 100644
--- a/src/v2/stage0/src/v2_compiler_compile.rs
+++ b/src/v2/stage0/src/v2_compiler_compile.rs
@@ -569,7 +569,7 @@ pub fn front_end_sources(sources: Rc<Vec<Rc<SourceFile>>>) -> Rc<FrontendResult>
 }), |acc: Rc<FrontendAccum>, s: Rc<SourceFile>| { let acc = Rc::try_unwrap(acc).unwrap_or_else(|rc| (*rc).clone()); {
             let tokens = tokenize(&s.content.clone(), s.path.clone());
 let si = build_newline_index(s.path.clone(), &s.content.clone());
-let pr = parse(tokens.clone(), v2_rt::rc_map_insert(v2_rt::rc_empty_map::<Rc<NewlineIndex>>(), si.file.clone(), si.clone()));
+let pr = parse(&tokens, v2_rt::rc_map_insert(v2_rt::rc_empty_map::<Rc<NewlineIndex>>(), si.file.clone(), si.clone()));
 Rc::new(FrontendAccum {
     parse_results: v2_rt::rc_list_push(acc.parse_results, pr.clone()),
     newline_indices: v2_rt::rc_list_push(acc.newline_indices, si.clone()),
diff --git a/src/v2/stage0/src/v2_compiler_emit_rust.rs b/src/v2/stage0/src/v2_compiler_emit_rust.rs
index 27c8386eb49..07152dbb14a 100644
--- a/src/v2/stage0/src/v2_compiler_emit_rust.rs
+++ b/src/v2/stage0/src/v2_compiler_emit_rust.rs
@@ -71,6 +71,7 @@ pub fn type_variable_node(id: String) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -3634,7 +3635,43 @@ let field_val = if needs_wrap.clone() {
                             };
 v2_rt::concat(v2_rt::concat(v2_rt::concat(v2_rt::concat("    ".to_string(), emit_ident(f_name.clone(), RenderTarget::Rust)), ": ".to_string()), field_val.clone()), ",".to_string())
 }); } __result });
-let all_field_strs = field_strs;
+let provided_names = Rc::new({ let mut __result = Vec::new(); for f in fields.clone().iter().cloned() { __result.push(field_init_node_name_at(f.clone(), scope.type_env.clone().source_indices.clone())); } __result });
+let provided_set = provided_names.iter().cloned().fold(v2_rt::rc_empty_map::<bool>(), |acc: Rc<HashMap<String, bool>>, n: String| v2_rt::rc_map_insert(acc.clone(), n.clone(), true));
+let summary = lookup_emit_type_summary(emit_info.clone(), tn.clone());
+let default_strs = match summary {
+    Some(s) => {
+                            let fs = s.field_summaries.clone();
+let ftm = s.field_type_map.clone();
+let missing = Rc::new({ let mut __result = Vec::new(); for k in Rc::new(v2_rt::map_keys(&fs)).iter().cloned() { if !emit_map_has(provided_set.clone(), k.clone()) { __result.push(k); } } __result });
+let all_defaultable = { let mut __all = true; for fname in missing.clone().iter().cloned() { if !({
+                                let has_zv = match v2_rt::map_get(&ftm, fname.clone()) {
+    Some(ft) => match rust_zero_value(&ft) {
+    Some(_) => true,
+    None => false,
+},
+    None => false,
+};
+(has_zv.clone() || is_optional_struct_field(emit_info.clone(), tn.clone(), fname.clone()))
+}) { __all = false; break; } } __all };
+if all_defaultable {
+                                Rc::new({ let mut __result = Vec::new(); for fname in missing.clone().iter().cloned() { __result.extend((*if is_optional_struct_field(emit_info.clone(), tn.clone(), fname.clone()) {
+                                    Rc::new(vec![v2_rt::concat(v2_rt::concat("    ".to_string(), emit_ident(fname.clone(), RenderTarget::Rust)), ": None,".to_string())])
+                                } else {
+                                    match v2_rt::map_get(&ftm, fname.clone()) {
+    Some(ft) => match rust_zero_value(&ft) {
+    Some(zv) => Rc::new(vec![v2_rt::concat(v2_rt::concat(v2_rt::concat(v2_rt::concat("    ".to_string(), emit_ident(fname.clone(), RenderTarget::Rust)), ": ".to_string()), zv.clone()), ",".to_string())]),
+    None => Rc::new(vec![]),
+},
+    None => Rc::new(vec![]),
+}
+                                }).iter().cloned()); } __result })
+                            } else {
+                                Rc::new(vec![])
+                            }
+},
+    None => Rc::new(vec![]),
+};
+let all_field_strs = v2_rt::concat(field_strs, default_strs);
 let fields_str = all_field_strs.join(&"\n".to_string());
 let raw = v2_rt::concat(v2_rt::concat(v2_rt::concat(display_tn, " {\n".to_string()), fields_str), "\n}".to_string());
 raw
@@ -3646,6 +3683,22 @@ raw
 }
 }
 
+pub fn rust_zero_value(type_name: &String) -> Option<String> {
+    if (type_name.clone().as_str() == "Int".to_string().as_str()) {
+        Some("0".to_string())
+    } else {
+        if (type_name.clone().as_str() == "Bool".to_string().as_str()) {
+            Some("false".to_string())
+        } else {
+            if (type_name.clone().as_str() == "String".to_string().as_str()) {
+                Some(v2_rt::concat("\"\"".to_string(), ".to_string()".to_string()))
+            } else {
+                None
+            }
+        }
+    }
+}
+
 pub fn emit_typed_bin_op(op: &BinOp, algebra_field: Option<AlgebraFieldKind>, left: &Rc<Node>, right: &Rc<Node>, registry: &Rc<HashMap<String, Rc<ItemInfo>>>, scope: &Rc<InferScope>, depth: i64, shared_types: &Rc<HashMap<String, bool>>, emit_info: &Rc<EmitGraphInfo>) -> String {
     {
         let l_str = emit_typed_expr(left.clone(), registry.clone(), &scope, depth.clone(), shared_types.clone(), emit_info.clone(), 1024);
diff --git a/src/v2/stage0/src/v2_compiler_infer.rs b/src/v2/stage0/src/v2_compiler_infer.rs
index 331c5185d17..137a0d659ed 100644
--- a/src/v2/stage0/src/v2_compiler_infer.rs
+++ b/src/v2/stage0/src/v2_compiler_infer.rs
@@ -444,6 +444,7 @@ pub fn nominal_ref_node(name: &String, span: Rc<SourceSpan>, ident_span: Option<
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -589,6 +590,7 @@ pub fn type_variable_node(id: String) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -947,6 +949,7 @@ let fold_callable = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let lam_value = arg_value(&a);
 let prov_map = match (*elem_provenance.clone()).clone() {
@@ -1332,6 +1335,7 @@ let final_receiver = if ((returns_receiver_self && is_fully_resolved(&bridge_res
     has_non_tail_self_call: receiver.has_non_tail_self_call.clone(),
     match_pattern: receiver.match_pattern.clone(),
     expr_data: receiver.expr_data.clone(),
+    ident: 0,
 })
                             } else {
                                 receiver.clone()
@@ -2249,6 +2253,7 @@ if (type_name.clone() == None) {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })); } __result });
 let anon_node = Rc::new(Node {
     name: "".to_string(),
@@ -2268,6 +2273,7 @@ let anon_node = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let typed_field_nodes = typed_fields;
 let texpr = make_expr_node(Rc::new(ExprData::ExprRecordLit {
@@ -3399,6 +3405,7 @@ Rc::new(Node {
     call_semantics: cs.clone(),
     descent_evidence: Some(evidence),
 }),
+    ident: 0,
 })
 },
     ExprData::ExprMatch => {
@@ -3600,6 +3607,7 @@ Rc::new(Node {
     has_non_tail_self_call: body.has_non_tail_self_call.clone(),
     match_pattern: body.match_pattern.clone(),
     expr_data: body.expr_data.clone(),
+    ident: 0,
 })
 },
     ExprData::ExprLet => {
@@ -3667,6 +3675,7 @@ Rc::new(Node {
     has_non_tail_self_call: body.has_non_tail_self_call.clone(),
     match_pattern: body.match_pattern.clone(),
     expr_data: body.expr_data.clone(),
+    ident: 0,
 })
 },
     ExprData::ExprBlock => {
@@ -3744,6 +3753,7 @@ Rc::new(Node {
     has_non_tail_self_call: body.has_non_tail_self_call.clone(),
     match_pattern: body.match_pattern.clone(),
     expr_data: body.expr_data.clone(),
+    ident: 0,
 })
 },
     ExprData::ExprMethodCall { .. } => {
@@ -3900,6 +3910,7 @@ Rc::new(Node {
     has_non_tail_self_call: body.has_non_tail_self_call.clone(),
     match_pattern: body.match_pattern.clone(),
     expr_data: body.expr_data.clone(),
+    ident: 0,
 })
 }
             } else {
@@ -3955,6 +3966,7 @@ Rc::new(Node {
     has_non_tail_self_call: body.has_non_tail_self_call.clone(),
     match_pattern: body.match_pattern.clone(),
     expr_data: body.expr_data.clone(),
+    ident: 0,
 })
 },
     _ => map_children(&body, |child| annotate_descent(&child, &ctx)),
@@ -4271,6 +4283,7 @@ let val_result = infer_expr(&val, &scope, &None);
     has_non_tail_self_call: p.has_non_tail_self_call.clone(),
     match_pattern: p.match_pattern.clone(),
     expr_data: p.expr_data.clone(),
+    ident: 0,
 }), val_result.diagnostics.clone())
 }); } __result });
 Rc::new(InferPropertiesResult {
@@ -4304,6 +4317,7 @@ let val_result = infer_expr(&val, &scope, &None);
     has_non_tail_self_call: p.has_non_tail_self_call.clone(),
     match_pattern: p.match_pattern.clone(),
     expr_data: p.expr_data.clone(),
+    ident: 0,
 }), val_result.diagnostics.clone())
 }
         } else {
@@ -4343,6 +4357,7 @@ Rc::new(InferTransportResult {
     has_non_tail_self_call: t.has_non_tail_self_call.clone(),
     match_pattern: t.match_pattern.clone(),
     expr_data: t.expr_data.clone(),
+    ident: 0,
 })),
     diagnostics: prop_result.diagnostics.clone(),
 })
@@ -4387,6 +4402,7 @@ if ((item.connective.clone() != Connective::NoConnective) && (item.transport.clo
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(transport_diags, props_diags),
 })
@@ -4433,6 +4449,7 @@ Rc::new(TypedItemResult {
     has_non_tail_self_call: expr_has_non_tail_self_call(&body_typed, &item.name.clone(), true, &scope.type_env.clone().source_indices.clone()),
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(v2_rt::concat(transport_diags, props_diags), body_diags),
 })
@@ -4463,6 +4480,7 @@ Rc::new(TypedItemResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(v2_rt::concat(transport_diags, props_diags), body_diags),
 })
@@ -4504,6 +4522,7 @@ Rc::new(TypedItemResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(v2_rt::concat(transport_diags, props_diags), val_diags),
 })
@@ -4535,6 +4554,7 @@ Rc::new(TypedItemResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(transport_diags, props_diags),
 })
@@ -4564,6 +4584,7 @@ Rc::new(TypedItemResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(transport_diags, props_diags),
 })
@@ -4627,6 +4648,7 @@ let kernel_bindings_base = Rc::new(v2_rt::map_keys(&kernel_type_set())).iter().c
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     provenance: Rc::new(SubValueRelation::SubValueUnknown),
 })));
@@ -4651,6 +4673,7 @@ let kernel_bindings = v2_rt::rc_map_insert(kernel_bindings_base, "Unit".to_strin
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     provenance: Rc::new(SubValueRelation::SubValueUnknown),
 }));
@@ -4674,6 +4697,7 @@ let some_value_field = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let some_variant = Rc::new(Node {
     name: "Some".to_string(),
@@ -4693,6 +4717,7 @@ let some_variant = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let kernel_optional = Rc::new(Node {
     name: "Optional".to_string(),
@@ -4712,6 +4737,7 @@ let kernel_optional = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let kernel_bindings = v2_rt::rc_map_insert(kernel_bindings.clone(), "Optional".to_string(), Rc::new(TypeBinding {
     name: "Optional".to_string(),
@@ -4795,6 +4821,7 @@ if has_structure.clone() {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     name: item.name.clone(),
@@ -4823,6 +4850,7 @@ v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     name: item.name.clone(),
@@ -4861,6 +4889,7 @@ v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     name: item.name.clone(),
@@ -4956,6 +4985,7 @@ let kernel_bindings = Rc::new(v2_rt::map_keys(&kernel_type_set())).iter().cloned
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     provenance: Rc::new(SubValueRelation::SubValueUnknown),
 })));
@@ -4979,6 +5009,7 @@ let some_value_field = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let some_variant = Rc::new(Node {
     name: "Some".to_string(),
@@ -4998,6 +5029,7 @@ let some_variant = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let kernel_optional = Rc::new(Node {
     name: "Optional".to_string(),
@@ -5017,6 +5049,7 @@ let kernel_optional = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let kernel_bindings = v2_rt::rc_map_insert(kernel_bindings.clone(), "Optional".to_string(), Rc::new(TypeBinding {
     name: "Optional".to_string(),
@@ -5092,6 +5125,7 @@ if has_structure.clone() {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     name: item.name.clone(),
@@ -5120,6 +5154,7 @@ v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 v2_rt::rc_map_insert(acc.clone(), item.name.clone(), Rc::new(TypeBinding {
     name: item.name.clone(),
diff --git a/src/v2/stage0/src/v2_compiler_infer_method.rs b/src/v2/stage0/src/v2_compiler_infer_method.rs
index 6173fdb8532..b8e5a11ea16 100644
--- a/src/v2/stage0/src/v2_compiler_infer_method.rs
+++ b/src/v2/stage0/src/v2_compiler_infer_method.rs
@@ -35,6 +35,7 @@ pub fn type_variable_node(id: String) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
diff --git a/src/v2/stage0/src/v2_compiler_infer_patterns.rs b/src/v2/stage0/src/v2_compiler_infer_patterns.rs
index 620352cfa73..0db1ec35d8e 100644
--- a/src/v2/stage0/src/v2_compiler_infer_patterns.rs
+++ b/src/v2/stage0/src/v2_compiler_infer_patterns.rs
@@ -85,6 +85,7 @@ let value_field = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let some_node = Rc::new(Node {
     name: "Some".to_string(),
@@ -104,6 +105,7 @@ let some_node = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 some_node
 }
diff --git a/src/v2/stage0/src/v2_compiler_infer_resolve.rs b/src/v2/stage0/src/v2_compiler_infer_resolve.rs
index 9a86711f38f..ee349e79363 100644
--- a/src/v2/stage0/src/v2_compiler_infer_resolve.rs
+++ b/src/v2/stage0/src/v2_compiler_infer_resolve.rs
@@ -157,6 +157,7 @@ Rc::new(Node {
     has_non_tail_self_call: child.has_non_tail_self_call.clone(),
     match_pattern: child.match_pattern.clone(),
     expr_data: child.expr_data.clone(),
+    ident: 0,
 })
 }
                     } else {
@@ -186,6 +187,7 @@ Rc::new(Node {
     has_non_tail_self_call: n.has_non_tail_self_call.clone(),
     match_pattern: n.match_pattern.clone(),
     expr_data: n.expr_data.clone(),
+    ident: 0,
 })
 }
             }
@@ -269,6 +271,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: base_diags,
 })
@@ -312,6 +315,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: rt_diags.clone(),
 })
@@ -338,6 +342,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: all_diags,
 })
@@ -400,6 +405,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: rt_diags.clone(),
 })
@@ -426,6 +432,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: field_diags.clone(),
 })
@@ -451,6 +458,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: all_diags,
 })
@@ -517,6 +525,7 @@ let resolved_node = Rc::new(Node {
     has_non_tail_self_call: n.has_non_tail_self_call.clone(),
     match_pattern: n.match_pattern.clone(),
     expr_data: n.expr_data.clone(),
+    ident: 0,
 });
 Rc::new(NodeResolveResult {
     resolved: resolved_node,
@@ -546,6 +555,7 @@ let result = Rc::new(NodeResolveResult {
     has_non_tail_self_call: n.has_non_tail_self_call.clone(),
     match_pattern: n.match_pattern.clone(),
     expr_data: n.expr_data.clone(),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(arity_diags, arg_diags),
 });
@@ -611,6 +621,7 @@ let resolved_key_child = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let resolved_val_child = Rc::new(Node {
     name: val_param_name,
@@ -632,6 +643,7 @@ let resolved_val_child = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(NodeResolveResult {
     resolved: Rc::new(Node {
@@ -652,6 +664,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(key_diags, val_diags),
 })
@@ -694,6 +707,7 @@ let resolved_child = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(NodeResolveResult {
     resolved: Rc::new(Node {
@@ -714,6 +728,7 @@ Rc::new(NodeResolveResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: el_diags,
 })
@@ -1522,6 +1537,7 @@ let env = tp_names.iter().cloned().fold(env.clone(), |e: Rc<TypeEnv>, tp_name: S
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     provenance: Rc::new(SubValueRelation::SubValueUnknown),
 })),
@@ -1617,6 +1633,7 @@ Rc::new(ItemResult {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     diagnostics: v2_rt::concat(v2_rt::concat(v2_rt::concat(v2_rt::concat(v2_rt::concat(v2_rt::concat(v2_rt::concat(param_diags, ret_diags), use_diags), body_diags), anno_diags), transport_diags), prop_diags), child_diags),
 })
diff --git a/src/v2/stage0/src/v2_compiler_infer_service.rs b/src/v2/stage0/src/v2_compiler_infer_service.rs
index 91a23191f20..09358a45856 100644
--- a/src/v2/stage0/src/v2_compiler_infer_service.rs
+++ b/src/v2/stage0/src/v2_compiler_infer_service.rs
@@ -259,6 +259,7 @@ match matching.first().cloned() {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })); } __result }),
     connective: Connective::Conj,
     params: Rc::new(vec![]),
@@ -273,6 +274,7 @@ match matching.first().cloned() {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     op_params: op.params.clone(),
 }))
diff --git a/src/v2/stage0/src/v2_compiler_infer_types.rs b/src/v2/stage0/src/v2_compiler_infer_types.rs
index 0d3b109d778..5046d1a2371 100644
--- a/src/v2/stage0/src/v2_compiler_infer_types.rs
+++ b/src/v2/stage0/src/v2_compiler_infer_types.rs
@@ -49,6 +49,7 @@ pub fn type_variable_node(id: String) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -158,6 +159,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }), Rc::new(Node {
     name: val_id.clone(),
     span: make_span(0, 0),
@@ -178,6 +180,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })]),
     connective: Connective::NoConnective,
     params: Rc::new(vec![]),
@@ -192,6 +195,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -223,6 +227,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })]),
     connective: Connective::NoConnective,
     params: Rc::new(vec![]),
@@ -237,6 +242,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -269,6 +275,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }), Rc::new(Node {
     name: val_name,
     span: make_span(0, 0),
@@ -289,6 +296,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })]),
     connective: Connective::NoConnective,
     params: Rc::new(vec![]),
@@ -303,6 +311,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -328,6 +337,7 @@ pub fn make_callable_type(func_params: Rc<Vec<Rc<Node>>>, ret: Rc<Node>) -> Rc<N
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -356,6 +366,7 @@ pub fn make_tuple_type(first: Rc<Node>, second: Rc<Node>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }), Rc::new(Node {
     name: "second".to_string(),
     span: make_span(0, 0),
@@ -376,6 +387,7 @@ pub fn make_tuple_type(first: Rc<Node>, second: Rc<Node>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })]),
     connective: Connective::Conj,
     params: Rc::new(vec![]),
@@ -390,6 +402,7 @@ pub fn make_tuple_type(first: Rc<Node>, second: Rc<Node>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -414,6 +427,7 @@ pub fn algebra_value_field(name: &String, type_node: Rc<Node>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -441,6 +455,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -464,6 +479,7 @@ pub fn enrich_base_with_fields(name: String, base: &Rc<Node>, fields: Rc<Vec<Rc<
     has_non_tail_self_call: base.has_non_tail_self_call.clone(),
     match_pattern: base.match_pattern.clone(),
     expr_data: base.expr_data.clone(),
+    ident: 0,
 })
 }
 
diff --git a/src/v2/stage0/src/v2_compiler_parse.rs b/src/v2/stage0/src/v2_compiler_parse.rs
index 8c4e6395a28..05350dad237 100644
--- a/src/v2/stage0/src/v2_compiler_parse.rs
+++ b/src/v2/stage0/src/v2_compiler_parse.rs
@@ -6,7 +6,7 @@ use std::rc::Rc;
 use crate::v2_rt;
 use crate::NonEmptyVec;
 use crate::NonEmptyBTreeSet;
-pub use crate::v2_std_core::{module_node, import_node, Node, InferredNode, Connective, is_container_type, Cardinality, make_param_node, param_node_type_expr, param_node_default_value, make_field_node, field_node_name_at, field_node_type_expr, field_node_cardinality, field_node_default_value, field_node_from_key, make_variant_node, variant_node_name_at, variant_node_fields, leaf_node_with_span, ExprData, make_expr_node, make_named_expr_node, make_expr_error_node, expr_var_name_at, field_access_field_at, expr_call_func_at, make_arg_node, arg_name_at, arg_value, make_arm_node, make_field_init_node, make_resource_use_node, make_text_part_node, make_interp_part_node, MatchPattern, make_field_binding_node, field_binding_pattern, LiteralValue, ExprErrorKind, BinOp, UnaryOpKind, StringPart, local_transport_node, rest_transport_node, shell_transport_node, file_transport_node, transport_url_key, transport_path_key, transport_method_key, transport_path_template_key, transport_query_key, transport_body_key, transport_stdin_key, transport_response_format_key, transport_headers_key, service_config_properties, OperationModifier, Token, TokenShape, SourceSpan, make_span, ErrorNode, make_error_node, with_required_cardinality, error_type, is_compiler_error, node_name_span, no_span, NewlineIndex, InternTable, InternResult, empty_intern_table, intern, CompilerDiagnostic};
+pub use crate::v2_std_core::{module_node, import_node, Node, InferredNode, Connective, is_container_type, Cardinality, make_param_node, param_node_type_expr, param_node_default_value, make_field_node, field_node_name_at, field_node_type_expr, field_node_cardinality, field_node_default_value, field_node_from_key, make_variant_node, variant_node_name_at, variant_node_fields, leaf_node_with_span, ExprData, make_expr_node, make_named_expr_node, make_expr_error_node, expr_var_name_at, field_access_field_at, expr_call_func_at, make_arg_node, arg_name_at, arg_value, make_arm_node, make_field_init_node, make_resource_use_node, make_text_part_node, make_interp_part_node, MatchPattern, make_field_binding_node, field_binding_pattern, LiteralValue, ExprErrorKind, BinOp, UnaryOpKind, StringPart, local_transport_node, rest_transport_node, shell_transport_node, file_transport_node, transport_url_key, transport_path_key, transport_method_key, transport_path_template_key, transport_query_key, transport_body_key, transport_stdin_key, transport_response_format_key, transport_headers_key, service_config_properties, OperationModifier, Token, TokenShape, SourceSpan, make_span, ErrorNode, make_error_node, with_required_cardinality, error_type, is_compiler_error, node_name_span, no_span, NewlineIndex, InternTable, InternResult, empty_intern_table, intern, intern_find_or_empty, pre_intern_tokens, CompilerDiagnostic};
 use crate::v2_std_core::InferredNode::{Resolved, CompilerError, TypeVariable};
 use crate::v2_std_core::Connective::{Conj, Disj, NoConnective, Arrow};
 use crate::v2_std_core::Cardinality::{Required, CardOptional};
@@ -1642,6 +1642,7 @@ pub fn leaf_type_node(name: &String, span: &Rc<SourceSpan>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -1710,12 +1711,13 @@ continue;
 }
 }
 
-pub fn parse(tokens: Rc<Vec<Rc<Token>>>, source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>) -> Rc<ParseResult> {
+pub fn parse(tokens: &Rc<Vec<Rc<Token>>>, source_indices: Rc<HashMap<String, Rc<NewlineIndex>>>) -> Rc<ParseResult> {
     {
-        let state = Rc::new(ParserState {
+        let pre_interned = pre_intern_tokens(tokens.clone(), empty_intern_table());
+let state = Rc::new(ParserState {
     pos: 0,
     source_indices: source_indices,
-    intern_table: empty_intern_table(),
+    intern_table: pre_interned,
 });
 let r = parse_module(&tokens, state);
 if has_err(r.err.clone()) {
@@ -1782,8 +1784,9 @@ let s = r.state.clone();
 let mod_ir = intern(&s.intern_table.clone(), &mod_name);
 let s = Rc::new(ParserState { intern_table: mod_ir.table.clone(), ..(*s.clone()).clone() });
 let r#mod = module_node(&mod_name, imports, items, &start_span);
+let r#mod = Rc::new(Node { ident: mod_ir.id.clone(), ..(*r#mod.clone()).clone() });
 Rc::new(ModuleResult {
-    module: r#mod,
+    module: r#mod.clone(),
     state: s.clone(),
     err: None,
 })
@@ -1904,8 +1907,11 @@ if has_err(r.err.clone()) {
                 }
 let s = skip_newlines(tokens.clone(), r.state.clone());
 let imp = import_node(&mod_path, false, names, &start_span);
+let imp_ir = intern(&s.intern_table.clone(), &mod_path);
+let s = Rc::new(ParserState { intern_table: imp_ir.table.clone(), ..(*s.clone()).clone() });
+let imp = Rc::new(Node { ident: imp_ir.id.clone(), ..(*imp.clone()).clone() });
 Rc::new(ImportResult {
-    import: imp,
+    import: imp.clone(),
     state: s.clone(),
     err: None,
 })
@@ -1914,8 +1920,11 @@ Rc::new(ImportResult {
             {
                 let s = skip_newlines(tokens.clone(), s.clone());
 let imp = import_node(&mod_path, true, Rc::new(vec![]), &start_span);
+let imp_ir = intern(&s.intern_table.clone(), &mod_path);
+let s = Rc::new(ParserState { intern_table: imp_ir.table.clone(), ..(*s.clone()).clone() });
+let imp = Rc::new(Node { ident: imp_ir.id.clone(), ..(*imp.clone()).clone() });
 Rc::new(ImportResult {
-    import: imp,
+    import: imp.clone(),
     state: s.clone(),
     err: None,
 })
@@ -2006,6 +2015,7 @@ match form {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
     state: s.clone(),
     err: Some(parse_error("expected item declaration (type, fn, func, service, resource, data, extern, pattern, interface)".to_string(), current_span(tokens.clone(), s.clone()))),
@@ -2152,6 +2162,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &state, &Rc::new(ExpectedToken::ExpectKeyword {
     text: form.keyword.clone(),
@@ -2246,6 +2257,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -2276,6 +2288,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -2301,6 +2314,7 @@ pub fn outputs_to_inferred(outputs: &Rc<Vec<Rc<Node>>>, span: Rc<SourceSpan>, so
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }),
 }))
     } else {
@@ -2329,6 +2343,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -2352,6 +2367,7 @@ pub fn make_capability_node(name: String, ident_span: Option<Rc<SourceSpan>>, in
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -2376,6 +2392,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &state, &Rc::new(ExpectedToken::ExpectKeyword {
     text: "type".to_string(),
@@ -2411,6 +2428,7 @@ pub fn parse_type_after_kw(tokens: &Rc<Vec<Rc<Token>>>, state: &Rc<ParserState>,
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect_ident(&tokens, &state);
 if has_err(r.err.clone()) {
@@ -2447,6 +2465,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 if has_err(r.err.clone()) {
                     return Rc::new(ItemResult {
@@ -2483,6 +2502,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2520,6 +2540,7 @@ parse_type_body_after_eq(&tokens, &s, &name, &name_span, &start_span, &type_para
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2556,6 +2577,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let s = skip_newlines(tokens.clone(), prefix.state.clone());
 let e = eat(&tokens, &s, Rc::new(ExpectedToken::ExpectLBrace));
@@ -2597,6 +2619,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2634,6 +2657,7 @@ parse_type_body_after_eq(&tokens, &s, &name, &name_span, &start_span, &type_para
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2667,6 +2691,7 @@ pub fn parse_type_body_after_eq(tokens: &Rc<Vec<Rc<Token>>>, state: &Rc<ParserSt
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 if tok_is_ident(peek(tokens.clone(), state.clone())) {
             {
@@ -2720,6 +2745,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2765,6 +2791,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2812,6 +2839,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -2853,6 +2881,7 @@ let predicate_node = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let refined = Rc::new(Node {
     name: "".to_string(),
@@ -2872,6 +2901,7 @@ let refined = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(TypeResult {
     type_expr: refined,
@@ -3394,6 +3424,7 @@ let te = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(TypeResult {
     type_expr: te,
@@ -3502,6 +3533,7 @@ let te = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 maybe_optional(tokens.clone(), &ret.state.clone(), &te, start_span.clone())
 }
@@ -3591,6 +3623,7 @@ let te = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 maybe_optional(tokens.clone(), &r3.state.clone(), &te, start_span.clone())
 }
@@ -3720,6 +3753,7 @@ if e.consumed.clone() {
     has_non_tail_self_call: te.has_non_tail_self_call.clone(),
     match_pattern: te.match_pattern.clone(),
     expr_data: te.expr_data.clone(),
+    ident: 0,
 });
 Rc::new(TypeResult {
     type_expr: ote,
@@ -3929,6 +3963,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &state, &Rc::new(ExpectedToken::ExpectKeyword {
     text: "fn".to_string(),
@@ -3964,6 +3999,7 @@ pub fn parse_fn_after_kw(tokens: &Rc<Vec<Rc<Token>>>, state: Rc<ParserState>, st
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect_ident(&tokens, &state);
 if has_err(r.err.clone()) {
@@ -3993,6 +4029,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = parse_params(&tokens, r.state.clone());
 if has_err(r.err.clone()) {
@@ -4041,6 +4078,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -4076,6 +4114,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = parse_block(&tokens, &skip_newlines(tokens.clone(), prefix.state.clone()));
 if has_err(r.err.clone()) {
@@ -4104,6 +4143,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -4134,6 +4174,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let kw = tok_keyword_text(peek(tokens.clone(), state.clone()));
 let r = if (kw.clone().as_str() == "func".to_string().as_str()) {
@@ -4207,6 +4248,7 @@ pub fn parse_block_item_after_kw(tokens: &Rc<Vec<Rc<Token>>>, state: Rc<ParserSt
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect_ident(&tokens, &state);
 if has_err(r.err.clone()) {
@@ -4236,6 +4278,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = parse_params(&tokens, r.state.clone());
 if has_err(r.err.clone()) {
@@ -4302,6 +4345,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -4336,6 +4380,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = parse_block(&tokens, &skip_newlines(tokens.clone(), prefix.state.clone()));
 if has_err(r.err.clone()) {
@@ -4364,6 +4409,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -4393,6 +4439,7 @@ pub fn parse_no_body_from_prefix(prefix: &Rc<ItemPrefixResult>, start_span: Rc<S
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -4532,6 +4579,7 @@ let res_node = Rc::new(Node {
     has_non_tail_self_call: r3.type_expr.clone().has_non_tail_self_call.clone(),
     match_pattern: r3.type_expr.clone().match_pattern.clone(),
     expr_data: r3.type_expr.clone().expr_data.clone(),
+    ident: 0,
 });
 let ru = make_resource_use_node(&name, res_node, start_span.clone(), r.span.clone());
 Rc::new(ResUseResult {
@@ -4670,6 +4718,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &state, &Rc::new(ExpectedToken::ExpectKeyword {
     text: "service".to_string(),
@@ -4705,6 +4754,7 @@ pub fn parse_service_after_kw(tokens: &Rc<Vec<Rc<Token>>>, state: Rc<ParserState
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r_ns = expect_name(&tokens, &state);
 if has_err(r_ns.err.clone()) {
@@ -4736,6 +4786,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &r.state.clone(), &Rc::new(ExpectedToken::ExpectLBrace));
 if has_err(r.err.clone()) {
@@ -4790,6 +4841,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -6694,6 +6746,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &state, &Rc::new(ExpectedToken::ExpectKeyword {
     text: "resource".to_string(),
@@ -6729,6 +6782,7 @@ pub fn parse_resource_after_kw(tokens: &Rc<Vec<Rc<Token>>>, state: Rc<ParserStat
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect_ident(&tokens, &state);
 if has_err(r.err.clone()) {
@@ -6758,6 +6812,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &r.state.clone(), &Rc::new(ExpectedToken::ExpectLBrace));
 if has_err(r.err.clone()) {
@@ -6801,6 +6856,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -7240,6 +7296,7 @@ let dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &state, &Rc::new(ExpectedToken::ExpectKeyword {
     text: "data".to_string(),
@@ -7275,6 +7332,7 @@ pub fn parse_data_after_kw(tokens: &Rc<Vec<Rc<Token>>>, state: Rc<ParserState>,
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect_ident(&tokens, &state);
 if has_err(r.err.clone()) {
@@ -7304,6 +7362,7 @@ let named_dummy = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let r = expect(&tokens, &r.state.clone(), &Rc::new(ExpectedToken::ExpectColon));
 if has_err(r.err.clone()) {
@@ -7356,6 +7415,7 @@ let item = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 Rc::new(ItemResult {
     item: item,
@@ -7748,6 +7808,7 @@ let node = Rc::new(Node {
     has_non_tail_self_call: node.has_non_tail_self_call.clone(),
     match_pattern: node.match_pattern.clone(),
     expr_data: node.expr_data.clone(),
+    ident: 0,
 });
 Rc::new(ExprResult {
     expr: node.clone(),
@@ -7841,6 +7902,7 @@ let node = Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::ExprLet),
+    ident: 0,
 });
 Rc::new(ExprResult {
     expr: node,
@@ -7905,6 +7967,7 @@ if ((cr.constraints.clone().len() as i64) > 0) {
     has_non_tail_self_call: node.has_non_tail_self_call.clone(),
     match_pattern: node.match_pattern.clone(),
     expr_data: node.expr_data.clone(),
+    ident: 0,
 });
 Rc::new(ExprResult {
     expr: node.clone(),
diff --git a/src/v2/stage0/src/v2_std_core.rs b/src/v2/stage0/src/v2_std_core.rs
index d765fb06a0b..0c8b66b6755 100644
--- a/src/v2/stage0/src/v2_std_core.rs
+++ b/src/v2/stage0/src/v2_std_core.rs
@@ -512,6 +512,7 @@ pub struct DeclaredFuncEnv {
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct Node {
     pub name: String,
+    pub ident: i64,
     pub span: Rc<SourceSpan>,
     pub ident_span: Option<Rc<SourceSpan>>,
     pub children: Rc<Vec<Rc<Node>>>,
@@ -564,6 +565,7 @@ pub fn make_expr_node(expr_data: Rc<ExprData>, children: Rc<Vec<Rc<Node>>>, infe
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: expr_data,
+    ident: 0,
 })
 }
 
@@ -586,6 +588,7 @@ pub fn make_named_expr_node(name: &String, expr_data: Rc<ExprData>, children: Rc
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: expr_data,
+    ident: 0,
 })
 }
 
@@ -614,6 +617,7 @@ pub fn make_expr_error_node(kind: ExprErrorKind, message: &String, span: &Rc<Sou
     kind: kind,
     message: message.clone(),
 }),
+    ident: 0,
 })
 }
 
@@ -641,6 +645,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -669,6 +674,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: Some(pattern),
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -692,6 +698,7 @@ pub fn make_resource_use_node(name: &String, resource: Rc<Node>, span: Rc<Source
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -725,6 +732,7 @@ pub fn make_field_init_node(name: &String, value: Rc<Node>, span: Rc<SourceSpan>
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -747,6 +755,7 @@ pub fn make_field_binding_node(field_name: &String, binding: Rc<MatchPattern>, s
     has_non_tail_self_call: false,
     match_pattern: Some(binding),
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -784,6 +793,7 @@ pub fn make_text_part_node(text: String, span: Rc<SourceSpan>) -> Rc<Node> {
     value: text,
 }),
 }),
+    ident: 0,
 })
 }
 
@@ -806,6 +816,7 @@ pub fn make_interp_part_node(expr: Rc<Node>, span: Rc<SourceSpan>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -833,6 +844,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -917,6 +929,7 @@ let props = match from_key {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })]),
     None => Rc::new(vec![]),
 };
@@ -938,6 +951,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -995,6 +1009,7 @@ pub fn make_variant_node(name: &String, fields: Rc<Vec<Rc<Node>>>, span: Rc<Sour
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -1489,6 +1504,7 @@ pub fn make_transport_node(properties: Rc<Vec<Rc<Node>>>, children: Rc<Vec<Rc<No
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -1545,6 +1561,7 @@ pub fn shell_transport_node(argv: Rc<Vec<Rc<Node>>>, env: Rc<Vec<Rc<Node>>>, std
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 });
 let zero_span = make_span(0, 0);
 let stdin_props = match stdin {
@@ -1570,6 +1587,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -1707,6 +1725,7 @@ pub fn transport_env(t: Rc<Node>, source_indices: Rc<HashMap<String, Rc<NewlineI
 pub fn map_children(node: &Rc<Node>, transform: impl Fn(Rc<Node>) -> Rc<Node> + Clone) -> Rc<Node> {
     Rc::new(Node {
     name: node.name.clone(),
+    ident: node.ident.clone(),
     span: node.span.clone(),
     ident_span: node.ident_span.clone(),
     children: Rc::new({ let mut __result = Vec::new(); for child in node.children.clone().iter().cloned() { __result.push(transform(child.clone())); } __result }),
@@ -1876,6 +1895,7 @@ pub fn module_node(name: &String, imports: Rc<Vec<Rc<Node>>>, items: Rc<Vec<Rc<N
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -1900,6 +1920,7 @@ pub fn import_node(module_path: &String, is_all: bool, specific_names: Rc<Vec<Rc
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 }))
         } else {
             None
@@ -1922,6 +1943,7 @@ Rc::new(Node {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 }
@@ -1961,6 +1983,7 @@ pub fn leaf_node_with_span(name: &String, span: &Rc<SourceSpan>) -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
 }
 
@@ -1993,6 +2016,7 @@ pub fn unit_type() -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
         };
     }
@@ -2020,6 +2044,7 @@ pub fn bool_type() -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
         };
     }
@@ -2047,6 +2072,7 @@ pub fn string_type() -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
         };
     }
@@ -2074,6 +2100,7 @@ pub fn int_type() -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
         };
     }
@@ -2101,6 +2128,7 @@ pub fn float_type() -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
         };
     }
@@ -2128,6 +2156,7 @@ pub fn none_type() -> Rc<Node> {
     has_non_tail_self_call: false,
     match_pattern: None,
     expr_data: Rc::new(ExprData::NoExprData),
+    ident: 0,
 })
         };
     }
@@ -2170,6 +2199,7 @@ pub fn error_type() -> Rc<Node> {
     kind: ExprErrorKind::SemanticExprError,
     message: "unresolved type".to_string(),
 }),
+    ident: 0,
 })
         };
     }
@@ -2342,9 +2372,18 @@ pub fn merge_intern_tables(tables: Rc<Vec<Rc<InternTable>>>) -> Rc<InternTable>
     }))
 }
 
+pub fn pre_intern_tokens(tokens: Rc<Vec<Rc<Token>>>, table: Rc<InternTable>) -> Rc<InternTable> {
+    tokens.iter().cloned().fold(table.clone(), |t: Rc<InternTable>, tok: Rc<Token>| if (tok.text.clone().as_str() != "".to_string().as_str()) {
+        intern(&t, &tok.text.clone()).table.clone()
+    } else {
+        t.clone()
+    })
+}
+
 pub fn with_optional_cardinality(n: &Rc<Node>) -> Rc<Node> {
     Rc::new(Node {
     name: n.name.clone(),
+    ident: n.ident.clone(),
     span: n.span.clone(),
     ident_span: n.ident_span.clone(),
     children: n.children.clone(),
@@ -2367,6 +2406,7 @@ pub fn with_optional_cardinality(n: &Rc<Node>) -> Rc<Node> {
 pub fn with_required_cardinality(n: &Rc<Node>) -> Rc<Node> {
     Rc::new(Node {
     name: n.name.clone(),
+    ident: n.ident.clone(),
     span: n.span.clone(),
     ident_span: n.ident_span.clone(),
     children: n.children.clone(),
diff --git a/src/v2/tests/src/helpers.rs b/src/v2/tests/src/helpers.rs
index f0762ae0810..a37f528fff9 100644
--- a/src/v2/tests/src/helpers.rs
+++ b/src/v2/tests/src/helpers.rs
@@ -40,7 +40,7 @@ pub fn parse_source_named(filename: &str, source: &str) -> Rc<ParseResult> {
     let source_index = v2_compiler::v2_std_core::build_newline_index(filename.to_string(), &source.to_string());
     let mut source_indices = std::collections::HashMap::new();
     source_indices.insert(filename.to_string(), source_index);
-    v2_compiler::v2_compiler_parse::parse(tokens, Rc::new(source_indices))
+    v2_compiler::v2_compiler_parse::parse(&tokens, Rc::new(source_indices))
 }
 
 pub fn assert_parses(source: &str, label: &str) {
diff --git a/src/v2/tests/src/infer_semantics.rs b/src/v2/tests/src/infer_semantics.rs
index 3086802fcec..d3cfab1bcc6 100644
--- a/src/v2/tests/src/infer_semantics.rs
+++ b/src/v2/tests/src/infer_semantics.rs
@@ -34,10 +34,12 @@ fn container_node(kind_name: String, element: Rc<Node>) -> Rc<Node> {
     let sp = make_span(0, 0);
     Rc::new(Node {
         name: kind_name.clone(),
+        ident: 0,
         span: sp.clone(),
         ident_span: default_ident_span(kind_name, sp.clone()),
         children: Rc::new(vec![Rc::new(Node {
             name: param_name.clone(),
+            ident: 0,
             span: sp.clone(),
             ident_span: default_ident_span(param_name, sp.clone()),
             children: Rc::new(vec![]),
@@ -71,11 +73,12 @@ fn map_node(key: Rc<Node>, value: Rc<Node>) -> Rc<Node> {
     let sp = make_span(0, 0);
     Rc::new(Node {
         name: "Map".to_string(),
+        ident: 0,
         span: sp.clone(),
         ident_span: Some(sp.clone()),
         children: Rc::new(vec![
             Rc::new(Node {
-                name: key_name, span: sp.clone(),
+                name: key_name, ident: 0, span: sp.clone(),
                 ident_span: Some(sp.clone()),
                 children: Rc::new(vec![]), connective: Connective::NoConnective,
                 params: Rc::new(vec![]),
@@ -86,7 +89,7 @@ fn map_node(key: Rc<Node>, value: Rc<Node>) -> Rc<Node> {
                 match_pattern: None, expr_data: Rc::new(ExprData::NoExprData),
             }),
             Rc::new(Node {
-                name: val_name, span: sp.clone(),
+                name: val_name, ident: 0, span: sp.clone(),
                 ident_span: Some(sp.clone()),
                 children: Rc::new(vec![]), connective: Connective::NoConnective,
                 params: Rc::new(vec![]),
@@ -332,6 +335,7 @@ fn optional_match_exhaustiveness_accepts_some_and_none() {
 fn resolve_node_uses_node_name_for_lookup() {
     let node_ref = Rc::new(Node {
         name: "User".to_string(),
+        ident: 0,
         span: zero_span(),
         ident_span: Some(Rc::new(v2_compiler::v2_std_core::SourceSpan { file: "".to_string(), start: 0, end: 0 })),
         children: Rc::new(vec![]),
diff --git a/src/v2/tests/src/parse.rs b/src/v2/tests/src/parse.rs
index bbaefd8f456..9b5c0554b38 100644
--- a/src/v2/tests/src/parse.rs
+++ b/src/v2/tests/src/parse.rs
@@ -196,6 +196,35 @@ service weather.api {
     assert!(service_ident.start > service_item.span.start);
 }
 
+#[test]
+fn module_node_ident_is_populated_by_parser() {
+    let source = r#"module my.test.module
+import std.types { String }
+type Foo { value: String }
+"#;
+    let result = parse_source(source);
+    assert!(result.error.is_none(), "parse error: {:?}", result.error);
+
+    let module = result.module.clone().expect("module");
+    // Module ident should be non-zero (interned by parser)
+    assert_ne!(module.ident, 0, "module ident should be non-zero after parsing");
+    // The intern table should be able to recover the name from the ident
+    let recovered_name = v2_compiler::v2_std_core::intern_str(
+        result.intern_table.clone(), module.ident);
+    assert_eq!(recovered_name, "my.test.module",
+        "intern_str(table, module.ident) should recover the module name");
+
+    // Import node ident should also be non-zero
+    let imports = module.params.clone();
+    assert_eq!(imports.len(), 1);
+    let import_node = imports[0].clone();
+    assert_ne!(import_node.ident, 0, "import ident should be non-zero");
+    let import_name = v2_compiler::v2_std_core::intern_str(
+        result.intern_table.clone(), import_node.ident);
+    assert_eq!(import_name, "std.types",
+        "intern_str(table, import.ident) should recover the import path");
+}
+
 #[test]
 fn type_alias_rhs_ident_span_points_at_authored_type_name() {
     let source = r#"module test
@@ -465,11 +494,11 @@ fn parser_scales_linearly_with_token_count() {
     let large_tokens = tokenize(&large_source);
 
     let start = Instant::now();
-    let _small_result = v2_compiler::v2_compiler_parse::parse(small_tokens.clone(), Rc::new(std::collections::HashMap::new()));
+    let _small_result = v2_compiler::v2_compiler_parse::parse(&small_tokens.clone(), Rc::new(std::collections::HashMap::new()));
     let small_time = start.elapsed();
 
     let start = Instant::now();
-    let _large_result = v2_compiler::v2_compiler_parse::parse(large_tokens.clone(), Rc::new(std::collections::HashMap::new()));
+    let _large_result = v2_compiler::v2_compiler_parse::parse(&large_tokens.clone(), Rc::new(std::collections::HashMap::new()));
     let large_time = start.elapsed();
 
     let token_ratio = large_tokens.len() as f64 / small_tokens.len() as f64;
diff --git a/src/v2/tests/src/pipeline.rs b/src/v2/tests/src/pipeline.rs
index 2991f687858..8d4c25433ba 100644
--- a/src/v2/tests/src/pipeline.rs
+++ b/src/v2/tests/src/pipeline.rs
@@ -67,7 +67,7 @@ fn full_dsl_compiles() {
             let content = std::fs::read_to_string(&path)
                 .unwrap_or_else(|e| panic!("failed to read {}: {}", path.display(), e));
             let result =
-                v2_compiler::v2_compiler_parse::parse(v2_compiler::v2_compiler_tokenize::tokenize(
+                v2_compiler::v2_compiler_parse::parse(&v2_compiler::v2_compiler_tokenize::tokenize(
                     &content,
                     path.to_string_lossy().to_string(),
                 ), Rc::new(HashMap::new()));