Change the identity-based dict

Author: nystrom

meta/src/meta/codegen_templates.py

@@ -107,8 +107,6 @@ class BuiltinTemplate:
     "pp_dispatch": BuiltinTemplate("None", ["self.pprint_dispatch({0})"]),
     "get_at": BuiltinTemplate("{0}[{1}]"),
     # Provenance tracking
-    "push_path": BuiltinTemplate("None", ["self.push_path({0})"]),
-    "pop_path": BuiltinTemplate("None", ["self.pop_path()"]),
     "span_start": BuiltinTemplate("self.span_start()"),
     "record_span": BuiltinTemplate("None", ["self.record_span({0})"]),
 }
@@ -197,8 +195,6 @@ class BuiltinTemplate:
     "pp_dispatch": BuiltinTemplate("nothing", ["_pprint_dispatch(pp, {0})"]),
     "get_at": BuiltinTemplate("{0}[{1} + 1]"),
     # Provenance tracking
-    "push_path": BuiltinTemplate("nothing", ["push_path!(parser, {0})"]),
-    "pop_path": BuiltinTemplate("nothing", ["pop_path!(parser)"]),
     "span_start": BuiltinTemplate("span_start(parser)"),
     "record_span": BuiltinTemplate("nothing", ["record_span!(parser, {0})"]),
 }
@@ -291,8 +287,6 @@ class BuiltinTemplate:
     "pp_dispatch": BuiltinTemplate("nil", ["p.pprintDispatch({0})"]),
     "get_at": BuiltinTemplate("{0}[{1}]"),
     # Provenance tracking
-    "push_path": BuiltinTemplate("nil", ["p.pushPath(int({0}))"]),
-    "pop_path": BuiltinTemplate("nil", ["p.popPath()"]),
     "span_start": BuiltinTemplate("int64(p.spanStart())"),
     "record_span": BuiltinTemplate("nil", ["p.recordSpan(int({0}))"]),
 }

meta/src/meta/parser_gen.py

@@ -90,7 +90,7 @@
     Terminal,
 )
 from .grammar_utils import is_epsilon, rhs_elements
