rigortype 0.1.19 → 0.2.0

data/lib/rigor/rbs_extended.rb

@@ -7,43 +7,30 @@ require_relative "rbs_extended/reporter"
 require_relative "rbs_extended/hkt_directives"
 
 module Rigor
-  # Slice 7 phase 15 — first-preview reader for the
-  # `RBS::Extended` annotation surface described in
+  # Reader for the `RBS::Extended` annotation surface described in
   # `docs/type-specification/rbs-extended.md`.
   #
-  # This module reads `%a{rigor:v1:<directive> <payload>}`
-  # annotations off RBS method definitions and returns
-  # well-typed effect objects the inference engine can
-  # consume. v0.0.2 recognises:
+  # Reads `%a{rigor:v1:<directive> <payload>}` annotations off RBS
+  # method definitions and returns well-typed effect objects the
+  # inference engine can consume. Implemented directives:
   #
-  # - `rigor:v1:predicate-if-true <target> is <ClassName>`
-  # - `rigor:v1:predicate-if-false <target> is <ClassName>`
-  # - `rigor:v1:assert <target> is <ClassName>`
-  # - `rigor:v1:assert-if-true <target> is <ClassName>`
-  # - `rigor:v1:assert-if-false <target> is <ClassName>`
+  # - `rigor:v1:predicate-if-true <target> is <ClassName|refinement>`
+  # - `rigor:v1:predicate-if-false <target> is <ClassName|refinement>`
+  # - `rigor:v1:assert <target> is <ClassName|refinement>`
+  # - `rigor:v1:assert-if-true <target> is <ClassName|refinement>`
+  # - `rigor:v1:assert-if-false <target> is <ClassName|refinement>`
+  # - `rigor:v1:param <name> <type-expr>` — per-call param narrowing
+  # - `rigor:v1:return <type-expr>` — per-call return override
+  # - `rigor:v1:conforms-to <InterfaceName>` — structural conformance
   #
-  # `predicate-if-*` fires when the call is used as an
-  # `if` / `unless` condition; `assert` fires unconditionally
-  # at the call's post-scope; `assert-if-true` /
-  # `assert-if-false` fire at the post-scope only when the
-  # call's return value can be observed as truthy / falsey
-  # (currently: when the call is the predicate of a
-  # subsequent `if` / `unless`). Other directives in the spec
-  # (`param`, `return`, `conforms-to`, negation `~T`,
-  # `target: self` narrowing, ...) remain on the v0.0.x
-  # roadmap. Annotations whose key is in the `rigor:v1:`
-  # namespace but whose directive is unrecognised are
-  # silently ignored at first-preview quality (a future slice
-  # MAY surface them as diagnostics-on-Rigor-itself per the
-  # spec's "unsupported metadata" guidance).
-  #
-  # The parser is minimal: it accepts a strict shape
-  # `<target> is <ClassName>` where `<target>` is a Ruby
-  # identifier (parameter name) or `self`, and `<ClassName>`
-  # is a single non-namespaced class identifier or a
-  # `::Foo::Bar` style constant path. Negative refinements
-  # (`~T`), intersections, and unions are deferred to the
-  # next iteration.
+  # `predicate-if-*` fires when the call is used as an `if` / `unless`
+  # condition; `assert` fires unconditionally at the call's post-scope;
+  # `assert-if-true` / `assert-if-false` fire at the post-scope only
+  # when the call's return value can be observed as truthy / falsey.
+  # Negation (`~T`) is supported for both class-name and refinement
+  # right-hand sides. Parameterised refinements (`non-empty-array[T]`)
+  # are also recognised. Annotations whose directive is unrecognised
+  # are silently ignored per the spec's "unsupported metadata" guidance.
   module RbsExtended # rubocop:disable Metrics/ModuleLength
     DIRECTIVE_PREFIX = "rigor:v1:"
 
@@ -58,9 +45,10 @@ module Rigor
     # a kebab-case refinement name (`non-empty-string`,
     # `lowercase-string`, …) instead of a Capitalised class
     # name. The narrowing tier substitutes the carrier for the
-    # current local type; `class_name` is then nil and
-    # `negative` is false (refinement-form directives do not
-    # support `~T` negation in v0.0.4).
+    # current local type; `class_name` is then nil. `negative`
+    # may be true for refinement-form directives — `~T` negation
+    # is supported; the narrowing tier computes the complement
+    # decomposition (see `AssertEffect` docs below).
     class PredicateEffect < Data.define(:edge, :target_kind, :target_name, :class_name, :negative, :refinement_type)
       def truthy_only? = edge == :truthy_only
       def falsey_only? = edge == :falsey_only

