expressir 2.4.35-arm-linux → 2.4.37-arm-linux

data/lib/expressir/express/checker.rb

@@ -32,8 +32,9 @@ module Expressir
 
       attr_reader :notes
 
-      def initialize(repository)
+      def initialize(repository, dialect: nil)
         @repository = repository
+        @dialect = dialect.nil? ? nil : Dialect.normalize(dialect)
         @notes = []
         # Case-folded index to LISTS of schemas: EXPRESS schema ids are
         # case-insensitive, and two schemas differing only in case are
@@ -89,6 +90,30 @@ module Expressir
         Model::Declarations::Type
       ].freeze
 
+      NUMERIC_TYPES = %i[integer real number].freeze
+      LOGICAL_TYPES = %i[logical boolean].freeze
+      ORDERING_FAMILIES = {
+        numeric: NUMERIC_TYPES,
+        logical: LOGICAL_TYPES,
+        string: %i[string],
+        binary: %i[binary],
+        enum: %i[enum],
+      }.freeze
+
+      TYPE_CLASS_SYMBOLS = {
+        Model::DataTypes::Integer => :integer,
+        Model::DataTypes::Real => :real,
+        Model::DataTypes::Number => :number,
+        Model::DataTypes::String => :string,
+        Model::DataTypes::Binary => :binary,
+        Model::DataTypes::Boolean => :boolean,
+        Model::DataTypes::Logical => :logical,
+        Model::DataTypes::List => :aggregate,
+        Model::DataTypes::Set => :aggregate,
+        Model::DataTypes::Bag => :aggregate,
+        Model::DataTypes::Array => :aggregate,
+      }.freeze
+
       private
 
       def note!(id, severity, schema, message, node = nil)
@@ -116,6 +141,624 @@ module Expressir
         end
         check_string_references(schema)
         check_unresolved_refs(schema)
