From 355811d64e30c138d58eed595276b03362847b2b Mon Sep 17 00:00:00 2001 From: TermiNexus Date: Sat, 12 Sep 2026 12:50:35 +0800 Subject: [PATCH] =?UTF-8?q?chore(tpc):=20=E7=A7=BB=E9=99=A4=E5=B1=9E?= =?UTF-8?q?=E6=80=A7=E9=93=BE/=E8=B0=83=E7=94=A8=E5=88=86=E6=B4=BE?= =?UTF-8?q?=E9=94=99=E8=AF=AF=E8=B7=AF=E5=BE=84=E7=9A=84=E4=B8=B4=E6=97=B6?= =?UTF-8?q?=E8=AF=8A=E6=96=AD=E6=89=93=E7=82=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - HandlesBase: 删除 _AttrFailDiag 现场诊断（含模块别名链逐跳 dump），恢复精简错误信息 - HandlesExprAttr: 删除 [CHAIN-DBG] stderr 打点与 [attr-diag]/[attr-diag-nested] KeyError 包装 - HandlesExprCall: 删除 Unknown module 异常的 _rc_note 诊断后缀 --- lib/core/Handles/HandlesBase.py | 77 ----------------------------- lib/core/Handles/HandlesExprAttr.py | 48 ++---------------- lib/core/Handles/HandlesExprCall.py | 36 +------------- 3 files changed, 6 insertions(+), 155 deletions(-) diff --git a/lib/core/Handles/HandlesBase.py b/lib/core/Handles/HandlesBase.py index 817ae07..a0c5c06 100644 --- a/lib/core/Handles/HandlesBase.py +++ b/lib/core/Handles/HandlesBase.py @@ -585,86 +585,9 @@ class BaseHandle: msg: str = (f"{What}表达式 '{expr_text}' 编译期求值为空（属性访问未能解析出" f"目标类型/成员），赋值将被跳过、变量保持未初始化。位置 {loc}" f"{('，源码: ' + code_line) if code_line else ''}") - # 现场诊断：dump 最内层基变量在各类注册表/存储中的状态，定位属性解析 - # 在哪一级断裂（var_struct_class 缺失 / struct 键形态不匹配 / 存储退化）。 - diag: str = self._AttrFailDiag(Node, Gen) - if diag: - msg += f"\n[ATTR-DIAG]{diag}" _vlog().compile_error(msg, src_file, lineno, code_line) sys.exit(1) - @staticmethod - def _AttrFailDiag(Node: ast.AST, Gen: Any) -> str: - """提取属性链失败现场：最内层 Name 变量的类登记与存储状态""" - try: - inner: ast.AST = Node - while isinstance(inner, ast.Attribute): - inner = inner.value - if not isinstance(inner, ast.Name): - return '' - var: str = inner.id - seg: list[str] = [] - seg.append(f"var={var}") - vsc: Any = getattr(Gen, 'var_struct_class', {}) or {} - gsc: Any = getattr(Gen, 'global_struct_class', {}) or {} - seg.append(f"var_struct_class[{var}]={vsc.get(var)!r}") - seg.append(f"global_struct_class[{var}]={gsc.get(var)!r}") - def _ty_str(ptr: Any) -> str: - try: - if ptr is None: - return 'None' - return str(ptr.type) - except Exception: - return '?' - for _tab_name, _tab in (('variables', getattr(Gen, 'variables', {}) or {}), - ('_reg_values', getattr(Gen, '_reg_values', {}) or {}), - ('_direct_values', getattr(Gen, '_direct_values', {}) or {}), - ('global_vars', getattr(Gen, 'global_vars', {}) or {})): - if var in _tab: - seg.append(f"{_tab_name}[{var}]={_ty_str(_tab[var])}") - # 最内层类名 → 是否在 class_member_element_class 登记字段 - cn: Any = vsc.get(var) or gsc.get(var) - cmap: Any = getattr(Gen, 'class_member_element_class', {}) or {} - import re as _re - def _short(k: str) -> str: - return _re.sub(r'^[0-9a-fA-F]{16}\.', '', k) - if cn: - hit: list[str] = [] - for key, sub in cmap.items(): - if _short(key) == _short(cn): - hit.append(f"{key}:{sub}") - seg.append(f"elem_class_map_hits={hit or 'NONE'}") - # Gen.structs 中含 cn 短名的键（供键形态比对） - if cn: - struct_keys: list[str] = [k for k in (getattr(Gen, 'structs', {}) or {}) - if _short(k) == _short(cn)] - seg.append(f"structs_keys={struct_keys or 'NONE'}") - # 模块别名链（Mod.Var.Field，如 CompilerFactory.factory.PermPool）： - # 最内层 Name 是**模块名**，上面的登记 dump（var_struct_class 等）对它 - # 恒为 None、无法定位断点。补逐跳诊断：Mod 的 sha1、`Mod.Var` 在全局量表 - # 里的候选键命中与类型，直接指出断在哪一跳。 - _chain: list[str] = [] - _cur: ast.AST = Node - while isinstance(_cur, ast.Attribute): - _chain.append(_cur.attr) - _cur = _cur.value - _chain.reverse() - if _chain: - _sha1_map2: Any = getattr(Gen, 'ModuleSha1Map', {}) or {} - _gmap: Any = getattr(getattr(Gen, 'module', None), 'globals', {}) or {} - _mod_sha: Any = _sha1_map2.get(var) - seg.append(f"chain={var}.{'.'.join(_chain)} ModuleSha1Map[{var}]={_mod_sha!r}") - _hop: str = _chain[0] - _keys: list[str] = [f"{var}.{_hop}", _hop] - if _mod_sha: - _keys.append(f"{_mod_sha}.{_hop}") - for _k in _keys: - if _k in _gmap: - seg.append(f"globals[{_k}]={_ty_str(_gmap[_k])}") - return '\n'.join(seg) - except Exception: - return '' - def HandleBodyLlvm(self, Body: ast.AST | list[ast.stmt]) -> Any: return self.Trans.BodyHandler.HandleBodyLlvm(Body) diff --git a/lib/core/Handles/HandlesExprAttr.py b/lib/core/Handles/HandlesExprAttr.py index c823726..a27783d 100644 --- a/lib/core/Handles/HandlesExprAttr.py +++ b/lib/core/Handles/HandlesExprAttr.py @@ -616,8 +616,8 @@ class ExprAttrHandle(BaseHandle): # 通用指针槽兜底：静态类名（var_struct_class/键归一后）有效且 ObjVal 是指针， # 但 pointee 非 struct（如 cast 局部变量 tp: rowptr[Tuple] 的槽被建为 i32**， # Name 求值 load 一次得到 i32*，上述 struct 匹配/回退均不命中 → return None）。 - # 此时按静态类名信任 bitcast 到 struct* 再走成员 GEP（tp.elts 根因，ATTR-DIAG - # 实证 var_struct_class='Tuple'、structs 有 'Tuple'，仅槽位为通用指针形态）。 + # 此时按静态类名信任 bitcast 到 struct* 再走成员 GEP（tp.elts 根因： + # var_struct_class='Tuple'、structs 有 'Tuple'，仅槽位为通用指针形态）。 if (not struct_match and ClassName and ClassName in Gen.structs and isinstance(ObjVal.type, ir.PointerType) and not isinstance(ObjVal.type.pointee, ir.IdentifiedStructType) @@ -652,16 +652,7 @@ class ExprAttrHandle(BaseHandle): Gen.class_member_bitoffsets[ClassName][AttrName] = bo return self._load_bitfield_member(ObjVal, ClassName, AttrName) - try: - offset = Gen._get_member_offset(AttrName, ClassName) - except KeyError as _ke: - _vsc2: Any = getattr(Gen, 'var_struct_class', {}) or {} - raise KeyError( - f"{_ke} | [attr-diag] var={VarName} " - f"var_struct_class={_vsc2.get(VarName)!r} " - f"objval_pointee={getattr(getattr(ObjVal, 'type', None), 'pointee', None)!r} " - f"node={self._ExprText(Node)!r} " - f"base={self._ExprText(Node.value)!r}") from None + offset = Gen._get_member_offset(AttrName, ClassName) # 检查 offset 是否超出实际结构体 if isinstance(ObjVal.type, ir.PointerType): actual_pointee: Any = ObjVal.type.pointee @@ -772,18 +763,8 @@ class ExprAttrHandle(BaseHandle): return cdefine_result ObjVal: Any = self.HandleExprLlvm(Node.value) if not ObjVal or not isinstance(ObjVal.type, ir.PointerType): - import sys as _sys1 - _sys1.stderr.write( - f"[CHAIN-DBG] nested no-obj: node={self._ExprText(Node)!r} " - f"inner={self._ExprText(Node.value)!r} objval_type={getattr(ObjVal, 'type', None)!r}\n") return None pointee: Any = ObjVal.type.pointee - if not (isinstance(pointee, ir.IntType) - or isinstance(pointee, (ir.LiteralStructType, ir.IdentifiedStructType))): - import sys as _sys1b - _sys1b.stderr.write( - f"[CHAIN-DBG] nested unhandled-pointee: node={self._ExprText(Node)!r} " - f"objval_type={ObjVal.type!r} pointee={pointee!r}\n") # char* → struct* cast + 成员访问 if isinstance(pointee, ir.IntType) and pointee.width == 8: @@ -808,7 +789,7 @@ class ExprAttrHandle(BaseHandle): if not AttrClassName: # 【模块别名 + 模块级变量】`Mod.Var` 形态（如 CompilerFactory.factory）： # 上面三个解析器都按「字段所属类」思路找，对「模块别名.变量」返回 None - # （[CHAIN-DBG] char* key-miss: attr_class=None，StructGenMixin.vp:139 与 + # （attr_class=None 即此处的 key-miss 现场，StructGenMixin.vp:139 与 # ClassGenVTable.vp:99 根因）。而该变量的类已由 HandlesImports 的 # _EmitExternalGlobalDeclLlvm / HandlesAnnAssign 登记在 # var_struct_class / global_struct_class（键为**裸变量名**）⇒ 直读。 @@ -835,34 +816,23 @@ class ExprAttrHandle(BaseHandle): or getattr(Gen, 'global_struct_class', {}).get(_mva.attr)) ResolvedKey: str | None = self._find_struct_key_for_class_hint(Gen, AttrClassName) if ResolvedKey is None or ResolvedKey not in Gen.structs: - import sys as _sys2 - _sys2.stderr.write( - f"[CHAIN-DBG] char* key-miss: node={self._ExprText(Node)!r} " - f"attr_class={AttrClassName!r} resolved_key={ResolvedKey!r} " - f"objval_type={ObjVal.type!r}\n") return None st: Any ok: bool st, ok = self._try_Load_struct_from_stub(Gen, ResolvedKey) if not isinstance(st, ir.IdentifiedStructType): - import sys as _sys3 - _sys3.stderr.write(f"[CHAIN-DBG] char* not-struct: key={ResolvedKey!r} st={st!r}\n") return None if st.elements is None: # stub 仍 opaque（如跨模块泛型仅声明）：走泛型特化候选访问 spec_val: Any = self._try_access_opaque_generic_member(Gen, ObjVal, st, Node, ResolvedKey, AttrClassName) if spec_val is not None: return spec_val - import sys as _sys4 - _sys4.stderr.write(f"[CHAIN-DBG] char* opaque-miss: key={ResolvedKey!r} node={self._ExprText(Node)!r}\n") return None CastedObj: Any = Gen.builder.bitcast(ObjVal, ir.PointerType(st), name=f"cast_{ResolvedKey}") if Node.attr in Gen.class_member_bitoffsets.get(ResolvedKey, {}): return self._load_bitfield_member(CastedObj, ResolvedKey, Node.attr) offset: int | None = Gen._get_member_offset(Node.attr, ResolvedKey) if offset is None: - import sys as _sys5 - _sys5.stderr.write(f"[CHAIN-DBG] char* offset-miss: key={ResolvedKey!r} attr={Node.attr!r} st={st!r}\n") return None if offset < len(st.elements) and isinstance(st.elements[offset], ir.VoidType): return None @@ -891,15 +861,7 @@ class ExprAttrHandle(BaseHandle): bitfield_offsets: Any = Gen.class_member_bitoffsets.get(CN, {}) if Node.attr in bitfield_offsets: return self._load_bitfield_member(ObjVal, CN, Node.attr) - try: - offset = Gen._get_member_offset(Node.attr, CN) - except KeyError as _ke2: - raise KeyError( - f"{_ke2} | [attr-diag-nested] " - f"objval_pointee={getattr(getattr(ObjVal, 'type', None), 'pointee', None)!r} " - f"node={self._ExprText(Node)!r} " - f"inner={self._ExprText(Node.value)!r} " - f"parent_hint={parent_hint!r}") from None + offset = Gen._get_member_offset(Node.attr, CN) if offset is None: break # 泛型基础类型字段特化（根本修复）： diff --git a/lib/core/Handles/HandlesExprCall.py b/lib/core/Handles/HandlesExprCall.py index 4cf3c12..a14d70b 100644 --- a/lib/core/Handles/HandlesExprCall.py +++ b/lib/core/Handles/HandlesExprCall.py @@ -891,41 +891,7 @@ class ExprCallHandle(BaseHandle): if ModulePath and IsKnown: raise Exception(f"Undefined symbol: '{ModulePath}.{FuncAttr}'") if ModulePath and ModulePath not in {'t', 'c'} and not IsKnown: - # 诊断增强：这条 raise 会把「接收者链上方法分派失败」误报成 - # "Unknown module"，掩盖真因（factory.PermPool.alloc 排查现场）。 - # 附接收者链的类名解析结果 + 该类是否有目标成员/函数，一次定位： - # receiver_class=None → 链的类名解析仍断（见 _get_var_class） - # has_func/field_member=False → 类名对了但方法符号不存在 - _rc_cls: str | None = None - try: - _rc_cls = self.Trans.ExprHandler._get_var_class(Node.func.value, Gen) - except Exception: - _rc_cls = None - _rc_note: str = f", receiver_class={_rc_cls!r}" - if _rc_cls: - _rc_bare: str = _rc_cls.split('.')[-1] - _rc_note += f", has_func={Gen._has_function(f'{_rc_cls}.{FuncAttr}')}" - _rc_note += (", field_member=" - f"{bool([m for m, _ in (Gen.class_members.get(_rc_bare) or []) if m == FuncAttr])}") - # receiver_class=None 时，把第一跳（Mod.Var 的 Var）登记现场打出来 - _hops: list = [] - _cn: ast.AST = Node.func.value - while isinstance(_cn, ast.Attribute): - _hops.append(_cn.attr) - _cn = _cn.value - if isinstance(_cn, ast.Name): - _hops.append(_cn.id) - _hops.reverse() - if len(_hops) >= 2: - _h1 = _hops[1] - _vsc2 = getattr(Gen, 'var_struct_class', {}) or {} - _gsc2 = getattr(Gen, 'global_struct_class', {}) or {} - _gmap2 = getattr(getattr(Gen, 'module', None), 'globals', {}) or {} - _rc_note += (f", chain={'.'.join(_hops)}, hop1={_h1!r}" - f", vsc={_vsc2.get(_h1)!r}, gsc={_gsc2.get(_h1)!r}" - f", globals_suffix={[k for k in _gmap2 if k.endswith('.' + _h1)]}") - raise Exception(f"Unknown module: '{ModulePath}' (undefined symbol: " - f"'{ModulePath}.{FuncAttr}'){_rc_note}") + raise Exception(f"Unknown module: '{ModulePath}' (undefined symbol: '{ModulePath}.{FuncAttr}')") if not ModulePath and FuncAttr: raise Exception(f"Undefined method: '{FuncAttr}'") return MethodResult if MethodResult is not None else ir.Constant(ir.IntType(32), 0)