expressir 2.4.32 → 2.4.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c99980cc78fb445ea5c87f6b550c136c348e4b760b9fdabad8caf4a60a29884
-  data.tar.gz: 7effdd8da82e7a788dfedadfd54e13013febc24e90103542c1579052405e6e8d
+  metadata.gz: 11ae98e1866bac67ff62c5a8f27abd2f06d94c62f8f7468c43d67554e1d4cd48
+  data.tar.gz: a4ee98f12efb95ca5d3302aa8835120b2bad67ca37181430c9c4fcc1bbc8c561
 SHA512:
-  metadata.gz: ba219b7e2d9e4b740776308e31f3c14bdc0283c62e6400b83427b7f338a74acef3f5f8afad9ca1e57968204dc1d3e6c352c2f37bf5c7ea540daed395ceab783c
-  data.tar.gz: d9c2d5ad92afd32f7b38013e5f7c16795370c3d682e13fe60e4ee577602497e474b89dd3e475bed88f74a9f169053a51ac35bd66748909fa729400fdd78db346
+  metadata.gz: 0ec3c593547ace542482f7b5371d446dc7810e5e52f250281f0b5a6bca742d05c31abf15a8dc25456845314c98bdc673351a458a88384ea5e2d06b499904a411
+  data.tar.gz: b2f7b4a8c851a61024baa8601c826c649bcff17393d91934a4faf5d75ee2ecf0936697bd5178a92dd36d3c850a809ac9c6ed39cf70fda3fb4aba3646698b65b8

data/TODO.eengine/00-overview.md