+        check_expression_types(schema)
+        check_statement_types(schema)
+        check_rule_structure(schema)
+        check_dialect(schema) if @dialect
+      end
+
+      # ---- TODO.sota/06: edition awareness ----
+      # The grammar accepts both editions; the selected dialect decides
+      # which declarations are out of edition. The audited change list
+      # is spec/fixtures/dialects/iso-10303-11-2004-changes.yaml.
+      def check_dialect(schema)
+        modern = dialect_2004_constructs(schema)
+        deprecated = Array(schema.entities).select do |entity|
+          deprecated_inline_supertype?(entity)
+        end
+
+        if @dialect == Dialect::EDITION_1994
+          modern.each do |node, message|
+            note!(:check_dialect_2004_only, :error, schema,
+                  "dialect 10303-11:1994: #{message}", node)
+          end
+        else
+          deprecated.each do |entity|
+            note!(:check_dialect_deprecated, :warning, schema,
+                  "dialect 10303-11:2004: #{entity.id}: inline subtype " \
+                  "constraint syntax is deprecated; use SUBTYPE_CONSTRAINT " \
+                  "(Annex K)", entity)
+          end
+        end
+
+        return unless modern.any? && deprecated.any?
+
+        note!(:check_dialect_mixed, :warning, schema,
+              "dialect: schema mixes 2004-only declarations with " \
+              "edition-1 inline subtype constraint syntax", deprecated.first)
+      end
+
+      def dialect_2004_constructs(schema)
+        constructs = []
+        Array(schema.types).each do |type|
+          underlying = type.underlying_type
+          next unless underlying
+
+          if underlying.respond_to?(:extensible) && underlying.extensible
+            constructs << [type,
+                           "#{type.id}: EXTENSIBLE is not part of " \
+                           "ISO 10303-11:1994 (2004 edition, 8.4.1/8.4.2)"]
+          end
+          if underlying.respond_to?(:based_on) && underlying.based_on
+            constructs << [type,
+                           "#{type.id}: BASED_ON is not part of " \
+                           "ISO 10303-11:1994 (2004 edition, 8.4.1/8.4.2)"]
+          end
+          if underlying.respond_to?(:generic_entity) && underlying.generic_entity
+            constructs << [type,
+                           "#{type.id}: GENERIC_ENTITY is not part of " \
+                           "ISO 10303-11:1994 (2004 edition, 8.4.2)"]
+          end
+        end
+        Array(schema.subtype_constraints).each do |constraint|
+          constructs << [constraint,
+                         "#{constraint.id}: SUBTYPE_CONSTRAINT is not part " \
+                         "of ISO 10303-11:1994 (2004 edition, 9; Annex G)"]
+        end
+        constructs
+      end
+
+      def deprecated_inline_supertype?(entity)
+        expression = entity.supertype_expression
+        expression.is_a?(Model::SupertypeExpressions::OneofSupertypeExpression) ||
+          expression.is_a?(Model::SupertypeExpressions::BinarySupertypeExpression)
+      end
+
+      # ---- TODO.sota/01 tier 2: operator domain typing ----
+      # ISO 10303-11:2004 ch.12. eengine's expression checks traverse
+      # structurally only (kernel/check.lisp), so these notes carry the
+      # new :check_expr_operand_domain id with the clause in the
+      # message. A violation is flagged only when BOTH operand types
+      # are statically known.
+
+      def check_expression_types(schema)
+        check_initializer_types(schema)
+        expression_scopes(schema).each do |scope|
+          @current_expression_env = expression_env(schema, scope)
+          each_node(scope) do |node|
+            case node
+            when Model::Expressions::BinaryExpression
+              check_binary_expression_types(schema, node)
+            when Model::Expressions::UnaryExpression
+              check_unary_expression_types(schema, node)
+            when Model::Expressions::Interval
+              check_interval_types(schema, node)
+            when Model::References::IndexReference
+              check_index_reference_types(schema, node)
+            end
+          end
+        end
+        @current_expression_env = nil
+      end
+
+      def expression_scopes(schema)
+        Array(schema.constants) + Array(schema.types) +
+          Array(schema.entities) + Array(schema.functions) +
+          Array(schema.procedures) + Array(schema.rules)
+      end
+
+      # name → declared type node, for identifiers visible to the
+      # scope's expressions: the schema's constants, plus the scope's
+      # own parameters/variables/attributes.
+      def expression_env(schema, scope)
+        env = {}
+        Array(schema.constants).each do |constant|
+          env[constant.id&.safe_downcase] = constant.type if constant.id
+        end
+        case scope
+        when Model::Declarations::Entity
+          Array(scope.attributes).each do |attr|
+            env[attr.id&.safe_downcase] = attr.type if attr.id
+          end
+        when Model::Declarations::Function, Model::Declarations::Procedure
+          Array(scope.parameters).each do |param|
+            env[param.id&.safe_downcase] = param.type if param.id
+          end
+          Array(scope.variables).each do |variable|
+            env[variable.id&.safe_downcase] = variable.type if variable.id
+          end
+        when Model::Declarations::Rule
+          Array(scope.variables).each do |variable|
+            env[variable.id&.safe_downcase] = variable.type if variable.id
+          end
+        end
+        env
+      end
+
+      def check_binary_expression_types(schema, node)
+        left = static_type(schema, node.operand1)
+        right = static_type(schema, node.operand2)
+        return if undecidable?(left, right)
+
+        domain = binary_domain_violation(node.operator, left, right)
+        return unless domain
+
+        note!(:check_expr_operand_domain, :error, schema,
+              "operator '#{binary_operator_spelling(node.operator)}': " \
+              "#{domain} (#{left} vs #{right})", node)
+      end
+
+      def undecidable?(*types)
+        types.any? { |t| t.nil? || t == :unknown || t == :generic }
+      end
+
+      # nil = ok; String = the violation message body. Clauses per the
+      # TODO.sota/01 clause map.
+      def binary_domain_violation(operator, left, right)
+        case operator
+        when "ADDITION"
+          return nil if numeric_pair?(left, right) ||
+            same_pair?(left, right, :string) ||
+            same_pair?(left, right, :binary) ||
+            left == :aggregate || right == :aggregate
+
+          # 12.6 table 17: union admits an element singleton on either
+          # side of an aggregate; element↔base-type compatibility is a
+          # later tier.
+          "addition requires numeric, string, binary or aggregate " \
+            "operands (12.1, 12.3.2, 12.5.2, 12.6)"
+        when "SUBTRACTION"
+          return nil if numeric_pair?(left, right) ||
+            (left == :aggregate && right != :unknown) ||
+            same_pair?(left, right, :aggregate)
+
+          # 12.6 table 18: the difference's right operand may be an
+          # element singleton; the left must be an aggregate.
+          "difference requires an aggregate left operand (12.1, 12.6)"
+        when "MULTIPLICATION"
+          return nil if numeric_pair?(left, right) ||
+            same_pair?(left, right, :aggregate)
+
+          "intersection requires aggregate operands (12.1, 12.6)"
+        when "REAL_DIVISION", "EXPONENTIATION", "INTEGER_DIVISION", "MODULO"
+          "operator requires numeric operands (12.1)" unless numeric_pair?(left, right)
+        when "AND", "OR", "XOR"
+          "logical operator requires logical operands (12.4)" unless
+            LOGICAL_TYPES.include?(left) && LOGICAL_TYPES.include?(right)
+        when "EQUAL", "NOT_EQUAL"
+          "value comparison requires comparable operands (12.2.1)" unless
+            comparable_equality?(left, right)
+        when "LESS_THAN", "LESS_THAN_OR_EQUAL", "GREATER_THAN",
+             "GREATER_THAN_OR_EQUAL"
+          if left == :aggregate || right == :aggregate
+            unless left == :aggregate && right == :aggregate
+              return "subset/superset requires aggregate operands (12.6)"
+            end
+
+            return nil
+          end
+
+          "ordering comparison requires same-family operands (12.2.1)" unless
+            same_ordering_family?(left, right)
+        when "INSTANCE_EQUAL", "INSTANCE_NOT_EQUAL"
+          unless %i[entity aggregate select].include?(left) &&
+              %i[entity aggregate select].include?(right)
+            "instance comparison requires entity or aggregate " \
+              "operands (12.2.2)"
+          end
+        when "IN"
+          "membership requires an aggregate right operand (12.2.3)" unless
+            right == :aggregate
+        when "LIKE"
+          "like requires string operands (12.2.5)" unless
+            left == :string && right == :string
+        when "COMBINE"
+          unless left == :entity && right == :entity
+            "complex entity construction requires entity operands " \
+              "(12, precedence table note)"
+          end
+        end
+      end
+
+      def numeric_pair?(left, right)
+        NUMERIC_TYPES.include?(left) && NUMERIC_TYPES.include?(right)
+      end
+
+      def same_pair?(left, right, kind)
+        left == kind && right == kind
+      end
+
+      # 12.2.1: both operands of the same comparison family, with the
+      # numeric family spanning integer/real/number; aggregate/entity/
+      # select operands compare for (in)equality only.
+      def comparable_equality?(left, right)
+        return true if %i[aggregate entity select].include?(left) &&
+          %i[aggregate entity select].include?(right)
+
+        same_ordering_family?(left, right)
+      end
+
+      def same_ordering_family?(left, right)
+        ORDERING_FAMILIES.values.any? do |family|
+          family.include?(left) && family.include?(right)
+        end
+      end
+
+      def binary_operator_spelling(symbol)
+        {
+          "ADDITION" => "+", "SUBTRACTION" => "-", "REAL_DIVISION" => "/",
+          "INTEGER_DIVISION" => "div", "MODULO" => "mod",
+          "INSTANCE_EQUAL" => ":=:", "INSTANCE_NOT_EQUAL" => ":<>:"
+        }.fetch(symbol, symbol.downcase)
+      end
+
+      def check_unary_expression_types(schema, node)
+        t = static_type(schema, node.operand)
+        return if undecidable?(t)
+
+        violation =
+          if node.operator == "NOT"
+            "not requires a logical operand (12.4)" unless
+              LOGICAL_TYPES.include?(t)
+          else
+            unless NUMERIC_TYPES.include?(t)
+              "unary '#{node.operator.downcase}' requires a numeric " \
+                "operand (12.1)"
+            end
+          end
+        return unless violation
+
+        note!(:check_expr_operand_domain, :error, schema, violation, node)
+      end
+
+      def check_interval_types(schema, node)
+        types = [node.low, node.item, node.high].map do |part|
+          static_type(schema, part)
+        end
+        return if types.any? { |t| undecidable?(t) }
+        return if types.all? { |t| same_ordering_family?(types.first, t) } ||
+          numeric_family?(*types)
+
+        note!(:check_expr_operand_domain, :error, schema,
+              "interval bounds must be mutually comparable (12.2.4) " \
+              "(#{types.join(' vs ')})", node)
+      end
+
+      def numeric_family?(*types)
+        types.all? { |t| NUMERIC_TYPES.include?(t) }
+      end
+
+      # Static type of an expression node: a symbol from the lattice
+      # in TODO.sota/01 (:unknown when not statically decidable).
+      def static_type(schema, node, depth = 0)
+        return :unknown if node.nil? || depth > 8
+        return TYPE_CLASS_SYMBOLS[node.class] if TYPE_CLASS_SYMBOLS.key?(node.class)
+
+        case node
+        when Model::Literals::Integer then :integer
+        when Model::Literals::Real then :real
+        when Model::Literals::String then :string
+        when Model::Literals::Binary then :binary
+        when Model::Literals::Logical then :logical
+        when Model::Expressions::AggregateInitializer,
+             Model::Expressions::QueryExpression then :aggregate
+        when Model::Expressions::EntityConstructor,
+             Model::References::GroupReference then :entity
+        when Model::Expressions::BinaryExpression
+          binary_result_type(schema, node, depth)
+        when Model::Expressions::FunctionCall
+          function = schema_function(schema, node)
+          return :unknown unless function
+
+          static_type(schema, function.return_type, depth + 1)
+        when Model::DataTypes::Enumeration then :enum
+        when Model::DataTypes::Select then :select
+        when Model::DataTypes::Generic, Model::DataTypes::GenericEntity
+          :generic
+        when Model::References::SimpleReference
+          reference_type(schema, node, depth)
+        when Model::References::AttributeReference
+          attribute_reference_type(schema, node, depth)
+        when Model::References::IndexReference
+          index_element_type(schema, node, depth)
+        else :unknown
+        end
+      end
+
+      def binary_result_type(schema, node, depth)
+        case node.operator
+        when "EQUAL", "NOT_EQUAL", "LESS_THAN", "LESS_THAN_OR_EQUAL",
+             "GREATER_THAN", "GREATER_THAN_OR_EQUAL", "IN", "LIKE",
+             "INSTANCE_EQUAL", "INSTANCE_NOT_EQUAL", "AND", "OR", "XOR"
+          :logical
+        when "ADDITION"
+          left = static_type(schema, node.operand1, depth + 1)
+          NUMERIC_TYPES.include?(left) ? left : :unknown
+        when "REAL_DIVISION" then :real
+        when "INTEGER_DIVISION", "MODULO" then :integer
+        when "EXPONENTIATION"
+          both = [node.operand1, node.operand2].map do |operand|
+            static_type(schema, operand, depth + 1)
+          end
+          both.all?(:integer) ? :integer : :unknown
+        else :unknown
+        end
+      end
+
+      def builtin_symbol(name)
+        {
+          "integer" => :integer, "real" => :real, "number" => :number,
+          "string" => :string, "binary" => :binary, "boolean" => :boolean,
+          "logical" => :logical
+        }.fetch(name, :unknown)
+      end
+
+      def schema_function(schema, node)
+        callee = node.function
+        return nil unless callee.is_a?(Model::References::SimpleReference)
+
+        Array(schema.functions).find do |function|
+          function.id&.safe_downcase == callee.id&.safe_downcase
+        end
+      end
+
+      def reference_type(schema, node, depth)
+        key = node.id&.safe_downcase
+        return :unknown unless key
+
+        # builtin type names may arrive as unresolved references
+        # depending on parse layout
+        return builtin_symbol(key) if builtin?(node.id)
+
+        if (bound = @current_expression_env&.[](key))
+          return static_type(schema, bound, depth + 1)
+        end
+
+        declaration = find_type(schema, node.id.to_s)
+        return static_type(schema, declaration.underlying_type, depth + 1) if declaration
+
+        find_entity(schema, node.id) ? :entity : :unknown
+      end
+
+      # `color.red` parses as an AttributeReference over a reference to
+      # the enumeration TYPE (base infers :enum). An entity-typed base
+      # resolves through the entity's own attributes.
+      def attribute_reference_type(schema, node, depth)
+        base_node = node.ref
+        base = static_type(schema, base_node, depth + 1)
+        return :enum if base == :enum
+
+        entity = entity_for_reference(schema, base_node)
+        return :unknown unless entity
+
+        attr = Array(entity.attributes).find do |candidate|
+          candidate.id&.safe_downcase == node.attribute&.id&.safe_downcase
+        end
+        return :unknown unless attr
+
+        static_type(schema, attr.type, depth + 1)
+      end
+
+      def entity_for_reference(schema, node)
+        return nil unless node.is_a?(Model::References::SimpleReference)
+
+        find_entity(schema, node.id.to_s)
+      end
+
+      # ---- tier 3: aggregates through indexing ----
+
+      # 12.6.1 / 12.3.1 / 12.5.1: indexing yields the aggregate's base
+      # element; string indexing yields a string; binary indexing a
+      # binary.
+      def index_element_type(schema, node, depth)
+        element = index_element_type_node(schema, node.ref, depth + 1)
+        return :unknown if element.nil?
+
+        symbol = static_type(schema, element, depth + 1)
+        return symbol unless symbol == :unknown
+
+        case element
+        when Model::DataTypes::String then :string
+        when Model::DataTypes::Binary then :binary
+        else :unknown
+        end
+      end
+
+      def index_element_type_node(schema, node, depth)
+        return nil if node.nil? || depth > 8
+
+        type_node = declared_type_node(schema, node, depth)
+        case type_node
+        when Model::DataTypes::List, Model::DataTypes::Set,
+             Model::DataTypes::Bag, Model::DataTypes::Array
+          type_node.base_type
+        when Model::DataTypes::String, Model::DataTypes::Binary
+          type_node
+        when Model::DataTypes::Select
+          nil
+        end
+      end
+
+      # The declared type NODE an expression position names (as opposed
+      # to the static_type symbol): scope environment, schema types and
+      # entities, function returns.
+      def declared_type_node(schema, node, depth)
+        case node
+        when Model::References::SimpleReference
+          key = node.id&.safe_downcase
+          return nil unless key
+
+          @current_expression_env&.[](key) ||
+            find_type(schema, node.id.to_s)&.underlying_type ||
+            (find_entity(schema, node.id) && Model::DataTypes::GenericEntity.new)
+        when Model::References::IndexReference
+          index_element_type_node(schema, node.ref, depth + 1)
+        when Model::Expressions::FunctionCall
+          function = schema_function(schema, node)
+          function&.return_type
+        end
+      end
+
+      # 12.6.1/12.3.1/12.5.1: the indexed value shall be an aggregate,
+      # string or binary; 12.6.1/12.3.1/12.5.1 + 12.1: index positions
+      # shall be numeric.
+      def check_index_reference_types(schema, node)
+        base = static_type(schema, node.ref)
+        unless undecidable?(base) || base == :aggregate ||
+            base == :string || base == :binary || base == :select
+          note!(:check_expr_operand_domain, :error, schema,
+                "indexing requires an aggregate, string or binary " \
+                "operand (12.6.1, 12.3.1, 12.5.1) (#{base})", node)
+        end
+
+        [node.index1, node.index2].compact.each do |position|
+          position_type = static_type(schema, position)
+          next if undecidable?(position_type)
+          next if NUMERIC_TYPES.include?(position_type)
+
+          note!(:check_expr_operand_domain, :error, schema,
+                "index position shall be numeric (12.6.1) " \
+                "(#{position_type})", position)
+        end
+      end
+
+      # ---- tier 4: initializer compatibility (12.11) ----
+
+      # `x : T := expr` in CONSTANT, DERIVE and LOCAL: the initializer
+      # shall be compatible with the declared type (same type or a
+      # specialization, 12.11); numerics widen integer→real→number.
+      def check_initializer_types(schema)
+        initializers(schema).each do |owner, declaration|
+          @current_expression_env = if owner
+                                      expression_env(schema, owner)
+                                    else
+                                      expression_env(schema, schema)
+                                    end
+          declared = static_type(schema, declaration.type)
+          expression = declaration.expression
+          next if expression.nil? || undecidable?(declared)
+
+          expressed = static_type(schema, expression)
+          next if undecidable?(expressed)
+          next if initializer_compatible?(schema, declaration.type,
+                                          declared, expression, expressed)
+
+          note!(:check_expr_initializer_type, :error, schema,
+                "initializer #{expressed} is not compatible with the " \
+                "declared #{declared} (12.11)", declaration)
+        end
+        @current_expression_env = nil
+      end
+
+      def initializers(schema)
+        pairs = []
+        Array(schema.constants).each do |constant|
+          pairs << [nil, constant] if constant.expression
+        end
+        schema.entities.each do |entity|
+          Array(entity.attributes).each do |attr|
+            next unless attr.is_a?(Model::Declarations::Attribute) &&
+              !attr.is_a?(Model::Declarations::InverseAttribute) &&
+              attr.expression
+
+            pairs << [entity, attr]
+          end
+        end
+        schema.functions.each do |function|
+          Array(function.variables).each do |variable|
+            pairs << [function, variable] if variable.expression
+          end
+        end
+        pairs
+      end
+
+      def initializer_compatible?(schema, declared_node, declared, expression, expressed)
+        # enum and entity symbols are families, not identities — their
+        # compatibility is decided by declaration comparison below.
+        return true if declared == expressed &&
+          !%i[enum entity].include?(declared)
+        return true if declared == :number && NUMERIC_TYPES.include?(expressed)
+        return true if declared == :real && expressed == :integer
+        return true if LOGICAL_TYPES.include?(declared) &&
+          LOGICAL_TYPES.include?(expressed)
+        return true if declared == :select
+        return true if expressed == :select
+        return true if declared == :aggregate && expressed == :aggregate
+
+        # enumerations: same declared TYPE (expression enum members are
+        # AttributeReferences over the enumeration type)
+        return same_enum_declaration?(schema, declared_node, expression) if
+          declared == :enum && expressed == :enum
+
+        # entities: same entity or a specialization (12.11)
+        return entities_compatible?(schema, declared_node, expression) if
+          declared == :entity && expressed == :entity
+
+        false
+      end
+
+      # Resolve a type reference chain to its Type or Entity
+      # declaration: schema types and entities first, then the scope
+      # environment, then attribute/index member resolution.
+      def resolved_declaration(schema, node, depth = 0)
+        return nil if node.nil? || depth > 6
+
+        case node
+        when Model::Declarations::Type, Model::Declarations::Entity
+          node
+        when Model::References::SimpleReference
+          key = node.id&.safe_downcase
+          return nil unless key
+
+          bound = @current_expression_env&.[](key)
+          resolved_declaration(schema,
+                               bound || find_type(schema, node.id.to_s) ||
+                               find_entity(schema, node.id), depth + 1)
+        when Model::References::AttributeReference
+          owner = resolved_declaration(schema, node.ref, depth + 1)
+          # an enumeration member (`color.red`): the declaration is the
+          # enumeration TYPE itself
+          return owner if owner.is_a?(Model::Declarations::Type) &&
+            owner.underlying_type.is_a?(Model::DataTypes::Enumeration)
+
+          return nil unless owner.is_a?(Model::Declarations::Entity)
+
+          attr = Array(owner.attributes).find do |candidate|
+            candidate.id&.safe_downcase == node.attribute&.id&.safe_downcase
+          end
+          resolved_declaration(schema, attr&.type, depth + 1)
+        when Model::References::IndexReference
+          element = index_element_type_node(schema, node.ref, depth + 1)
+          resolved_declaration(schema, element, depth + 1)
+        when Model::References::GroupReference
+          resolved_declaration(schema, node.entity, depth + 1)
+        when Model::Expressions::FunctionCall
+          function = schema_function(schema, node)
+          resolved_declaration(schema, function&.return_type, depth + 1)
+        end
+      end
+
+      def same_enum_declaration?(schema, declared_node, expression)
+        slot_enum = resolved_declaration(schema, declared_node)
+        expr_enum = resolved_declaration(schema, expression)
+        return false unless slot_enum.is_a?(Model::Declarations::Type) &&
+          expr_enum.is_a?(Model::Declarations::Type)
+
+        slot_enum.underlying_type.is_a?(Model::DataTypes::Enumeration) &&
+          expr_enum.underlying_type.is_a?(Model::DataTypes::Enumeration) &&
+          slot_enum.id&.safe_downcase == expr_enum.id&.safe_downcase
+      end
+
+      def entities_compatible?(schema, declared_node, expression)
+        slot_entity = resolved_declaration(schema, declared_node)
+        expr_entity = resolved_declaration(schema, expression)
+        return false unless slot_entity.is_a?(Model::Declarations::Entity) &&
+          expr_entity.is_a?(Model::Declarations::Entity)
+
+        slot_entity.id&.safe_downcase == expr_entity.id&.safe_downcase ||
+          expr_entity.supertype_closure
+            .map { |e| e.id&.safe_downcase }
+            .include?(slot_entity.id&.safe_downcase)
       end
 
       # Self-qualified literals naming the CURRENT schema (#125): local
