infinity-data 2.1.0__tar.gz → 2.2.0__tar.gz

{infinity_data-2.1.0/src/infinity_data.egg-info → infinity_data-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infinity-data
-Version: 2.1.0
+Version: 2.2.0
 Summary: InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库
 Author: infinity_system: yin_bailiang
 License: MIT

{infinity_data-2.1.0 → infinity_data-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "infinity-data"
-version = "2.1.0"
+version = "2.2.0"
 description = "InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库"
 readme = "README.md"
 license = { text = "MIT" }
@@ -35,6 +35,7 @@ Documentation = "https://github.com/yinbailiang/infinity_data#readme"
 [dependency-groups]
 # 测试组：仅运行测试所需（CI test job 只装这组，更快）
 test = [
+    "pyyaml",
     "pytest>=8.0",
     "pytest-cov>=5.0",
 ]
@@ -89,7 +90,7 @@ line-ending = "lf"
 typeCheckingMode = "strict"
 reportMissingTypeStubs = false
 reportMissingImports = "error"
-exclude = ["**/node_modules", "**/__pycache__", "**/.*", ".venv"]
+exclude = ["**/node_modules", "**/__pycache__", "**/.*", ".venv", "build"]
 venvPath = "."
 venv = ".venv"
 

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/pipeline.py

@@ -137,7 +137,7 @@ def _compile(file: File, options: CompileOptions) -> CompilationResult:
                 if resolver.schema.from_file and context.schema_scope is not None
                 else context.root_scope
             )
-            key = scope.get(resolver.schema.template)
+            key = scope.visible.get(resolver.schema.template)
             if key is None:
                 raise SchemaError('schema.undefined_template', {'template': resolver.schema.template})
             tpl = std.templates[key]

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/builder/__init__.py

@@ -13,8 +13,10 @@ from infinity_data.semantic.builder.models import (
     StdDocument,
     StdField,
     StdLiteral,
+    StdNode,
     StdObject,
     StdValue,
+    is_std_node,
 )
 
 __all__ = [
@@ -24,6 +26,8 @@ __all__ = [
     'StdDocument',
     'StdField',
     'StdLiteral',
+    'StdNode',
     'StdObject',
     'StdValue',
+    'is_std_node',
 ]

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/builder/builder.py

@@ -82,9 +82,9 @@ class AstBuilder:
         # 执行期状态（每次 build 重置）
         self._templates: dict[TemplateKey, TemplateDef] = {}
         self._template_scopes: dict[TemplateKey, Scope] = {}
-        self._root_scope: Scope = {}
+        self._root_scope: Scope = Scope()
         self._schema_scope: Scope | None = None
-        self._namespace: dict[str, StdValue] = {}  # $ 引用解析目标（!env/!file/!var 统一为 StdValue）
+        # $ 命名空间按文件就地解析（§1.8）：由各 Scope 对象自身携带（scope.namespaces）
         self._collector: DiagnosticCollector = DiagnosticCollector()  # 本次 build 的共享收集器
         self._depth = 0
         self._recursive_defaults: set[TemplateKey] = set()
@@ -107,9 +107,8 @@ class AstBuilder:
         """
         self._templates = {}
         self._template_scopes = {}
-        self._root_scope = {}
+        self._root_scope = Scope()
         self._schema_scope = None
-        self._namespace = {}
         self._collector = collector
         self._depth = 0
         self._recursive_defaults = set()
@@ -119,7 +118,6 @@ class AstBuilder:
         self._template_scopes = context.template_scopes
         self._root_scope = context.root_scope
         self._schema_scope = context.schema_scope
-        self._namespace = context.namespace
 
         # 静态防护：默认值引用环检测（默认值禁止自引用，见 neo_desg.md 2.6）
         self._detect_recursive_defaults()
@@ -127,8 +125,8 @@ class AstBuilder:
         # 模板配置校验：extra_*_vars 指向的字段必须在模板中声明（§2.9，定义即报错）
         self._check_variadic_config()
 
-        # !var 求值（§2.10）：root 构建前填充 $ 命名空间（前向引用 + 环检测）
-        self._resolve_var_statements(doc)
+        # !var 求值（§2.10）：root 构建前按文件填充 $ 命名空间（前向引用 + 环检测，就地解析）
+        self._resolve_var_statements(context)
 
         # 构建 root（顶层结构约束挂在 root.constraints，不执行）
         root_fields: list[StdField] = []
@@ -160,25 +158,44 @@ class AstBuilder:
         return StdDocument(
             root=StdObject(fields=self._finalize_object(root_fields, ''), constraints=root_constraints),
             templates=dict(self._templates),
-            scope=dict(self._root_scope),
+            scope=dict(self._root_scope.visible),
         )
 
     # ═══════════════════════════════════════════════════════
     # !var 求值（§2.10）
     # ═══════════════════════════════════════════════════════
 
-    def _resolve_var_statements(self, doc: Document) -> None:
-        """!var 求值：静态依赖图 + 环检测 + 拓扑求值 + path 投影，填充 $ 命名空间。
+    def _resolve_var_statements(self, context: ResolvedContext) -> None:
+        """!var 求值（按文件就地解析，§1.8）：每文件独立依赖图 + 环检测 + 拓扑求值。
 
         在 root 构建之前调用——前向引用经拓扑序天然支持；依赖环 → ``var.cycle``。
-        值构造（模板展开 / 解包 / $ 引用）全部复用 :meth:`_resolve_value`。
+        值构造（模板展开 / 解包 / $ 引用）全部复用 :meth:`_resolve_value`，
+        用**该文件**的 scope 就地解析、绑定**该文件**的 $ 命名空间（跨文件完全隔离）。
+        ``!var`` 语句由 scope 对象携带（``scope.var_statements``），此处遍历全部文件 scope。
+        Scope 按身份相等且可哈希（dataclass eq=False），直接用 set 去重。
         """
-        stmts = [s for s in doc.statements if isinstance(s, VarStmt)]
-        if not stmts:
-            return
+        seen: set[Scope] = set()
+        for scope in self._iter_scopes(context):
+            if scope in seen:
+                continue  # 同一 scope 被多模板共享，只处理一次
+            seen.add(scope)
+            if scope.var_statements:
+                self._resolve_var_file(scope, scope.var_statements)
+
+    def _iter_scopes(self, context: ResolvedContext) -> list[Scope]:
+        """context 中全部文件 scope（root + 各定义点 + schema 隐式导入）。"""
+        scopes: list[Scope] = [context.root_scope]
+        if context.schema_scope is not None:
+            scopes.append(context.schema_scope)
+        scopes.extend(context.template_scopes.values())
+        return scopes
+
+    def _resolve_var_file(self, scope: Scope, stmts: list[VarStmt]) -> None:
+        """单个文件内 !var 求值（用该文件 scope 解析，绑定该文件命名空间）。"""
+        namespace = scope.namespaces
         by_alias = {s.alias: i for i, s in enumerate(stmts)}
 
-        # 1) 依赖图：!var 的 $ 引用指向其他 !var 别名 → 边（walk 静态提取）
+        # 1) 依赖图：!var 的 $ 引用指向同文件其他 !var 别名 → 边（walk 静态提取）
         deps: dict[int, set[int]] = {}
         for i, s in enumerate(stmts):
             dep_indices: set[int] = set()
@@ -208,10 +225,10 @@ class AstBuilder:
         for i in range(len(stmts)):
             visit(i)
 
-        # 3) 拓扑序求值 → path 投影 → 填 namespace（duplicate 检测）
+        # 3) 拓扑序求值 → path 投影 → 填本文件命名空间（duplicate 检测）
         for i in order:
             s = stmts[i]
-            rv = self._resolve_value(s.value, '', self._root_scope)
+            rv = self._resolve_value(s.value, '', scope)
             if rv is None:
                 continue  # 值解析失败已报告
             if s.json_path:
@@ -220,10 +237,10 @@ class AstBuilder:
                 except (KeyError, IndexError, TypeError):
                     self._err('var.path_failed', {'alias': s.alias}, s.source, '')
                     continue
-            if s.alias in self._namespace:
+            if s.alias in namespace:
                 self._err('namespace.duplicate', {'name': s.alias}, s.source, '')
                 continue
-            self._namespace[s.alias] = rv
+            namespace[s.alias] = rv
 
     # ═══════════════════════════════════════════════════════
     # 递归默认值防护（方案 C：默认引用图 + 静态环检测）
@@ -299,7 +316,7 @@ class AstBuilder:
             return
         for node in walk(v):
             if isinstance(node, TemplateCallValue):
-                k = scope.get(node.template_name)
+                k = scope.visible.get(node.template_name)
                 if k is not None:
                     yield k, node.source
 
@@ -401,7 +418,7 @@ class AstBuilder:
         """数组元素 noexist → 报错并按 null（保留位置）。"""
         if isinstance(value, StdLiteral) and value.kind == 'noexist':
             self._err('value.noexist_in_array', {}, source, path)
-            return StdLiteral(kind='null', value=None)
+            return StdLiteral(kind='null', value=None, source=source)
         return value
 
     def _bind_to_std(self, value: Value | StdValue, path: str, scope: Scope) -> StdValue:
@@ -430,7 +447,7 @@ class AstBuilder:
                 case LiteralValue(value=tok):
                     return self._convert_literal(tok)
                 case DollarValue(name=n, type_cast=tc, source=src):
-                    return self._resolve_dollar(n, tc, path, src)
+                    return self._resolve_dollar(n, tc, path, src, scope)
                 case DictValue(fields=fs, constraints=cs, unpacks=ups):
                     std_fields: list[StdField] = []
                     # **expr 解包：目标必须是 dict，展开为键值对（disjoint merge 查重在 _finalize_object）
@@ -447,7 +464,11 @@ class AstBuilder:
                     # dict 结构级约束（作用于该字面量整体）：解析后挂节点，不执行
                     specs, diags = resolve_constraint_list(cs, scope)
                     self._collector.extend(diags)
-                    return StdObject(fields=self._finalize_object(std_fields, path), constraints=specs)
+                    return StdObject(
+                        fields=self._finalize_object(std_fields, path),
+                        constraints=specs,
+                        source=raw.source,
+                    )
                 case ArrayValue(elements=els):
                     std_elements: list[StdValue] = []
                     for i, e in enumerate(els):
@@ -462,7 +483,7 @@ class AstBuilder:
                         if rv is None:
                             continue
                         std_elements.append(self._array_noexist(rv, e.source, f'{path}[{i}]'))
-                    return StdArray(elements=std_elements)
+                    return StdArray(elements=std_elements, source=raw.source)
                 case TemplateCallValue(
                     template_name=tn,
                     positional_args=pa,
@@ -489,34 +510,41 @@ class AstBuilder:
         self,
         tok: StringToken | IntegerToken | FloatToken | BoolToken | NullToken | NoexistToken,
     ) -> StdLiteral:
-        """将字面量 Token 转为 StdLiteral。"""
+        """将字面量 Token 转为 StdLiteral（携带 token 在源文档中的位置）。"""
         match tok:
             case StringToken(value=v):
-                return StdLiteral(kind='str', value=v)
+                return StdLiteral(kind='str', value=v, source=tok.raw.source)
             case IntegerToken(value=v):
-                return StdLiteral(kind='int', value=v)
+                return StdLiteral(kind='int', value=v, source=tok.raw.source)
             case FloatToken(value=v):
-                return StdLiteral(kind='float', value=v)  # Decimal，含 NaN/±Inf
+                return StdLiteral(kind='float', value=v, source=tok.raw.source)  # Decimal，含 NaN/±Inf
             case BoolToken(value=v):
-                return StdLiteral(kind='bool', value=v)
+                return StdLiteral(kind='bool', value=v, source=tok.raw.source)
             case NullToken():
-                return StdLiteral(kind='null', value=None)
+                return StdLiteral(kind='null', value=None, source=tok.raw.source)
             case NoexistToken():
-                return StdLiteral(kind='noexist', value=None)
+                return StdLiteral(kind='noexist', value=None, source=tok.raw.source)
         raise TypeError(f'未知字面量 token 类型: {type(tok)}')
 
     def _resolve_dollar(
-        self, name: str, type_cast: str | None, path: str, source: SourceRange | None = None
+        self,
+        name: str,
+        type_cast: str | None,
+        path: str,
+        source: SourceRange | None = None,
+        scope: Scope | None = None,
     ) -> StdValue:
-        """解析 ``$name`` 引用，type_cast 为显式 as bool/int/float/str 转换。
+        """解析 ``$name`` 引用（按书写位置的 scope 就地查该文件 $ 命名空间，§1.8）。
 
-        source 为 ``$name`` 表达式在源码中的位置
+        type_cast 为显式 as bool/int/float/str 转换；source 为 ``$name`` 表达式在源码中的位置。
+        本文件空间查不到 → ``dollar.undefined`` 警告取 null（不中断编译）。
         """
-        if name not in self._namespace:
+        namespace = scope.namespaces if scope is not None else {}
+        if name not in namespace:
             self._warn('dollar.undefined', {'name': name}, source, path)
-            return StdLiteral(kind='null', value=None)
+            return StdLiteral(kind='null', value=None, source=source)
 
-        raw = self._namespace[name]
+        raw = namespace[name]
         # namespace 统一存 StdValue（!env/!file/!var 均由 python_to_std / 求值产出）
         if type_cast is None:
             return raw
@@ -563,10 +591,10 @@ class AstBuilder:
                         )
                     )
                     val = False
-                return StdLiteral(kind='bool', value=val)
+                return StdLiteral(kind='bool', value=val, source=source)
             case 'int':
                 try:
-                    return StdLiteral(kind='int', value=int(cast(Any, raw)))
+                    return StdLiteral(kind='int', value=int(cast(Any, raw)), source=source)
                 except (ValueError, TypeError):
                     self._collector.add(
                         Diagnostic(
@@ -577,10 +605,10 @@ class AstBuilder:
                             path,
                         )
                     )
-                    return StdLiteral(kind='int', value=0)
+                    return StdLiteral(kind='int', value=0, source=source)
             case 'float':
                 try:
-                    return StdLiteral(kind='float', value=decimal.Decimal(str(raw)))
+                    return StdLiteral(kind='float', value=decimal.Decimal(str(raw)), source=source)
                 except (ValueError, TypeError, decimal.InvalidOperation):
                     self._collector.add(
                         Diagnostic(
@@ -591,22 +619,22 @@ class AstBuilder:
                             path,
                         )
                     )
-                    return StdLiteral(kind='float', value=decimal.Decimal(0))
+                    return StdLiteral(kind='float', value=decimal.Decimal(0), source=source)
             case 'str':
                 # as str = 字符串化：任意字面量按**语言字面量风格**转为字符串，
                 # 保证可 round-trip 还原回原值（bool → true/false、float 特殊值
                 # → nan/+inf/-inf），不泄漏 Python 内部表示；null/noexist 已在上方
                 # 保持传播，不进入本分支
                 if isinstance(raw, bool):
-                    return StdLiteral(kind='str', value='true' if raw else 'false')
+                    return StdLiteral(kind='str', value='true' if raw else 'false', source=source)
                 if isinstance(raw, decimal.Decimal):
                     if raw.is_nan():
-                        return StdLiteral(kind='str', value='nan')
+                        return StdLiteral(kind='str', value='nan', source=source)
                     if raw.is_infinite():
-                        return StdLiteral(kind='str', value='+inf' if raw > 0 else '-inf')
-                return StdLiteral(kind='str', value=str(raw))
+                        return StdLiteral(kind='str', value='+inf' if raw > 0 else '-inf', source=source)
+                return StdLiteral(kind='str', value=str(raw), source=source)
             case _:
-                return StdLiteral(kind='str', value=str(raw))
+                return StdLiteral(kind='str', value=str(raw), source=source)
 
     # ═══════════════════════════════════════════════════════
     # 模板展开
@@ -725,7 +753,7 @@ class AstBuilder:
         for combo in combos:
             pa, na, upa, upk = self._build_expand_args(pos_args, named, unpack_args, unpack_kwargs, axes, combo)
             results.append(self._instantiate_once(template_name, pa, na, upa, upk, path, source, scope))
-        return StdArray(elements=results)
+        return StdArray(elements=results, source=source)
 
     def _resolve_axis(
         self,
@@ -798,7 +826,7 @@ class AstBuilder:
         解包：``*expr``（list → 位置参数）/ ``**expr``（dict → 命名参数）；
         解包键与已有参数冲突 → ``dict.duplicate_key``（disjoint merge，§2.7）。
         """
-        key = scope.get(template_name)
+        key = scope.visible.get(template_name)
         if key is None:
             self._collector.add(
                 Diagnostic(Severity.ERROR, 'template.undefined', {'template': template_name}, source, path)
@@ -947,14 +975,19 @@ class AstBuilder:
             if tf.name in param_values:
                 pv = param_values[tf.name]
                 v = self._bind_to_std(pv, child, scope)
+                # 字段位置 = 调用点参数表达式（值无来源时回退至此，而非模板定义）；
+                # 展开轴元素等彻底无来源时最后回退模板定义（避免丢失位置）
+                field_src = getattr(pv, 'source', None) or v.source or tf.source
             elif tf.default_value is not None:
                 v = self._resolve_value(tf.default_value, child, inner_scope)
+                # 字段位置 = 默认值表达式（模板定义内）
+                field_src = v.source if v is not None else tf.source
             else:
                 continue  # 必填且未提供 → 已在上面报错
 
             specs, diags = resolve_constraints(tf.constraints, inner_scope)
             self._collector.extend(diags)
-            std_fields.append(StdField(name=tf.name, value=v, source=tf.source, constraints=specs))
+            std_fields.append(StdField(name=tf.name, value=v, source=field_src, constraints=specs))
 
         # allow_extra=true：额外字段作为扩展字段进入内容（按调用点 scope 解析）
         for name, (arg_val, arg_src) in extra_args.items():
@@ -965,4 +998,9 @@ class AstBuilder:
         # 模板级约束（: 起始，约束整个 dict）：解析后挂到实例节点
         tpl_specs, tpl_diags = resolve_constraint_list(template.constraints, inner_scope)
         self._collector.extend(tpl_diags)
-        return StdObject(fields=self._finalize_object(std_fields, path), template=key, constraints=tpl_specs)
+        return StdObject(
+            fields=self._finalize_object(std_fields, path),
+            template=key,
+            constraints=tpl_specs,
+            source=source,
+        )

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/builder/models.py

@@ -24,14 +24,16 @@ from infinity_data.semantic.std import (
     StdArray,
     StdField,
     StdLiteral,
+    StdNode,
     StdObject,
     StdValue,
+    is_std_node,
     is_std_value,
     python_to_std,
 )
 
 if TYPE_CHECKING:
-    from infinity_data.semantic.resolver.models import Scope, TemplateKey
+    from infinity_data.semantic.resolver.models import TemplateKey
 
 __all__ = [
     'LiteralKind',
@@ -40,8 +42,10 @@ __all__ = [
     'StdDocument',
     'StdField',
     'StdLiteral',
+    'StdNode',
     'StdObject',
     'StdValue',
+    'is_std_node',
     'is_std_value',
     'python_to_std',
 ]
@@ -58,8 +62,10 @@ class StdDocument:
 
     - ``root``：编译产物（顶层对象）
     - ``templates``：全部已加载模板（:class:`TemplateKey` → 定义，含 ``!from`` 导入的）
-    - ``scope``：**入口文件**的可见名表（可见名 → :class:`TemplateKey`），
-      与 ``templates`` 配合可完整解析：可见名 → TemplateKey → TemplateDef
+    - ``scope``：**入口文件**的可见名表快照（可见名 → :class:`TemplateKey`），
+      与 ``templates`` 配合可完整解析：可见名 → TemplateKey → TemplateDef。
+      纯快照（普通 dict）：各文件的 `$` 命名空间 / !var 关联在 Phase 1 的
+      :class:`Scope` 上（§1.8），不随产物下发。
 
     不携带诊断：所有诊断经共享 :class:`DiagnosticCollector` 收集，
     由流水线在 :class:`CompilationResult` 上承载——诊断不属于文档数据。
@@ -67,4 +73,4 @@ class StdDocument:
 
     root: StdObject = field(default_factory=StdObject)
     templates: dict[TemplateKey, TemplateDef] = field(default_factory=lambda: {})
-    scope: Scope = field(default_factory=lambda: {})
+    scope: dict[str, TemplateKey] = field(default_factory=lambda: {})

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/constraints.py

@@ -141,7 +141,7 @@ def resolve_constraint_arg(c: Constraint, scope: Scope) -> tuple[Any, list[Diagn
 
 def translate_name(name: str, scope: Scope) -> str:
     """可见名 → 真名字符串。未命中（如 has(field) 的裸字段名）保留原名。"""
-    key = scope.get(name)
+    key = scope.visible.get(name)
     return str(key) if key is not None else name
 
 

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/executor/executor.py

@@ -67,7 +67,8 @@ class ConstraintExecutor:
                 self._validate_field(f, collector, path)
             # 结构级约束（dict 级 / 模板级 / 顶层）：全部执行（不短路）
             for spec in node.constraints:
-                result = self._exec(spec, node, spec.source, path)
+                # 诊断指向被检查的对象本身（无来源时回退约束表达式位置）
+                result = self._exec(spec, node, node.source or spec.source, path)
                 if not result.ok:
                     collector.extend(result.diagnostics)
         elif isinstance(node, StdArray):
@@ -79,8 +80,10 @@ class ConstraintExecutor:
         child = f'{path}.{field.name}' if path else field.name
         if field.value is not None:
             self.validate(field.value, collector, child)
+        # 被检查对象 = 字段值：诊断指向值本身（无来源时回退字段位置）
+        value_src = field.value.source if field.value is not None else None
         for spec in field.constraints:
-            result = self._exec(spec, field.value, spec.source or field.source, child)
+            result = self._exec(spec, field.value, value_src or field.source, child)
             if not result.ok:
                 collector.extend(result.diagnostics)
                 break  # 约束链短路（与构建期语义一致）
@@ -105,7 +108,9 @@ class ConstraintExecutor:
         key = self._templates_by_name.get(constraint.name)
         if key is not None:
             return self._check_template(key, value, source, path)
-        return self._registry.apply(constraint, value, constraint.source or source, path, self._exec)
+        # 诊断位置 = 被检查对象的位置（调用方已按值/字段/对象解析），
+        # 不再取约束表达式自身（spec.source）——错误指向值而非约束声明
+        return self._registry.apply(constraint, value, source, path, self._exec)
 
     def _check_template(
         self,
@@ -157,7 +162,9 @@ class ConstraintExecutor:
                 specs, rdiags = resolve_constraints(tf.constraints, scope)
                 diags.extend(rdiags)
                 for spec in specs:
-                    result = self._exec(spec, f.value, tf.source, child)
+                    # 诊断指向手写 dict 中被检查的字段值（而非模板定义里的约束）；
+                    # 值/字段均无来源（如外部导入数据）时回退外层被检查对象位置
+                    result = self._exec(spec, f.value, f.value.source or f.source or source, child)
                     if not result.ok:
                         diags.extend(result.diagnostics)
                         break
@@ -242,7 +249,8 @@ class ConstraintExecutor:
                 specs, rdiags = resolve_constraints(tf.constraints, scope)
                 diags.extend(rdiags)
                 for spec in specs:
-                    result = self._exec(spec, f.value, tf.source, tf.name)
+                    # 诊断指向顶层对象中被检查的字段值（而非模板定义里的约束）
+                    result = self._exec(spec, f.value, f.value.source or f.source, tf.name)
                     if not result.ok:
                         diags.extend(result.diagnostics)
 
@@ -250,7 +258,8 @@ class ConstraintExecutor:
         specs, rdiags = resolve_constraint_list(tpl.constraints, scope)
         diags.extend(rdiags)
         for spec in specs:
-            result = self._exec(spec, root, None, '')
+            # 顶层对象无来源时回退约束表达式位置（避免丢位置）
+            result = self._exec(spec, root, root.source or spec.source, '')
             if not result.ok:
                 diags.extend(result.diagnostics)
 

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/registry/dict_constraints.py

@@ -62,4 +62,6 @@ def _check_field(
     # noexist = 键不出现 → 视为字段缺失（与 has 同理）
     if f is None or f.is_noexist:
         return fail_result('constraint.field_missing', {'field': name}, source, path)
-    return executor(spec, f.value, source, f'{path}.{name}')
+    # 诊断指向被检查的字段值本身（无来源时回退字段位置）
+    f_src = f.value.source if f.value is not None else f.source
+    return executor(spec, f.value, f_src or source, f'{path}.{name}')

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/registry/general.py

@@ -123,12 +123,15 @@ def _check_each(
     diags: list[Diagnostic] = []
     if isinstance(val, StdArray):
         for i, elem in enumerate(val.elements):
-            r = executor(spec, elem, source, f'{path}[{i}]')
+            # 诊断指向被检查的元素本身（无来源时回退容器位置）
+            r = executor(spec, elem, elem.source or source, f'{path}[{i}]')
             if not r.ok:
                 diags.extend(r.diagnostics)
     elif isinstance(val, StdObject):
         for f in val.fields:
-            r = executor(spec, f.value, source, f'{path}.{f.name}')
+            # 诊断指向被检查的字段值本身（无来源时回退字段位置）
+            f_src = f.value.source if f.value is not None else f.source
+            r = executor(spec, f.value, f_src or source, f'{path}.{f.name}')
             if not r.ok:
                 diags.extend(r.diagnostics)
     else:
@@ -162,7 +165,9 @@ def _check_position(
         return fail_result('constraint.position_need', {}, source, path)
     if idx < 0 or idx >= len(val.elements):
         return fail_result('constraint.position_out', {'index': idx, 'size': len(val.elements)}, source, path)
-    return executor(spec, val.elements[idx], source, f'{path}[{idx}]')
+    # 诊断指向被检查的元素本身（无来源时回退容器位置）
+    elem = val.elements[idx]
+    return executor(spec, elem, elem.source or source, f'{path}[{idx}]')
 
 
 def _check_in(

{infinity_data-2.1.0 → infinity_data-2.2.0}/src/infinity_data/semantic/resolver/identity.py

@@ -1,11 +1,13 @@
-"""模板真名计算：直接依赖组合哈希（§2.5）。
+"""模板真名计算：直接依赖组合哈希（§2.5，含 `$` 数据依赖）。
 
-    identity(T) = SHA256(canon(T) || sorted(identity(直接依赖模板)))
+    identity(T) = SHA256(canon(T) || sorted(identity(直接依赖模板)) || sorted(import_identity(T 的 $ 引用)))
 
 - ``canon(T)``：:meth:`TemplateDef.canonical` —— AST 规范化序列化，输出**标准
   infd 源码**（可被 parser 还原，round-trip；排除 source/位置，注释不影响）
 - 直接依赖：T 定义文件 scope 中、T 实际引用的模板（值位置模板调用 + 约束中的
   模板名，排除注册约束名——模板名不与已注册约束同名，见 ``template.shadows_builtin``）
+- ``import_identity``：T 定义文件命名空间中其 `$` 引用对应绑定的**导入真名**（§1.8）
+  ——模板身份覆盖数据依赖（!file/!env/!var 来源变化 → 身份变化，可审计）
 - 闭包无需显式计算（Merkle 式）：直接依赖的 identity 已含其自身依赖子树
 - 环处理：DFS 栈上的依赖退化为「该模板内容 hash」（不递归），保证终止、确定、路径无关
 
@@ -22,6 +24,7 @@ from collections.abc import Collection
 from infinity_data.parser import (
     ConstraintCall,
     ConstraintIdent,
+    DollarValue,
     TemplateCallValue,
     TemplateDef,
     walk,
@@ -53,12 +56,26 @@ def extract_dependencies(tpl: TemplateDef, scope: Scope, builtin_names: Collecti
     for n in names:
         if n in builtin_names:
             continue  # 注册约束（内置/自定义）名，非模板依赖
-        key = scope.get(n)
+        key = scope.visible.get(n)
         if key is not None:
             deps.add(key)
     return deps
 
 
+def extract_import_dependencies(tpl: TemplateDef, scope: Scope) -> set[str]:
+    """模板 T 的 `$` 数据依赖：walk 收集 ``$`` 引用名，映射为定义文件命名空间的**导入真名**（§1.8）。
+
+    导入真名由 scope 对象自身携带（``scope.import_identities``）；真名是叶子哈希
+    （无递归），直接进入模板身份组合；找不到映射（如 `$` 未定义或该文件无对应
+    导入绑定）→ 跳过。数据来源变化 → 导入真名变化 → 模板身份变化。
+    """
+    idents = scope.import_identities
+    if not idents:
+        return set()
+    names = {node.name for node in walk(tpl) if isinstance(node, DollarValue)}
+    return {idents[n] for n in names if n in idents}
+
+
 # ═══════════════════════════════════════════════════════════
 # 依赖闭包组合哈希
 # ═══════════════════════════════════════════════════════════
@@ -73,16 +90,20 @@ def compute_identity_map(
     template_scopes: dict[TemplateKey, Scope],
     builtin_names: Collection[str],
 ) -> dict[TemplateKey, TemplateKey]:
-    """计算 old → new 的 TemplateKey 映射（新 identity = 依赖闭包组合哈希）。
+    """计算 old → new 的 TemplateKey 映射（新 identity = 依赖闭包组合哈希 + $ 数据依赖）。
 
-    - 无环：``identity = hash(content_hash || sorted(依赖 identity))``
+    - 无环：``identity = hash(content_hash || sorted(依赖 identity) || sorted(导入真名))``
     - 环：DFS 栈上依赖退化为内容 hash（不递归）——终止、确定、路径无关
+    - `$` 导入真名由各定义点 scope 自身携带（§1.8，``scope.import_identities``）
     """
     content_hashes: dict[TemplateKey, str] = {}
     dependencies: dict[TemplateKey, set[TemplateKey]] = {}
+    import_deps: dict[TemplateKey, set[str]] = {}
     for key, tpl in templates.items():
         content_hashes[key] = _content_hash(tpl)
-        dependencies[key] = extract_dependencies(tpl, template_scopes.get(key, {}), builtin_names)
+        scope = template_scopes.get(key, Scope())
+        dependencies[key] = extract_dependencies(tpl, scope, builtin_names)
+        import_deps[key] = extract_import_dependencies(tpl, scope)
 
     memo: dict[TemplateKey, str] = {}
     stack: set[TemplateKey] = set()
@@ -94,7 +115,8 @@ def compute_identity_map(
             return content_hashes[key]  # 环：依赖退化为内容 hash（不递归）
         stack.add(key)
         dep_ids = sorted(identity_of(d) for d in dependencies[key])
-        combined = content_hashes[key] + '|' + ','.join(dep_ids)
+        import_ids = sorted(import_deps[key])
+        combined = content_hashes[key] + '|' + ','.join(dep_ids) + '|' + ','.join(import_ids)
         ident = IDENTITY_PREFIX + hashlib.sha256(combined.encode('utf-8')).hexdigest()
         memo[key] = ident
         stack.remove(key)