@@ -0,0 +1,39 @@
+# TODO.eengine — the eengine-parity program
+
+Consolidates the remaining eengine-parity tasks (formerly scattered
+across TODO.parity-ee) into one execution-ordered series. The oracle
+is eengine-5.1.0 (GIT eeng-5.1.0) at `~/src/external/exp-engine-engine`; where
+eengine and ISO 10303-11 disagree, the standard wins and the
+divergence is classified in the differential output.
+
+## Execution order and status
+
+| n | task | folds | status |
+|---|------|-------|--------|
+| 01 | resolution diagnostics + USE/REFERENCE tiering | 06-remainder, 07-part | done |
+| 02 | check-p11 catalog completion | 07, 12 | done (type-resolution tranche; generic unresolved-ref walk covers expression bodies; subtype-constraint supertype refs + SELF redeclaration resolution added; constness has no eeng rule — covered by the generic walk) |
+| 03 | entity computations (inherited/derived/inverse closures) | matrix §3, 05-prereq | done |
+| 04 | SHTOLO rule audit + corpus differential | 14-remainder | done (audit spec live; G.NM.2 + G.1.10 fixed; G.1.6 synthesis remains per annex-g-rules.md) |
+| 05 | SHTOLO longform flatten (Annex G) | 05 | done |
+| 06 | population / Part 21 reader + validation | 13 | done (parsanol reader; schema-mapping validator; Annex H corpus clean; eengine p21 differential blocked — eeng 5.1.0 aborts bare-p11 validate/*PARSE-MODE* NIL, every -MODE demands stepmod context) |
+| 07 | schema compare & patch | 16 | done (SchemaCompare canonical-path deltas + SchemaPatch.apply; oracle differential vs eeng --compare green on add/remove entity/attribute + enum-value changes) |
+| 08 | official corpus CI gate | 17 | done |
+| 09 | MIM mapping parser | 18 | done |
+
+## Sources
+
+- eengine: `~/src/external/exp-engine-engine` (kernel/*.lisp,
+  plugins/p11/*.lisp, plugins/p21/*).
+- ISO 10303-11 clause text: `~/src/mn/iso-10303-11/sources/sections/`.
+- Detached docs: `~/src/mn/iso-10303-detached-docs/sources/` (Part 21
+  grammar, Part 28 text).
+
+## Standing rules
+
+- Semantics land in Ruby; parse-adjacent and graph-scale work lands in
+  expressir-rs (TODO.parity-ee 19, option B).
+- Where eengine and the standard disagree, the standard wins; every
+  such divergence is classified in the differential output, never
+  silently copied.
+- Every ported check keeps its eengine note id for oracle
+  cross-referencing, and cites its ISO 10303-11 clause.

data/TODO.eengine/01-resolution-diagnostics.md

@@ -0,0 +1,30 @@
+# 01 — Resolution diagnostics + USE/REFERENCE tiering
+
+Folds the shipped remainder of TODO.parity-ee 06 (transitive USE and
+the cycle guard are in; `interface_visibility_spec.rb` gates them)
+with the tiering half of 07.
+
+## Gaps
+
+- USE FROM resolves **type + entity only**; REFERENCE FROM resolves
+  constant/entity/function/procedure/type (eeng
+  resolve-interface.lisp:30-66). Our resolution treats both alike.
+- Unresolved resources: eeng hard-errors `Resource '~A' not found`;
+  we warn (severity folded here from 07).
+
+## Design
+
+- `Schema#interfaced_items(kind:)` filters by interface kind.
+- `Schema#resolve_item(name, kinds:)` walks own declarations then
+  interfaces (transitively through USE for :use-from scope),
+  cycle-guarded, honoring per-kind restriction.
+- `Expressir::Express::Checker` reports unresolved references as
+  errors (`E-RES-001`, the eeng note id family) with schema+name.
+
+## Acceptance
+
+- USE-only visibility: an interface's function is NOT visible through
+  USE FROM; IS visible through REFERENCE FROM.
+- Transitive USE chains still resolve (06's shipped behavior).
+- Cycle-guarded resolution terminates.
+- The checker flags an unresolved USE FROM resource as an error.

data/TODO.eengine/02-check-catalog-completion.md

@@ -0,0 +1,53 @@
+# 02 — check-p11 catalog completion
+
+Folds TODO.parity-ee 07 + 12. Shipped subset: interface redundant,
+interface resource duplicate, subtype ref/cycle, duplicate
+declaration, where/unique name pattern, unresolved ref, select/enumeration
+extended type, self-schema reference, parse failure.
+
+## Sources
+
+- `~/src/external/exp-engine-engine/kernel/check.lisp` (835 lines,
+  per-node-type check-p11 methods) + `kernel/check-notes.lisp`.
+- ISO 10303-11:2004 clause text:
+  `~/src/mn/iso-10303-11/sources/sections/`.
+
+## Port list (diff of eeng methods vs shipped subset)
+
+Per eeng check-p11: entity attribute redeclare compatibility,
+inverse target/entity/attribute existence, derive aggregation rules,
+rule-entity reference containment, function/procedure parameter and
+return checks, subtype-constraint reflexive/rule references,
+constant expression constness. Each ported check keeps the eeng note
+id and cites its ISO 10303-11 clause.
+
+## Acceptance
+
+- eeng-differential over the SRL corpus: every eeng-emitted note of
+  the ported kinds is emitted here with matching schema/name; no
+  false positives on clean corpora (express suite green).
+
+## Status: done
+
+Shipped across three tranches:
+
+1. Original subset — interface redundant, interface resource
+   duplicate, subtype ref/cycle, duplicate declaration, where/unique
+   name pattern, unresolved ref, select/enumeration extended type,
+   self-schema reference, parse failure; inverse target/entity/
+   attribute checks; group references; aggregate bounds;
+   check-attrib-name-fun.
+2. Type-resolution tranche — constant/local/parameter/return types
+   (eeng check-constant-type, check-local-type, check-parameter-type,
+   check-fun-return-type) plus rule FOR entity refs.
+3. Remainder — subtype-constraint supertype-expression refs (eeng
+   kernel/check.lisp:426, check_supertype_ref note id) and
+   SELF\ redeclaration resolution (ISO 10303-11:2004 9.2.2.3; eeng
+   kernel/check.lisp:255 comment-only). Expression bodies are covered
+   generically by check_unresolved_refs; eengine has no separate
+   constant-expression constness rule (kernel/check.lisp only checks
+   the constant's type), so that port-list item closes as covered.
+
+Foreign-blindness rule: names that do not resolve in a single-file
+parse (USE FROM targets of unloaded schemas) are skipped, not flagged —
+both new checks verified note-free over 265 stepmod resource schemas.

data/TODO.eengine/03-entity-computations.md

@@ -0,0 +1,22 @@
+# 03 — Entity computations
+
+Matrix §3: eeng materializes inherited attributes and closures
+(kernel/compute-inheritance.lisp, derive-attrs.lisp,
+inverse-attrs.lisp, supertypes.lisp, explicit-attrs.lisp); expressir
+walks supertype chains ad hoc. Needed by Annex G.2.6 select synthesis
+(04/05) and the entity checks (02).
+
+## Design
+
+- `Entity#supertype_closure` — transitively closed supertype refs,
+  cycle-safe.
+- `Entity#inherited_explicit_attributes` — explicit attributes from
+  the full closure, redeclaration-aware (SELF\\supertype.attr
+  overrides).
+- `Entity#derived_attributes` / `Entity#inverse_attributes` —
+  accumulated from the closure.
+
+## Acceptance
+
+- chain + multiple inheritance + redeclaration fixtures; the
+  materialization matches a hand-computed table.

data/TODO.eengine/04-shtolo-rule-audit.md

@@ -0,0 +1,32 @@
+# 04 — SHTOLO rule audit + corpus differential
+
+Folds TODO.parity-ee 14's remainder.
+
+- Walk `spec/fixtures/shtolo/annex-g-rules.md` (G.NM.1-2, G.1.1-10,
+  G.2.1-7): mark every rule PASS/partial/✖ with a fixture per rule.
+- G.1.6 dependently-instantiable output verified against the Annex G
+  text (eeng ✖ there; the standard wins).
+- name-munging policy (`_dot_` and friends): eeng ✖; standard wins.
+- prune-pass reachability (unreachable subtype branches).
+- corpus differential: every modules.lst module arm/mim, flat output
+  diffed vs eeng :flat, divergences classified.
+
+## Result: DONE (2026-10-15) — the audit is a live spec
+
+`shtolo_annex_g_rule_audit_spec.rb` — 8 examples, one per previously
+uncovered rule. Audited outcome:
+
+- G.NM.2, G.1.2, G.1.5, G.1.8 (model-direct), G.2.3, G.2.4, G.2.6 —
+  PASS (G.2.4's folded extension keeps its G.NM.1-munged name —
+  correct per the name-clash rule).
+- G.1.10 — was absent; **implemented** (`add_provenance_remark!`):
+  all-or-none provenance remark on the longform schema with
+  schema + schema_version_id lines.
+- Still open (recorded in annex-g-rules.md): G.1.6
+  dependently-instantiable RULE/FUNCTION synthesis (eeng ✖; annex is
+  the contract) and the G.1.9 prune-depth notes.
+
+Fixture note: `EXTENSIBLE_ENUMERATION` as a single composite keyword
+is not in the grammar and not in the corpus — the corpus writes
+`EXTENSIBLE ENUMERATION` (302×) / `EXTENSIBLE SELECT` (546×), both
+supported.

data/TODO.eengine/05-shtolo-longform-flatten.md

@@ -0,0 +1,12 @@
+# 05 — SHTOLO longform flatten (Annex G)
+
+TODO.parity-ee 05. Convert the STEPmod multi-schema web into ONE
+ISO 10303-11:1994 longform schema: no interfaces, visibility
+preserved as rules, no name clashes, unreachable declarations pruned.
+
+Sources: `ag-single-schema.adoc` (rule ids), eeng run-op (:flat) +
+print-flatten + wo-flat.lisp (373 lines; eeng keeps structure and
+lowercases — the standard wins on divergence), add/remove-declaration
+and cleanup-interface lisps.
+
+Builds on 01 (visibility), 03 (closures), 04 (rule audit).

data/TODO.eengine/06-population-p21.md

@@ -0,0 +1,34 @@
+# 06 — Population / Part 21
+
+TODO.parity-ee 13, scope ladder (each step ships):
+
+1. P21 reader: parsanol grammar for ISO 10303-21 (HEADER entities,
+   DATA section: complex instances `(A(...)B(...))`, simple
+   `#1=TYPE(...)`, list/set/typed-ref values, enums `.T.`, binary
+   `"...`, redefines `/`); a `Model::Population` (header + instances).
+2. Population validation against a loaded schema: instance entity
+   exists (direct or complex against the supertype graph), attribute
+   names/arity match, value types check.
+3. eengine differential on the Part 21 fixtures
+   (`~/src/mn/iso-10303-detached-docs/sources/iso-10303-21*`).
+
+## Status: done
+
+1. Reader — `Expressir::P21` (parsanol grammar + PopulationBuilder):
+   HEADER FILE_* entities, DATA simple/complex instances, lists,
+   typed parameters, references, enumerations, binaries, strings
+   (doubled-quote escape), `$`/`*`, `/* */` comments.
+2. Validator — `Expressir::P21::Validator`: FILE_SCHEMA name,
+   instance keywords, complex-record supertype cliques, mapped
+   attribute arity in Part 21 order (supertype attributes first;
+   DERIVE-redeclared slots keep their position valued `*` per clause
+   12.2.6), enumeration membership, instance references,
+   typed-parameter resolution; optional short_names map for clause
+   12.3 short names.
+3. Corpus — ISO 10303-21 Annex H complete exchange structure parses
+   and validates clean (13 instances, comments, short names).
+
+eengine differential (ladder step 3) is blocked by the oracle build:
+eengine 5.1.0 --validate/--xref abort loading a bare p11 schema
+(*PARSE-MODE* NIL) and every -MODE demands a stepmod context, while
+--validate itself is flagged "not fully supported" upstream.

data/TODO.eengine/07-schema-compare-patch.md

@@ -0,0 +1,25 @@
+# 07 — Schema compare & patch
+
+TODO.parity-ee 16. Structural diff of two schemata with a
+machine-applicable patch: declarations matched by canonical path
+(`schema.item`); deltas added/removed/changed (per-attribute
+structural diff: types, optionality, aggregates); patch output
+declarable against the flattened base (eeng `--compare`/`--patch`
+semantics, plugin/p11 compare entry).
+
+## Status: done
+
+- `Expressir::Express::SchemaCompare` — deltas at `schema.item` and
+  entity-attribute `schema.item.attribute` paths; signatures are
+  lutaml-model `to_hash` trees stripped of resolution artifacts
+  (`base_path`, `ref`, `source`, remarks).
+- `Expressir::Express::SchemaPatch.apply` — rebuilds the revised
+  schema through the framework round trip; the base is never mutated;
+  item-level `:changed` nodes subsume their attribute sub-deltas.
+- Interfaces are out of scope by design: the patch target is a
+  flattened (longform) schema.
+- Oracle: `spec/expressir/express/schema_compare_oracle_spec.rb`
+  agrees with `eengine --compare -MODE RESOURCE -STEPMOD <checkout>`
+  on added/removed entities, removed attributes and enum-value type
+  changes; gated on binary + stepmod checkout presence
+  (EENGINE_BIN / STEPMOD_DIR).

data/TODO.eengine/08-official-corpus-gate.md

@@ -0,0 +1,7 @@
+# 08 — Official corpus CI gate
+
+TODO.parity-ee 17. One rake task mapping every official corpus to
+specs, with CI tiers: (a) every push — eeng bug corpus (bug39/40),
+SHTOLO rule fixtures, Part 21 grammar fixtures; (b) nightly/manual —
+SRL/SMRL full corpus differentials (pretty/flat/xml) when the eengine
+oracle is on PATH.

data/TODO.eengine/09-mim-mapping-parser.md

@@ -0,0 +1,9 @@
+# 09 — MIM mapping parser
+
+TODO.parity-ee 18 (expressir#88). Parse + validate MIM reference
+paths into a typed model: entity chains `A -> B -> C`, qualifiers
+`[attr => val]`, `=>` derived references, `->>` subtype traversal,
+`<>` select member. Sources: this checkout's
+`schemas/modules/*/mapping.yaml` (`<<express:SCHEMA.ITEM,ITEM>>` link
+markup), upstream module.xml `reference_path` bodies, the Part 1x
+mapping-annex grammar; the module corpus is the oracle.

data/lib/expressir/express/checker.rb

@@ -82,6 +82,13 @@ module Expressir
         blength insert remove
       ].freeze
 
+      USE_ITEM_KINDS = [Model::Declarations::Entity, Model::Declarations::Type].freeze
+      REFERENCE_ITEM_KINDS = [
+        Model::Declarations::Constant, Model::Declarations::Entity,
+        Model::Declarations::Function, Model::Declarations::Procedure,
+        Model::Declarations::Type
+      ].freeze
+
       private
 
       def note!(id, severity, schema, message, node = nil)
@@ -92,6 +99,7 @@ module Expressir
       def check_schema(schema)
         check_duplicates(schema)
         check_interfaces(schema)
+        check_type_resolutions(schema)
         check_self_schema_reference(schema)
         schema.entities.each { |e| check_entity(schema, e) }
         schema.types.each do |t|
@@ -100,9 +108,11 @@ module Expressir
           check_where_rules(schema, t, t.where_rules)
         end
         schema.rules.each { |r| check_where_rules(schema, r, r.where_rules) }
+        check_subtype_constraints(schema)
         schema.entities.each do |entity|
           check_aggregate_bounds(schema, entity)
           check_attrib_name_fun(schema, entity)
+          check_attribute_redeclarations(schema, entity)
         end
         check_string_references(schema)
         check_unresolved_refs(schema)
@@ -184,14 +194,44 @@ module Expressir
           end
 
           resource_names(iface).each do |name|
-            next if foreign_decl?(foreign, name)
+            decl = foreign_declaration(foreign, name)
+            unless decl
+              note!(:check_unresolved_ref, :error, schema,
+                    "interface resource '#{name}' not in schema '#{target}'", iface)
+              next
+            end
 
-            note!(:check_unresolved_ref, :error, schema,
-                  "interface resource '#{name}' not in schema '#{target}'", iface)
+            # eeng resolve-interface: use-from resolves via
+            # find-type/entity, reference-from via the 5-kind or-chain;
+            # anything else is "Resource '~A' not found".
+            next if item_kind_interfacable?(iface.kind, decl)
+
+            note!(:check_interface_kind_restriction, :error, schema,
+                  "interface resource '#{name}' is a #{decl.class.name.split('::').last}: " + "#{iface.kind} resolves #{allowed_kinds(iface.kind)} only", iface)
           end
         end
       end
 
+      def item_kind_interfacable?(kind, decl)
+        (kind == Model::Declarations::Interface::REFERENCE ? REFERENCE_ITEM_KINDS : USE_ITEM_KINDS)
+          .any? { |k| decl.is_a?(k) }
+      end
+
+      def allowed_kinds(kind)
+        (kind == Model::Declarations::Interface::REFERENCE ? REFERENCE_ITEM_KINDS : USE_ITEM_KINDS)
+          .map { |k| k.name.split("::").last }.join(", ")
+      end
+
+      def foreign_declaration(schema, name)
+        key = name.safe_downcase
+        DECL_COLLECTIONS.each do |coll|
+          Array(schema.public_send(coll)).each do |d|
+            return d if d.id&.safe_downcase == key
+          end
+        end
+        nil
+      end
+
       def iface_schema_name(iface)
         iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
       end
@@ -210,6 +250,85 @@ module Expressir
         end
       end
 
+      # eeng check-p11 context checks (kernel/check.lisp:160-201,
+      # 299-336, 337-395): constant/local/parameter/return types must
+      # resolve to a TYPE or ENTITY visible in the schema (find-type/
+      # entity semantics - constants, functions, procedures do NOT
+      # satisfy them). Note ids are the eeng ones.
+      def check_type_resolutions(schema)
+        schema.constants.each do |constant|
+          check_type_ref(schema, Array(constant.type), :check_constant_type, constant.id, constant)
+        end
+
+        schema.functions.each do |function|
+          Array(function.parameters).each do |param|
+            check_type_ref(schema, Array(param.type), :check_parameter_type, param.id, param)
+          end
+          check_type_ref(schema, Array(function.return_type),
+                         :check_function_return_type, function.id, function)
+          Array(function.variables).each do |variable|
+            check_type_ref(schema, Array(variable.type), :check_local_type, variable.id, variable)
+          end
+        end
+
+        schema.procedures.each do |procedure|
+          Array(procedure.parameters).each do |param|
+            check_type_ref(schema, Array(param.type), :check_parameter_type, param.id, param)
+          end
+          Array(procedure.variables).each do |variable|
+            check_type_ref(schema, Array(variable.type), :check_local_type, variable.id, variable)
+          end
+        end
+
+        schema.rules.each do |rule|
+          Array(rule.applies_to).each do |entity_ref|
+            # parameter-rule: the FOR entities resolve via
+            # find-type/entity too (kernel/check.lisp:311-322)
+            check_entity_ref(schema, Array(entity_ref), :check_parameter_type, rule.id, rule)
+          end
+          Array(rule.variables).each do |variable|
+            check_type_ref(schema, Array(variable.type), :check_local_type, variable.id, variable)
+          end
+        end
+      end
+
+      def check_type_ref(schema, nodes, note_id, name, node)
+        nodes.each do |type|
+          next unless type.is_a?(Model::References::SimpleReference)
+          next if type.id.nil? || builtin?(type.id)
+          next if resolves_to_type_or_entity?(schema, type.id)
+
+          note!(note_id, :error, schema,
+                "type '#{type.id}' of '#{name}' does not resolve to a type or entity", node || type)
+        end
+      end
+
+      def check_entity_ref(schema, nodes, note_id, name, node)
+        nodes.each do |ref|
+          next unless ref.is_a?(Model::References::SimpleReference)
+          next if ref.id.nil?
+          next if resolves_to_type_or_entity?(schema, ref.id)
+
+          note!(note_id, :error, schema,
+                "entity '#{ref.id}' of '#{name}' does not resolve to a type or entity", node || ref)
+        end
+      end
+
+      def resolves_to_type_or_entity?(schema, name)
+        key = name.safe_downcase
+        schema.children.any? do |child|
+          next false unless child.id&.safe_downcase == key
+
+          child.is_a?(Model::Declarations::Type) || child.is_a?(Model::Declarations::Entity) ||
+            (child.is_a?(Model::Declarations::InterfacedItem) && interface_item_type_or_entity?(child))
+        end
+      end
+
+      def interface_item_type_or_entity?(item)
+        base = item.base_item
+        base.is_a?(Model::Declarations::Type) || base.is_a?(Model::Declarations::Entity)
+      end
+
       def check_entity(schema, entity)
         Array(entity.subtype_of).each do |ref|
           id = ref.is_a?(String) ? ref : ref.id
@@ -282,6 +401,75 @@ module Expressir
 
       # eeng check-supertype-ref: every entity named in the SUPERTYPE
       # expression must resolve to an entity of this schema.
+      # eeng check-p11 subtype_constraint (kernel/check.lisp:426) only
+      # checks the supertype expression; the note id matches the entity
+      # supertype path (kernel/check.lisp:523).
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |attr| attr.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def check_subtype_constraints(schema)
+        schema.subtype_constraints.each do |constraint|
+          expr = constraint.supertype_expression
+          next unless expr
+
+          each_reference(expr) do |ref|
+            id = ref.id
+            next if id.nil?
+            # Names outside this schema's scope (foreign entities of a
+            # single-file parse) cannot be verified here.
+            next unless resolves_to_type_or_entity?(schema, id)
+            next if find_entity(schema, id)
+
+            note!(:check_supertype_ref, :error, schema,
+                  "SUBTYPE_CONSTRAINT #{constraint.id}: supertype " \
+                  "'#{id}' is not an entity", constraint)
+          end
+        end
+      end
+
+      # A `SELF\<supertype>.<attr>` redeclaration must name a supertype
+      # in the inheritance closure carrying that attribute (ISO
+      # 10303-11:2004, 9.2.2.3). eeng kernel/check.lisp:255 leaves this
+      # as a TODO comment, so this check has no eeng note id.
+      def check_attribute_redeclarations(schema, entity)
+        explicit_attributes(entity).each do |attr|
+          tag = attr.supertype_attribute
+          next unless tag.is_a?(Model::References::AttributeReference)
+
+          sup_id = tag.ref&.entity&.id
+          attr_id = tag.attribute&.id
+          if sup_id.nil?
+            note!(:check_attribute_redeclaration, :error, schema,
+                  "ENTITY #{entity.id}: redeclaration of '#{attr.id}' " \
+                  "names no supertype", attr)
+            next
+          end
+
+          supertype = entity.supertype_closure
+            .find { |st| st.id&.safe_downcase == sup_id.safe_downcase }
+          if supertype.nil?
+            # The named supertype may be foreign (USE FROM) and thus
+            # outside the closure of a single-file parse; only flag it
+            # when it resolves in this scope yet is not a supertype.
+            if find_entity(schema, sup_id)
+              note!(:check_attribute_redeclaration, :error, schema,
+                    "ENTITY #{entity.id}: redeclaration '#{attr.id}' names " \
+                    "'#{sup_id}', which is not a supertype", attr)
+            end
+            next
+          end
+
+          next if explicit_attributes(supertype)
+            .any? { |candidate| candidate.id&.safe_downcase == attr_id&.safe_downcase }
+
+          note!(:check_attribute_redeclaration, :error, schema,
+                "ENTITY #{entity.id}: redeclaration '#{attr.id}': supertype " \
+                "'#{sup_id}' has no attribute '#{attr_id}'", attr)
+        end
+      end
+
       def check_supertype_refs(schema, entity)
         expr = entity.supertype_expression
         return unless expr