data/lib/rigor/reflection.rb

@@ -17,11 +17,8 @@ module Rigor
   #    classes / modules, in-source constants, discovered method
   #    nodes, class ivar / cvar declarations).
   #
-  # This module is the **stable read shape** that v0.1.0's plugin
-  # API will be designed against. ADR-2 (`docs/adr/2-extension-api.md`)
-  # calls out a unified reflection layer as a prerequisite for the
-  # extension protocols, and `docs/design/20260505-v0.1.0-readiness.md`
-  # nominates this module as the highest-leverage cold-start slice.
+  # This module is the **stable read shape** the plugin API is
+  # designed against (ADR-2, `docs/adr/2-extension-api.md`).
   #
   # The facade is **read-only and additive**. Existing call sites
   # that read directly from `Rigor::Scope` or
@@ -52,8 +49,8 @@ module Rigor
   #   defined in the analyzed sources?
   #
   # The provenance side of the API (which source family contributed
-  # each fact) is explicitly out of scope for the v0.0.7 first
-  # pass. v0.1.0's plugin API adds it as a separate concern.
+  # each fact) is explicitly out of scope for the v0.0.7 first pass;
+  # v0.1.0's plugin API added it as a separate concern.
   module Reflection
     module_function
 

data/lib/rigor/scope/discovery_index.rb

@@ -28,7 +28,9 @@ module Rigor
       :discovered_superclasses,
       :discovered_includes,
       :discovered_class_sources,
-      :data_member_layouts
+      :data_member_layouts,
+      :struct_member_layouts,
+      :param_inferred_types
     )
 
     class DiscoveryIndex
@@ -53,7 +55,17 @@ module Rigor
         discovered_superclasses: EMPTY_TABLE,
         discovered_includes: EMPTY_TABLE,
         discovered_class_sources: EMPTY_TABLE,
-        data_member_layouts: EMPTY_TABLE
+        data_member_layouts: EMPTY_TABLE,
+        struct_member_layouts: EMPTY_TABLE,
+        # ADR-67 WD3 — the call-site parameter-inference table, keyed by
+        # `[class_name, method_name, kind]` (the same `(class, method, kind)`
+        # triple {Inference::ParameterInferenceCollector} records and that
+        # `build_method_entry_scope` reconstructs from the lexical class path).
+        # The value is a `{param_name(Symbol) => Rigor::Type}` map of the union
+        # of resolved call-site argument types. Empty on every normal run; only
+        # the `coverage --protection` collection pass populates it today, so a
+        # `check` run leaves it empty and seeds nothing (byte-identical).
+        param_inferred_types: EMPTY_TABLE
       )
     end
   end

data/lib/rigor/scope.rb

@@ -23,7 +23,7 @@ module Rigor
                 :ivars, :cvars, :globals,
                 :indexed_narrowings, :method_chain_narrowings,
                 :declaration_sourced,
-                :source_path, :discovery
+                :source_path, :discovery, :struct_fold_safe_locals
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # {DiscoveryIndex} the scope carries by a single reference; the
@@ -51,6 +51,13 @@ module Rigor
     def discovered_includes = @discovery.discovered_includes
     def discovered_class_sources = @discovery.discovered_class_sources
     def data_member_layouts = @discovery.data_member_layouts
+    def struct_member_layouts = @discovery.struct_member_layouts
+    # ADR-67 WD3 — call-site-inferred parameter types, keyed by
+    # `[class_name, method_name, kind]`. `build_method_entry_scope` consults
+    # this to seed an undeclared `def` parameter with the union of its
+    # resolved call-site argument types (precision-additive; an RBS-declared
+    # parameter always wins). Empty unless a collection pass seeded it.
+    def param_inferred_types = @discovery.param_inferred_types
 
     # Narrowing key for an indexed read `receiver[key]` where both
     # the receiver and the key are stable enough to address. The
@@ -99,8 +106,14 @@ module Rigor
     # principle. Any flow-live touch (write / narrowing) drops the mark, so
     # the diagnostic keeps firing exactly as before on flow-observed nil.
     EMPTY_DECLARATION_SOURCED = Set.new.freeze
+    # ADR-48 Struct slice 3 — the per-body set of local names whose struct
+    # member reads are fold-safe (provably never mutated / aliased / escaped).
+    # A static per-scope context like {#source_path}: inherited unchanged
+    # through flow transitions and ignored by `==` / `hash`.
+    EMPTY_FOLD_SAFE = Set.new.freeze
     private_constant :EMPTY_VAR_BINDINGS, :EMPTY_INDEXED_NARROWINGS,