-from .proto_ast import ProtoField, ProtoMessage
+from .proto_ast import ProtoMessage
 from .target import (
     Assign,
     BaseType,
@@ -101,8 +101,6 @@
     ListExpr,
     ListType,
     Lit,
-    NewMessage,
-    OneOf,
     ParseNonterminal,
     ParseNonterminalDef,
     Seq,
@@ -134,105 +132,6 @@ class AmbiguousGrammarError(Exception):
     pass
 
 
-def _proto_fields_by_name(
-    proto_messages: dict[tuple[str, str], ProtoMessage] | None,
-    module: str,
-    name: str,
-) -> dict[str, ProtoField]:
-    """Return a name->ProtoField map for a proto message, or {} if not found."""
-    if proto_messages is None:
-        return {}
-    proto_msg = proto_messages.get((module, name))
-    if proto_msg is None:
-        return {}
-    result: dict[str, ProtoField] = {}
-    for f in proto_msg.fields:
-        result[f.name] = f
-    for oneof in proto_msg.oneofs:
-        for f in oneof.fields:
-            result[f.name] = f
-    return result
-
-
-def _build_param_proto_fields(
-    action: Lambda,
-    proto_messages: dict[tuple[str, str], ProtoMessage] | None,
-) -> dict[int, ProtoField]:
-    """Map lambda parameter indices to protobuf ProtoField descriptors.
-
-    Inspects the semantic action's body. When it is a NewMessage, cross-references
-    field names with proto_messages to find proto fields.
-
-    As a fallback, when the action's return type is a known proto message,
-    matches parameter names to proto field names.
-
-    Returns dict mapping parameter index to ProtoField.
-    """
-    if proto_messages is None:
-        return {}
-    body = action.body
-    if isinstance(body, NewMessage):
-        fields_by_name = _proto_fields_by_name(proto_messages, body.module, body.name)
-        if not fields_by_name:
-            return {}
-        param_names = [p.name for p in action.params]
-        result: dict[int, ProtoField] = {}
-        for field_name, field_expr in body.fields:
-            pf = fields_by_name.get(field_name)
-            if pf is None:
-                continue
-            param_name = _extract_param_name(field_expr, param_names)
-            if param_name is not None and param_name in param_names:
-                param_idx = param_names.index(param_name)
-                result.setdefault(param_idx, pf)
-        return result
-    # Fallback: match parameter names against the return type's proto fields.
-    return _build_param_proto_fields_by_return_type(action, proto_messages)
-
-
-def _build_param_proto_fields_by_return_type(
-    action: Lambda,
-    proto_messages: dict[tuple[str, str], ProtoMessage] | None,
-) -> dict[int, ProtoField]:
-    """Fallback: match parameter names to proto fields via the return type."""
-    from .target import MessageType
-
-    if proto_messages is None:
-        return {}
-    rt = action.return_type
-    if not isinstance(rt, MessageType):
-        return {}
-    fields_by_name = _proto_fields_by_name(proto_messages, rt.module, rt.name)
-    if not fields_by_name:
-        return {}
-    result: dict[int, ProtoField] = {}
-    for i, param in enumerate(action.params):
-        pf = fields_by_name.get(param.name)
-        if pf is not None:
-            result[i] = pf
-    return result
-
-
-def _extract_param_name(expr: TargetExpr, param_names: list[str]) -> str | None:
-    """Extract the parameter name from a field expression.
-
-    Handles:
-    - Direct Var reference
-    - Call(OneOf(...), [Var(...)]) wrapper
-    - Call(Builtin(...), [Var(...), ...]) e.g. unwrap_option_or
-    """
-    from .target import Builtin
-
-    if isinstance(expr, Var) and expr.name in param_names:
-        return expr.name
-    if isinstance(expr, Call):
-        if isinstance(expr.func, OneOf) and expr.args:
-            return _extract_param_name(expr.args[0], param_names)
-        if isinstance(expr.func, Builtin) and expr.args:
-            return _extract_param_name(expr.args[0], param_names)
-    return None
-
-
 def generate_parse_functions(
     grammar: Grammar,
     indent: str = "",
@@ -544,15 +443,6 @@ def _generate_parse_rhs_ir(
                 return Seq([parse_expr, apply_lambda(action, [])])
             var_name = gensym(action.params[0].name)
             var = Var(var_name, rhs.target_type())
-            # Wrap with push_path when the action maps this param to a proto
-            # field (e.g., oneof dispatch: formula -> atom pushes the atom
-            # field number onto the provenance path).
-            if proto_messages is not None:
-                pf = _build_param_proto_fields(action, proto_messages).get(0)
-                if pf is not None:
-                    stmts = _wrap_with_path(pf.number, var, parse_expr)
-                    stmts.append(apply_lambda(action, [var]))
-                    return Seq(stmts)
             return Let(var, parse_expr, apply_lambda(action, [var]))
         return parse_expr
     elif isinstance(rhs, Option):
@@ -587,15 +477,6 @@ def _generate_parse_rhs_ir(
         raise NotImplementedError(f"Unsupported Rhs type: {type(rhs)}")
 
 
-def _wrap_with_path(field_num: int, var: Var, inner: TargetExpr) -> list[TargetExpr]:
-    """Return statements that push path, assign inner to var, then pop path."""
-    return [
-        Call(make_builtin("push_path"), [Lit(field_num)]),
-        Assign(var, inner),
-        Call(make_builtin("pop_path"), []),
-    ]
-
-
 def _generate_parse_rhs_ir_sequence(
     rhs: Sequence,
     grammar: Grammar,
@@ -607,11 +488,6 @@ def _generate_parse_rhs_ir_sequence(
     if is_epsilon(rhs):
         return Lit(None)
 
-    # Compute param->proto field mapping for provenance
-    param_proto_fields: dict[int, ProtoField] = {}
-    if action is not None and proto_messages is not None:
-        param_proto_fields = _build_param_proto_fields(action, proto_messages)
-
     exprs = []
     arg_vars = []
     elems = list(rhs_elements(rhs))
@@ -639,25 +515,7 @@ def _generate_parse_rhs_ir_sequence(
                     )
                 var_name = gensym("arg")
             var = Var(var_name, elem.target_type())
-            pf = param_proto_fields.get(non_literal_count)
-            if pf is not None and pf.is_repeated and isinstance(elem, Star):
-                # Repeated proto field parsed as a Star: push field number
-                # around the whole loop and push/pop an index per element.
-                stmts = _wrap_star_with_index_path(
-                    elem, var, grammar, follow_set_i, pf.number, proto_messages
-                )
-                exprs.extend(stmts)
-            elif isinstance(elem, Star) and proto_messages is not None:
-                # Star without a repeated proto field (helper rule): still
-                # push/pop an index per element for provenance.
-                stmts = _wrap_star_with_index_path(
-                    elem, var, grammar, follow_set_i, None, proto_messages
-                )
-                exprs.extend(stmts)
-            elif pf is not None:
-                exprs.extend(_wrap_with_path(pf.number, var, elem_ir))
-            else:
-                exprs.append(Assign(var, elem_ir))
+            exprs.append(Assign(var, elem_ir))
             arg_vars.append(var)
             non_literal_count += 1
     if apply_action and action:
@@ -674,55 +532,3 @@ def _generate_parse_rhs_ir_sequence(
         return exprs[0]
     else:
         return Seq(exprs)
-
-
-def _wrap_star_with_index_path(
-    star: Star,
-    result_var: Var,
-    grammar: Grammar,
-    follow_set: TerminalSequenceSet,
-    field_num: int | None,
-    proto_messages: dict[tuple[str, str], ProtoMessage] | None = None,
-) -> list[TargetExpr]:
-    """Return statements for a Star loop with push_path(index)/pop_path()
-    around each element. When field_num is provided, the entire loop is
-    also wrapped with push_path(field_num)/pop_path().
-    Assigns the resulting list to result_var."""
-    xs = Var(gensym("xs"), ListType(star.rhs.target_type()))
-    cond = Var(gensym("cond"), BaseType("Boolean"))
-    idx = Var(gensym("idx"), BaseType("Int64"))
-    predictor = _build_option_predictor(grammar, star.rhs, follow_set)
-    parse_item = _generate_parse_rhs_ir(
-        star.rhs, grammar, follow_set, False, None, proto_messages
-    )
-    item = Var(gensym("item"), star.rhs.target_type())
-    loop_body = Seq(
-        [
-            Call(make_builtin("push_path"), [idx]),
-            Assign(item, parse_item),
-            Call(make_builtin("pop_path"), []),
-            Call(make_builtin("list_push"), [xs, item]),
-            Assign(idx, Call(make_builtin("add"), [idx, Lit(1)])),
-            Assign(cond, predictor),
-        ]
-    )
-    inner = Let(
-        xs,
-        ListExpr([], star.rhs.target_type()),
-        Let(
-            cond,
-            predictor,
-            Let(
-                idx,
-                Lit(0),
-                Seq([While(cond, loop_body), xs]),
-            ),
-        ),
-    )
-    if field_num is not None:
-        return [
-            Call(make_builtin("push_path"), [Lit(field_num)]),
-            Assign(result_var, inner),
-            Call(make_builtin("pop_path"), []),
-        ]
-    return [Assign(result_var, inner)]

meta/src/meta/target_builtins.py

@@ -250,8 +250,6 @@ def is_builtin(name: str) -> bool:
 register_builtin("get_at", [SequenceType(T), INT64], T)
 
 # === Provenance tracking ===
-register_builtin("push_path", [INT64], VOID)
-register_builtin("pop_path", [], VOID)
 register_builtin("span_start", [], INT64)
 register_builtin("record_span", [INT64], VOID)
 

meta/src/meta/templates/parser.go.template

@@ -330,7 +330,6 @@ type Parser struct {{
 	idToDebugInfo     map[string]map[relationIdKey]string
 	currentFragmentID []byte
 	Provenance        map[string]Span
-	path              []int
 	lineStarts        []int
 }}
 
@@ -342,7 +341,6 @@ func NewParser(tokens []Token, input string) *Parser {{
 		idToDebugInfo:     make(map[string]map[relationIdKey]string),
 		currentFragmentID: nil,
 		Provenance:        make(map[string]Span),
-		path:              nil,
 		lineStarts:        computeLineStarts(input),
 	}}
 }}
@@ -362,14 +360,6 @@ func (p *Parser) makeLocation(offset int) Location {{
 	return Location{{Line: lineIdx + 1, Column: col + 1, Offset: offset}}
 }}
 
-func (p *Parser) pushPath(n int) {{
-	p.path = append(p.path, n)
-}}
-
-func (p *Parser) popPath() {{
-	p.path = p.path[:len(p.path)-1]
-}}
-
 func (p *Parser) spanStart() int {{
 	return p.lookahead(0).StartPos
 }}
@@ -383,15 +373,7 @@ func (p *Parser) recordSpan(startOffset int) {{
 		Start: p.makeLocation(startOffset),
 		Stop:  p.makeLocation(endOffset),
 	}}
-	// Build comma-separated path key
-	key := ""
-	for i, v := range p.path {{
-		if i > 0 {{
-			key += ","
-		}}
-		key += fmt.Sprintf("%d", v)
-	}}
-	p.Provenance[key] = s
+	p.Provenance[""] = s
 }}
 
 func (p *Parser) lookahead(k int) Token {{

meta/src/meta/templates/parser.jl.template

@@ -190,11 +190,10 @@ mutable struct ParserState
     _current_fragment_id::Union{{Nothing,Vector{{UInt8}}}}
     _relation_id_to_name::Dict{{Tuple{{UInt64,UInt64}},String}}
     provenance::Dict{{Tuple{{Vararg{{Int}}}},Span}}
-    _path::Vector{{Int}}
     _line_starts::Vector{{Int}}
 
     function ParserState(tokens::Vector{{Token}}, input_str::String)
-        return new(tokens, 1, Dict(), nothing, Dict(), Dict(), Int[], _compute_line_starts(input_str))
+        return new(tokens, 1, Dict(), nothing, Dict(), Dict(), _compute_line_starts(input_str))
     end
 end
 
@@ -205,16 +204,6 @@ function _make_location(parser::ParserState, offset::Int)::Location
     return Location(line_idx, col + 1, offset)
 end
 
-function push_path!(parser::ParserState, n::Int)
-    push!(parser._path, n)
-    return nothing
-end
-
-function pop_path!(parser::ParserState)
-    pop!(parser._path)
-    return nothing
-end
-
 function span_start(parser::ParserState)::Int
     return lookahead(parser, 0).start_pos
 end
@@ -226,7 +215,7 @@ function record_span!(parser::ParserState, start_offset::Int)
         end_offset = start_offset
     end
     s = Span(_make_location(parser, start_offset), _make_location(parser, end_offset))
-    parser.provenance[Tuple(parser._path)] = s
+    parser.provenance[tuple()] = s
     return nothing
 end