@@ -409,6 +1052,137 @@ module Expressir
           .select { |attr| attr.instance_of?(Model::Declarations::Attribute) }
       end
 
+      # ---- tier 5: statement flow (13.2.1, 13.5, 13.6, 13.7) ----
+
+      def statement_scopes(schema)
+        Array(schema.functions) + Array(schema.procedures) +
+          Array(schema.rules)
+      end
+
+      def check_statement_types(schema)
+        statement_scopes(schema).each do |owner|
+          @current_expression_env = expression_env(schema, owner)
+          each_node(owner) do |node|
+            case node
+            when Model::Statements::Assignment
+              check_assignment_type(schema, node)
+            when Model::Statements::If
+              check_logical_expression(schema, node.expression,
+                                       "if condition (13.5)", node)
+            when Model::Statements::Repeat
+              check_repeat_types(schema, node)
+            when Model::Statements::Return
+              check_return_type(schema, owner, node)
+            end
+          end
+        end
+        @current_expression_env = nil
+      end
+
+      def check_assignment_type(schema, node)
+        declared = static_type(schema, node.ref)
+        expressed = static_type(schema, node.expression)
+        return if undecidable?(declared, expressed)
+        return if initializer_compatible?(schema, node.ref, declared,
+                                          node.expression, expressed)
+
+        note!(:check_expr_assignment_type, :error, schema,
+              "assignment of #{expressed} to a #{declared} variable is " \
+              "not compatible (13.2.1, 12.11)", node)
+      end
+
+      def check_logical_expression(schema, expression, label, node)
+        t = static_type(schema, expression)
+        return if undecidable?(t)
+        return if LOGICAL_TYPES.include?(t)
+
+        note!(:check_expr_operand_domain, :error, schema,
+              "#{label} shall be a logical expression", node)
+      end
+
+      def check_repeat_types(schema, node)
+        [node.while_expression, node.until_expression].compact.each do |condition|
+          check_logical_expression(schema, condition,
+                                   "repeat control condition (13.6)", node)
+        end
+        [node.bound1, node.bound2, node.increment].compact.each do |bound|
+          t = static_type(schema, bound)
+          next if undecidable?(t)
+          next if NUMERIC_TYPES.include?(t)
+
+          note!(:check_expr_operand_domain, :error, schema,
+                "repeat increment control bounds shall be numeric " \
+                "(13.6.1) (#{t})", bound)
+        end
+      end
+
+      def check_return_type(schema, owner, node)
+        unless owner.is_a?(Model::Declarations::Function)
+          return unless node.expression
+
+          note!(:check_expr_return, :error, schema,
+                "a procedure return shall not specify an expression " \
+                "(13.7)", node)
+        end
+
+        expression = node.expression
+        return if expression.nil?
+        return if owner.is_a?(Model::Declarations::Function) &&
+          !owner.return_type
+
+        declared = static_type(schema, owner.return_type)
+        expressed = static_type(schema, expression)
+        return if undecidable?(declared, expressed)
+        return if initializer_compatible?(schema, owner.return_type,
+                                          declared, expression, expressed)
+
+        note!(:check_expr_return, :error, schema,
+              "return expression #{expressed} is not compatible with " \
+              "the declared return #{declared} (13.7, 12.11)", node)
+      end
+
+      # ---- tier 6: WHERE/UNIQUE structure (9.4) ----
+
+      def check_rule_structure(schema)
+        schema.entities.each do |entity|
+          check_where_booleans(schema, entity, Array(entity.where_rules))
+          check_unique_labels(schema, entity)
+        end
+        schema.types.each do |type|
+          check_where_booleans(schema, type, Array(type.where_rules))
+        end
+        schema.rules.each do |rule|
+          check_where_booleans(schema, rule, Array(rule.where_rules))
+        end
+      end
+
+      def check_where_booleans(schema, owner, where_rules)
+        @current_expression_env = expression_env(schema, owner)
+        where_rules.each do |rule|
+          t = static_type(schema, rule.expression)
+          next if undecidable?(t)
+          next if LOGICAL_TYPES.include?(t)
+
+          note!(:check_expr_where_boolean, :error, schema,
+                "WHERE '#{rule.id}' shall be a logical expression (9.4)", rule)
+        end
+        @current_expression_env = nil
+      end
+
+      def check_unique_labels(schema, entity)
+        seen = {}
+        Array(entity.unique_rules).each do |rule|
+          key = rule.id&.safe_downcase
+          next unless key
+
+          if seen[key]
+            note!(:check_expr_unique_duplicate, :error, schema,
+                  "duplicate UNIQUE label '#{rule.id}' (9.4)", rule)
+          end
+          seen[key] = true
+        end
+      end
+
       def check_subtype_constraints(schema)
         schema.subtype_constraints.each do |constraint|
           expr = constraint.supertype_expression
@@ -583,7 +1357,10 @@ module Expressir
 
           Array(current.subtype_of).each do |ref|
             id = ref_id(ref)
-            queue << find_entity(schema, id) if id
+            next unless id
+
+            target = find_entity(schema, id)
+            queue << target if target
           end
         end
         nil