-                     :EMPTY_CHAIN_NARROWINGS, :EMPTY_DECLARATION_SOURCED
+                     :EMPTY_CHAIN_NARROWINGS, :EMPTY_DECLARATION_SOURCED,
+                     :EMPTY_FOLD_SAFE
 
     class << self
       def empty(environment: Environment.default, source_path: nil)
@@ -120,7 +133,8 @@ module Rigor
       indexed_narrowings: EMPTY_INDEXED_NARROWINGS,
       method_chain_narrowings: EMPTY_CHAIN_NARROWINGS,
       declaration_sourced: EMPTY_DECLARATION_SOURCED,
-      source_path: nil
+      source_path: nil,
+      struct_fold_safe_locals: EMPTY_FOLD_SAFE
     )
       @environment = environment
       @locals = locals
@@ -134,6 +148,7 @@ module Rigor
       @method_chain_narrowings = method_chain_narrowings
       @declaration_sourced = declaration_sourced
       @source_path = source_path
+      @struct_fold_safe_locals = struct_fold_safe_locals
       freeze
     end
 
@@ -180,17 +195,29 @@ module Rigor
       rebuild(self_type: type)
     end
 
-    # ADR-11 per-call-site assertion gating prerequisite. The
-    # analyzer's per-file boundary stamps the current source
-    # file's path onto the seed scope; nested rebuilds carry
-    # the value through so plugin rules (`dynamic_return`'s
-    # `file_methods:` gate, sigil checks) can resolve "which
-    # file does this call site belong to?" without
+    # ADR-28 / ADR-52 slice 5a — per-file source path carried on
+    # the scope. The analyzer stamps the current file's path onto
+    # the seed scope; nested rebuilds propagate it so plugin rules
+    # (`dynamic_return`'s `file_methods:` gate, sigil checks) can
+    # resolve "which file does this call site belong to?" without
     # thread-locals.
     def with_source_path(path)
       rebuild(source_path: path)
     end
 
+    # ADR-48 Struct slice 3 — installs the per-body fold-safe-local set
+    # ({Inference::StructFoldSafety}). Set once at body entry; inherited
+    # unchanged through subsequent flow transitions.
+    def with_struct_fold_safe(locals)
+      rebuild(struct_fold_safe_locals: locals)
+    end
+
+    # True when `name`'s `Struct` member reads are fold-safe in this body
+    # (the local is provably never mutated / aliased / escaped).
+    def struct_fold_safe?(name)
+      @struct_fold_safe_locals.include?(name.to_sym)
+    end
+
     # ADR-53 Track A — swaps the whole discovery index in one transition.
     # The sole seeding path; the per-table writers it replaced are derived
     # off-`Scope` through `scope.discovery.with(table_name: table)`.
@@ -484,6 +511,20 @@ module Rigor
       layout
     end
 
+    # ADR-48 Struct follow-up — the `{ members:, keyword_init: }` layout
+    # recorded for a `Struct.new(...)`-defined class, in the constant form
+    # (`Point = Struct.new(:x, :y)`) and the named-subclass form
+    # (`class Point < Struct.new(:x, :y)`). Consumed by
+    # {Inference::MethodDispatcher::StructFolding} so `Point.new(...)` on a
+    # `Singleton[Point]` receiver materialises a member instance. Returns nil
+    # when the class has no recorded struct layout. Mirrors
+    # {#data_member_layout}'s dependency-recording contract.
+    def struct_member_layout(class_name)
+      layout = @discovery.struct_member_layouts[class_name.to_s]
+      record_class_dependency(class_name) if layout && Analysis::DependencyRecorder.active?
+      layout
+    end
+
     # ADR-24 slice 2 — per-class/module table mapping a fully
     # qualified user class or module to the list of module
     # names it `include`s / `prepend`s, AS WRITTEN at the
@@ -674,7 +715,8 @@ module Rigor
       indexed_narrowings: @indexed_narrowings,
       method_chain_narrowings: @method_chain_narrowings,
       declaration_sourced: @declaration_sourced,
-      source_path: @source_path
+      source_path: @source_path,
+      struct_fold_safe_locals: @struct_fold_safe_locals
     )
       self.class.new(
         environment: environment, locals: locals,
@@ -684,7 +726,8 @@ module Rigor
         indexed_narrowings: indexed_narrowings,
         method_chain_narrowings: method_chain_narrowings,
         declaration_sourced: declaration_sourced,
-        source_path: source_path
+        source_path: source_path,
+        struct_fold_safe_locals: struct_fold_safe_locals
       )
     end
 

