Callsite argument_types silently mixes AST node categories with inferred type names in one field (CLDK-007)

[rahlk]

Target: canonical schema v2 (epic #69) — representation is contract surface. From the external v0.3.0/Odoo quality audit, finding CLDK-007 (severity Medium).

Audit evidence (Odoo, native export)

Callsite argument_types mixes two unrelated vocabularies in one list with no discriminator: Python AST node class names (Name ×38,572, plus Constant, Attribute, Call) interleaved with Jedi-inferred type names (str ×28,422, …). A consumer cannot tell "this argument is a string" from "this argument was a Name node whose type is unknown" without undocumented conventions.

Root cause

symbol_table_builder.py (main @ 607-611):

argument_types = [
    self._infer_type(script, arg.lineno, arg.col_offset)
    or type(arg).__name__
    for arg in node.args
]

When Jedi inference fails, the code silently substitutes the AST node class name into the same field. Two adjacent weaknesses share the pattern of one field carrying mixed semantics:

• _infer_type returns Jedi's .name for whatever the position resolves to — for a function-valued argument like len in str(len(x)) the recorded "type" is len (the function's name, not its return type).
• Callsite return_type is inferred at the call-expression start and is really the receiver's type — that anchor bug is Callee inference anchors at call-expression start: attribute calls resolve to receiver type, 99.9% of Odoo env calls bind to enclosing class (CLDK-001 + CLDK-002) #80; the representation lesson here is the same field name meaning different things depending on which code path filled it.

Fix direction (v2)

Per the audit gate, consumers must be able to distinguish verbatim source, AST category, declared type, and inferred type without conventions. v2's source-span design (source stored once per module + byte offsets) already gives verbatim argument text; on top of that, keep AST category and inferred type as separate properties (either two parallel lists or a small per-argument object), and never let an inference failure masquerade as a type name — absent means absent.