data/lib/rigor/sig_gen/observed_call.rb

@@ -5,9 +5,9 @@ module Rigor
     # Per-call-site argument observation produced by
     # {ObservationCollector}. ADR-14 follow-up: the earlier
     # MVP shape (`Array[Type]` of positional types only)
-    # could not represent keyword arguments — every call like
-    # `MethodCatalog.new(path: ..., mutating_selectors: ...)`
-    # discarded the whole observation via `non_positional?`.
+    # could not represent keyword arguments — keyword calls
+    # like `MethodCatalog.new(path: ..., mutating_selectors: ...)`
+    # were silently skipped in that shape.
     # The new shape carries positional and keyword arg types
     # in parallel so the per-position / per-keyword unions
     # can each be reconstructed independently.

data/lib/rigor/sig_gen/writer.rb

@@ -46,6 +46,11 @@ module Rigor
       def initialize(path_mapper:, overwrite: false)
         @path_mapper = path_mapper
         @overwrite = overwrite
+        # Run-level (cross-file) namespace-kind view, populated
+        # per `#write_all` from every candidate's per-file map.
+        # Empty until then so the single-target `#write` path
+        # falls back to per-candidate kinds only.
+        @global_namespace_kinds = {}
       end
 
       # Process the full candidate list by resolving each
@@ -65,6 +70,7 @@ module Rigor
         emittable = candidates.select { |c| EMITTABLE.include?(c.classification) }
         return [] if emittable.empty?
 
+        @global_namespace_kinds = build_namespace_kinds(candidates)
         emittable.group_by { |c| @path_mapper.target_for(c.path, class_name: c.class_name) }
                  .map { |target, group| write_target(target, group) }
       end
@@ -161,13 +167,45 @@ module Rigor
       end
 
       def merged_namespace_kinds(candidates)
-        merged = {}
+        merged = @global_namespace_kinds.dup
         candidates.each do |c|
-          (c.namespace_kinds || {}).each { |k, v| merged[k] = v }
+          (c.namespace_kinds || {}).each { |k, v| apply_namespace_kind(merged, k, v) }
         end
         merged
       end
 
+      # Folds every candidate's per-file namespace-kind map
+      # into one run-level view so a `class Foo` recorded
+      # while scanning `foo.rb` governs the wrapper keyword
+      # emitted for `Foo` in a *sibling* file's target — e.g.
+      # `foo/bar.rb` declaring `class Foo::Bar`, whose compact
+      # constant path never names `Foo`, so the walker records
+      # no kind for it. Without this view that sibling target
+      # wraps the nested class in `module Foo` while `foo.rbs`
+      # declares `class Foo`; loading both raises
+      # `RBS::DuplicatedDeclarationError`, aborting the whole
+      # RBS env build.
+      def build_namespace_kinds(candidates)
+        candidates.each_with_object({}) do |candidate, acc|
+          (candidate.namespace_kinds || {}).each { |name, kind| apply_namespace_kind(acc, name, kind) }
+        end
+      end
+
+      # A `class` declaration is authoritative and MUST win
+      # over the `:module` wrapper default: a compact
+      # `class Foo::Bar` never names `Foo`, so the only signal
+      # for `Foo`'s kind is an actual `class Foo` (or
+      # `Const = Data.define(...)` shell) seen elsewhere. This
+      # guarantees the generated tree never mixes `class` /
+      # `module` for the same constant.
+      def apply_namespace_kind(map, key, kind)
+        if kind == :class
+          map[key] = :class
+        else
+          map[key] ||= :module
+        end
+      end
+
       # Tree node: { name:, children: Hash{String => node},
       # methods: Array<MethodCandidate>, shell: Boolean }.
       # `shell` flags nodes that came in via `class_shells`

data/lib/rigor/source/constant_path.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Source
+    # Flattens a Prism constant-reference node (`ConstantReadNode` /
+    # `ConstantPathNode`) to its source-qualified `"A::B::C"` string.
+    #
+    # Two nil policies for the one edge case that distinguishes the call
+    # sites — a constant path rooted in a *dynamic* base (`expr::Bar`, where
+    # the left side is a runtime expression rather than a constant):
+    #
+    # * {.qualified_name} / {.render} are LENIENT — they drop the dynamic
+    #   segment and render the trailing constant names (`expr::Bar` => "Bar").
+    #   The scope indexer and statement evaluator feed only genuine
+    #   class/module path nodes and want a best-effort name.
+    # * {.qualified_name_or_nil} is STRICT — a dynamic base anywhere in the
+    #   chain yields `nil`, so a caller that statically names constants can
+    #   treat the path as opaque rather than guessing.
+    #
+    # A leading `::` (absolute root, `::Foo`) renders as `"Foo"` under both
+    # policies. A node that is neither a `ConstantReadNode` nor a
+    # `ConstantPathNode` yields `nil` under both.
+    module ConstantPath
+      module_function
+
+      # Lenient dispatch over a constant-reference node.
+      def qualified_name(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode then render(node)
+        end
+      end
+
+      # Lenient render of a `ConstantPathNode`; never nil for a path node.
+      def render(node)
+        prefix =
+          case node.parent
+          when Prism::ConstantReadNode then "#{node.parent.name}::"
+          when Prism::ConstantPathNode then "#{render(node.parent)}::"
+          else ""
+          end
+        "#{prefix}#{node.name}"
+      end
+
+      # Strict dispatch: a dynamic base anywhere in the path yields nil.
+      def qualified_name_or_nil(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent
+          return node.name.to_s if parent.nil?
+
+          parent_name = qualified_name_or_nil(parent)
+          return nil if parent_name.nil?
+
+          "#{parent_name}::#{node.name}"
+        end
+      end
+    end
+  end
+end

data/lib/rigor/source.rb

@@ -14,3 +14,4 @@ end
 require_relative "source/node_locator"
 require_relative "source/node_walker"
 require_relative "source/literals"
+require_relative "source/constant_path"

data/lib/rigor/type/bound_method.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -46,17 +47,7 @@ module Rigor
         "Method"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/combinator.rb

@@ -405,6 +405,21 @@ module Rigor
         DataInstance.new(members, class_name)
       end
 
+      # ADR-48 Struct follow-up — the class object produced by
+      # `Struct.new(:x, :y)`. `members` is the ordered Symbol member-name
+      # list; `keyword_init` records the `keyword_init:` flag; `class_name`
+      # tags the class when known (the named-subclass form).
+      def struct_class_of(members:, class_name: nil, keyword_init: false)
+        StructClass.new(members, class_name, keyword_init: keyword_init)
+      end
+
+      # ADR-48 Struct follow-up — a `Struct.new` value instance. `members`
+      # is the ordered member-name -> value-type map; `class_name` tags the
+      # instance's class when known.
+      def struct_instance_of(members:, class_name: nil)
+        StructInstance.new(members, class_name)
+      end
+
       # Normalized union. Flattens nested Unions, deduplicates structurally
       # equal members, drops Bot, and collapses 0/1-member results.
       def union(*types)
@@ -929,9 +944,7 @@ module Rigor
         end
       end
 
-      # ADR-15 Phase 4b.x — eager-allocate the singleton
-      # `Dynamic[Top]` carrier on the main Ractor at load time.
-      # The `untyped` reader above just returns this ivar.
+      # Eager-allocated at load time; see `untyped` method comment above.
       @untyped = Dynamic.new(Top.instance)
     end
   end

data/lib/rigor/type/constant.rb

@@ -3,6 +3,7 @@
 require "date"
 require_relative "../trinary"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -100,17 +101,7 @@ module Rigor
         end
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/data_class.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -54,17 +55,7 @@ module Rigor
         "singleton(#{class_name || 'Data'})"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/data_instance.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -74,17 +75,7 @@ module Rigor
         name
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/hash_shape.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -96,17 +97,7 @@ module Rigor
         read_only_keys.include?(key)
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/integer_range.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -103,17 +104,7 @@ module Rigor
         "Integer"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/intersection.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -62,17 +63,7 @@ module Rigor
         members.first.erase_to_rbs
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter
 

data/lib/rigor/type/nominal.rb

@@ -3,6 +3,7 @@
 require_relative "../trinary"
 require_relative "../value_semantics"
 require_relative "acceptance_router"
+require_relative "plain_lattice"
 
 module Rigor
   module Type
@@ -52,17 +53,7 @@ module Rigor
         "#{class_name}[#{rendered}]"
       end
 
-      def top
-        Trinary.no
-      end
-
-      def bot
-        Trinary.no
-      end
-
-      def dynamic
-        Trinary.no
-      end
+      include Rigor::Type::PlainLattice
 
       include Rigor::Type::AcceptanceRouter