rigortype 0.0.1

data/lib/rigor/rbs_extended.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative "type"
+
+module Rigor
+  # Slice 7 phase 15 — first-preview 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. The first preview ships only the **type
+  # predicate** directives:
+  #
+  # - `rigor:v1:predicate-if-true <target> is <ClassName>`
+  # - `rigor:v1:predicate-if-false <target> is <ClassName>`
+  #
+  # Other directives in the spec (`assert`, `assert-if-true`,
+  # `assert-if-false`, `param`, `return`, `conforms-to`, ...)
+  # are intentionally deferred. 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.
+  module RbsExtended
+    DIRECTIVE_PREFIX = "rigor:v1:"
+
+    # Returned for `predicate-if-true` / `predicate-if-false`.
+    # `target_kind` is `:parameter` (with `target_name` the
+    # Ruby parameter symbol) or `:self`.
+    PredicateEffect = Data.define(:edge, :target_kind, :target_name, :class_name) do
+      def truthy_only? = edge == :truthy_only
+      def falsey_only? = edge == :falsey_only
+    end
+
+    module_function
+
+    # Reads RBS::Extended predicate effects off
+    # `RBS::Definition::Method#annotations`. Returns the
+    # effects in source order; duplicates and unrecognised
+    # `rigor:v1:` directives are dropped. Returns an empty
+    # array (NEVER `nil`) for a method with no recognised
+    # annotations so callers can iterate unconditionally.
+    def read_predicate_effects(method_def)
+      return [] if method_def.nil?
+
+      annotations = method_def.annotations
+      return [] if annotations.nil? || annotations.empty?
+
+      effects = []
+      annotations.each do |annotation|
+        effect = parse_predicate_annotation(annotation.string)
+        effects << effect if effect
+      end
+      effects.uniq
+    end
+
+    PREDICATE_DIRECTIVE_PATTERN = /
+      \A
+      rigor:v1:(?<directive>predicate-if-(?:true|false))
+      \s+
+      (?<target>self|[a-z_][a-zA-Z0-9_]*)
+      \s+is\s+
+      (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
+      \s*
+      \z
+    /x
+    private_constant :PREDICATE_DIRECTIVE_PATTERN
+
+    def parse_predicate_annotation(string)
+      match = PREDICATE_DIRECTIVE_PATTERN.match(string)
+      return nil if match.nil?
+
+      directive = match[:directive].to_s
+      target = match[:target].to_s
+      class_name = match[:class_name].to_s.sub(/\A::/, "")
+      edge = directive == "predicate-if-true" ? :truthy_only : :falsey_only
+      target_kind = target == "self" ? :self : :parameter
+      target_name = target == "self" ? :self : target.to_sym
+      PredicateEffect.new(
+        edge: edge,
+        target_kind: target_kind,
+        target_name: target_name,
+        class_name: class_name
+      )
+    end
+  end
+end

data/lib/rigor/scope.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+require_relative "type"
+require_relative "environment"
+require_relative "analysis/fact_store"
+require_relative "inference/expression_typer"
+require_relative "inference/statement_evaluator"
+
+module Rigor
+  # Immutable analyzer scope: holds local-variable bindings and a reference
+  # to the surrounding Environment. State changes return new scopes through
+  # explicit transition methods (#with_local). The central query is
+  # #type_of(node), the Rigor counterpart of PHPStan's
+  # $scope->getType($node).
+  #
+  # See docs/internal-spec/inference-engine.md for the binding contract.
+  # rubocop:disable Metrics/ClassLength,Metrics/ParameterLists
+  class Scope
+    attr_reader :environment, :locals, :fact_store, :self_type, :declared_types,
+                :ivars, :cvars, :globals,
+                :class_ivars, :class_cvars, :program_globals,
+                :discovered_classes, :in_source_constants, :discovered_methods
+
+    EMPTY_DECLARED_TYPES = {}.compare_by_identity.freeze
+    EMPTY_VAR_BINDINGS = {}.freeze
+    EMPTY_CLASS_BINDINGS = {}.freeze
+    private_constant :EMPTY_DECLARED_TYPES, :EMPTY_VAR_BINDINGS, :EMPTY_CLASS_BINDINGS
+
+    class << self
+      def empty(environment: Environment.default)
+        new(environment: environment, locals: {}.freeze, fact_store: Analysis::FactStore.empty)
+      end
+    end
+
+    def initialize(
+      environment:, locals:,
+      fact_store: Analysis::FactStore.empty,
+      self_type: nil,
+      declared_types: EMPTY_DECLARED_TYPES,
+      ivars: EMPTY_VAR_BINDINGS,
+      cvars: EMPTY_VAR_BINDINGS,
+      globals: EMPTY_VAR_BINDINGS,
+      class_ivars: EMPTY_CLASS_BINDINGS,
+      class_cvars: EMPTY_CLASS_BINDINGS,
+      program_globals: EMPTY_VAR_BINDINGS,
+      discovered_classes: EMPTY_VAR_BINDINGS,
+      in_source_constants: EMPTY_VAR_BINDINGS,
+      discovered_methods: EMPTY_CLASS_BINDINGS
+    )
+      @environment = environment
+      @locals = locals
+      @fact_store = fact_store
+      @self_type = self_type
+      @declared_types = declared_types
+      @ivars = ivars
+      @cvars = cvars
+      @globals = globals
+      @class_ivars = class_ivars
+      @class_cvars = class_cvars
+      @program_globals = program_globals
+      @discovered_classes = discovered_classes
+      @in_source_constants = in_source_constants
+      @discovered_methods = discovered_methods
+      freeze
+    end
+
+    def local(name)
+      @locals[name.to_sym]
+    end
+
+    def with_local(name, type)
+      new_locals = @locals.merge(name.to_sym => type).freeze
+      new_fact_store = fact_store.invalidate_target(Analysis::FactStore::Target.local(name))
+      rebuild(locals: new_locals, fact_store: new_fact_store)
+    end
+
+    def with_fact(fact)
+      rebuild(fact_store: fact_store.with_fact(fact))
+    end
+
+    # Slice A-engine. Returns a scope with `self_type` set to `type`,
+    # preserving locals and facts. `StatementEvaluator` injects this
+    # at class-body and method-body boundaries; `ExpressionTyper`
+    # consults it when typing `Prism::SelfNode` and implicit-self
+    # `Prism::CallNode` receivers.
+    def with_self_type(type)
+      rebuild(self_type: type)
+    end
+
+    # Slice A-declarations. Returns a scope that carries an
+    # identity-comparing Hash of `Prism::Node => Rigor::Type`
+    # overrides. `ExpressionTyper#type_of(node)` MUST consult
+    # `declared_types[node]` before any other dispatch and
+    # return the recorded type as-is when present. The table is
+    # populated by `ScopeIndexer` for declaration-position
+    # nodes (the `constant_path` of `Prism::ModuleNode` and
+    # `Prism::ClassNode`) so a `module Foo` / `class Bar`
+    # header types as `Singleton[<qualified path>]` instead of
+    # falling through to `Dynamic[Top]`. The table is shared
+    # by structural reference across every derived scope so
+    # `with_local` / `with_fact` / `with_self_type` carry it
+    # transparently.
+    def with_declared_types(table)
+      rebuild(declared_types: table)
+    end
+
+    # Slice 7 phase 1 — instance/class/global variable bindings.
+    # `ivar(name)` / `cvar(name)` / `global(name)` return the
+    # type currently bound for the named variable, or `nil` when
+    # the variable has not been written in the analyzed slice of
+    # the program. The first cut tracks bindings only within a
+    # single method body (each `def` enters with a fresh binding
+    # map), so reads in other methods of the same class fall
+    # through to `Dynamic[Top]`. Cross-method ivar/cvar inference
+    # is a follow-up slice.
+    def ivar(name)
+      @ivars[name.to_sym]
+    end
+
+    def cvar(name)
+      @cvars[name.to_sym]
+    end
+
+    def global(name)
+      @globals[name.to_sym]
+    end
+
+    def with_ivar(name, type)
+      rebuild(ivars: @ivars.merge(name.to_sym => type).freeze)
+    end
+
+    def with_cvar(name, type)
+      rebuild(cvars: @cvars.merge(name.to_sym => type).freeze)
+    end
+
+    def with_global(name, type)
+      rebuild(globals: @globals.merge(name.to_sym => type).freeze)
+    end
+
+    # Slice 7 phase 2 — class-level ivar accumulator. Keyed by
+    # the qualified class name (e.g. `"Rigor::Scope"`); the
+    # value is a `Hash[Symbol, Type::t]` of every ivar that
+    # appears as a write target inside any def body of that
+    # class. `StatementEvaluator#build_method_entry_scope`
+    # seeds the method body's `ivars` map from this table so a
+    # `def get; @x; end` reads the type written in a sibling
+    # `def init; @x = 1; end`.
+    #
+    # `ScopeIndexer` populates the table once at index time
+    # through a separate pre-pass over the program. The map is
+    # frozen and shared by structural reference across every
+    # derived scope.
+    def class_ivars_for(class_name)
+      return EMPTY_VAR_BINDINGS if class_name.nil?
+
+      @class_ivars[class_name.to_s] || EMPTY_VAR_BINDINGS
+    end
+
+    def with_class_ivars(table)
+      rebuild(class_ivars: table)
+    end
+
+    # Slice 7 phase 6 — class-level cvar accumulator (same shape
+    # as `class_ivars` but populated from `Prism::ClassVariableWriteNode`
+    # writes, and seeded on BOTH instance and singleton method
+    # bodies because Ruby cvars are visible from each).
+    def class_cvars_for(class_name)
+      return EMPTY_VAR_BINDINGS if class_name.nil?
+
+      @class_cvars[class_name.to_s] || EMPTY_VAR_BINDINGS
+    end
+
+    def with_class_cvars(table)
+      rebuild(class_cvars: table)
+    end
+
+    # Slice 7 phase 6 — program-level globals accumulator.
+    # Globals are process-wide in Ruby, so the analyzer carries a
+    # single map (`Hash[Symbol, Type]`) keyed by the variable name
+    # and seeded into every method body (instance and singleton)
+    # plus the top-level program scope. `ScopeIndexer` populates
+    # it from a single program-wide pre-pass.
+    def with_program_globals(table)
+      rebuild(program_globals: table)
+    end
+
+    # Slice 7 phase 7 — in-source class discovery. Maps a
+    # qualified class name (e.g. `"Account"`) to its
+    # `Type::Singleton` so references to user-defined classes
+    # in the analyzed files resolve through
+    # `ExpressionTyper#resolve_constant_name` even when no RBS
+    # decl exists. Populated once at index time by
+    # `ScopeIndexer` from every `Prism::ClassNode` and
+    # `Prism::ModuleNode` it walks.
+    def with_discovered_classes(table)
+      rebuild(discovered_classes: table)
+    end
+
+    # Slice 7 phase 9 — in-source constant-value tracking.
+    # Maps a qualified constant name (e.g. `"BUCKETS"` or
+    # `"Rigor::Analysis::FactStore::BUCKETS"`) to the type of
+    # the rvalue assigned at its `Prism::ConstantWriteNode` /
+    # `Prism::ConstantPathWriteNode`. Populated by
+    # `ScopeIndexer` once at index time. `ExpressionTyper#resolve_constant_name`
+    # consults this map after class lookups so an in-source
+    # constant assignment overrides any RBS-declared constant
+    # of the same qualified name (matching Ruby's runtime
+    # precedence: a constant defined in user code is the
+    # authoritative value).
+    def with_in_source_constants(table)
+      rebuild(in_source_constants: table)
+    end
+
+    # Slice 7 phase 12 — in-source method discovery. Maps a
+    # qualified class name to a `Hash[Symbol, Symbol]` of
+    # `method_name => :instance | :singleton`. Populated by
+    # `ScopeIndexer` from every `Prism::DefNode` and recognised
+    # `define_method` invocation inside class/module bodies. The
+    # `rigor check` undefined-method and wrong-arity rules
+    # consult this map to suppress diagnostics for methods the
+    # user has defined dynamically, even when no RBS sig
+    # describes them.
+    def discovered_method?(class_name, method_name, kind)
+      table = @discovered_methods[class_name.to_s]
+      return false unless table
+
+      table[method_name.to_sym] == kind
+    end
+
+    def with_discovered_methods(table)
+      rebuild(discovered_methods: table)
+    end
+
+    def facts_for(target: nil, bucket: nil)
+      fact_store.facts_for(target: target, bucket: bucket)
+    end
+
+    def local_facts(name, bucket: nil)
+      facts_for(target: Analysis::FactStore::Target.local(name), bucket: bucket)
+    end
+
+    def type_of(node, tracer: nil)
+      Inference::ExpressionTyper.new(scope: self, tracer: tracer).type_of(node)
+    end
+
+    # Statement-level evaluation: returns the pair `[type, scope']`
+    # where `type` is what the node produces and `scope'` is the
+    # scope observable after the node has run. The receiver scope is
+    # never mutated. See {Rigor::Inference::StatementEvaluator} for
+    # the catalogue of nodes that thread scope; everything else
+    # defers to {#type_of} and returns the receiver scope unchanged.
+    def evaluate(node, tracer: nil)
+      Inference::StatementEvaluator.new(scope: self, tracer: tracer).evaluate(node)
+    end
+
+    # Joins this scope with another at a control-flow merge point. The
+    # joined scope is bound to every local that BOTH branches bind, with
+    # the type widened to the union of both sides. Names bound in only
+    # one branch are dropped from the joined scope; the eventual
+    # statement-level evaluator (Slice 3 phase 2) is responsible for
+    # nil-injecting half-bound names where the language semantics demand
+    # it. The two scopes MUST share the same Environment.
+    def join(other)
+      raise ArgumentError, "join requires a Rigor::Scope, got #{other.class}" unless other.is_a?(Scope)
+
+      unless environment.equal?(other.environment)
+        raise ArgumentError, "join requires both scopes to share the same Environment"
+      end
+
+      joined_locals = join_bindings(locals, other.locals)
+      joined_ivars = join_bindings(ivars, other.ivars)
+      joined_cvars = join_bindings(cvars, other.cvars)
+      joined_globals = join_bindings(globals, other.globals)
+      build_joined_scope(joined_locals, joined_ivars, joined_cvars, joined_globals, other)
+    end
+
+    def ==(other) # rubocop:disable Metrics/CyclomaticComplexity
+      other.is_a?(Scope) &&
+        environment.equal?(other.environment) &&
+        @locals == other.locals &&
+        fact_store == other.fact_store &&
+        self_type == other.self_type &&
+        @ivars == other.ivars &&
+        @cvars == other.cvars &&
+        @globals == other.globals
+    end
+    alias eql? ==
+
+    def hash
+      [Scope, environment.object_id, @locals, fact_store, self_type, @ivars, @cvars, @globals].hash
+    end
+
+    private
+
+    def rebuild(
+      locals: @locals, fact_store: @fact_store, self_type: @self_type,
+      declared_types: @declared_types, ivars: @ivars, cvars: @cvars, globals: @globals,
+      class_ivars: @class_ivars, class_cvars: @class_cvars, program_globals: @program_globals,
+      discovered_classes: @discovered_classes, in_source_constants: @in_source_constants,
+      discovered_methods: @discovered_methods
+    )
+      self.class.new(
+        environment: environment, locals: locals,
+        fact_store: fact_store, self_type: self_type,
+        declared_types: declared_types,
+        ivars: ivars, cvars: cvars, globals: globals,
+        class_ivars: class_ivars, class_cvars: class_cvars,
+        program_globals: program_globals,
+        discovered_classes: discovered_classes,
+        in_source_constants: in_source_constants,
+        discovered_methods: discovered_methods
+      )
+    end
+
+    def join_bindings(left, right)
+      shared = left.keys & right.keys
+      shared.to_h { |name| [name, Type::Combinator.union(left[name], right[name])] }.freeze
+    end
+
+    def build_joined_scope(joined_locals, joined_ivars, joined_cvars, joined_globals, other)
+      self.class.new(
+        environment: environment,
+        locals: joined_locals.freeze,
+        fact_store: fact_store.join(other.fact_store),
+        self_type: self_type == other.self_type ? self_type : nil,
+        declared_types: declared_types,
+        ivars: joined_ivars,
+        cvars: joined_cvars,
+        globals: joined_globals,
+        class_ivars: class_ivars,
+        class_cvars: class_cvars,
+        program_globals: program_globals,
+        discovered_classes: discovered_classes,
+        in_source_constants: in_source_constants,
+        discovered_methods: discovered_methods
+      )
+    end
+  end
+  # rubocop:enable Metrics/ClassLength,Metrics/ParameterLists
+end

data/lib/rigor/source/node_locator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Source
+    # Locates the deepest Prism AST node enclosing a given source position.
+    #
+    # The locator works on byte offsets internally so that multibyte source
+    # text behaves consistently with Prism, which itself reports offsets in
+    # bytes. Convenience constructors translate from `(line, column)` pairs.
+    #
+    # Lines are 1-indexed (matching editor / Prism / gcc conventions).
+    # Columns are 1-indexed when supplied via the `(line, column)` API; this
+    # matches the canonical `file.rb:line:col` form most tools emit. Internal
+    # offsets remain 0-indexed bytes.
+    #
+    # The locator is read-only: a single instance binds to one source buffer
+    # and AST root, and queries are pure functions of the byte offset.
+    class NodeLocator
+      class OutOfRangeError < StandardError; end
+
+      class << self
+        # @param source [String]
+        # @param root [Prism::Node]
+        # @param line [Integer] 1-indexed line number
+        # @param column [Integer] 1-indexed column number (byte index within the line)
+        # @return [Prism::Node, nil]
+        def at_position(source:, root:, line:, column:)
+          new(source: source, root: root).at_position(line: line, column: column)
+        end
+
+        # @param root [Prism::Node]
+        # @param offset [Integer] 0-indexed byte offset
+        # @return [Prism::Node, nil]
+        def at_offset(root:, offset:)
+          new(source: nil, root: root).at_offset(offset)
+        end
+      end
+
+      # @param source [String, nil] used by `#at_position`; may be omitted when only `#at_offset` is needed.
+      # @param root [Prism::Node]
+      def initialize(source:, root:)
+        @source = source
+        @root = root
+      end
+
+      # Resolve a `(line, column)` pair (1-indexed) to the deepest enclosing node.
+      #
+      # @raise [OutOfRangeError] if the line or column falls outside the source buffer.
+      def at_position(line:, column:)
+        offset = position_to_offset(line, column)
+        at_offset(offset)
+      end
+
+      # Resolve a byte offset (0-indexed) to the deepest enclosing node.
+      def at_offset(offset)
+        descend(@root, offset)
+      end
+
+      # Translate a `(line, column)` pair into a 0-indexed byte offset for the
+      # bound source buffer.
+      def position_to_offset(line, column)
+        raise ArgumentError, "source buffer required for position lookup" if @source.nil?
+        raise OutOfRangeError, "line must be >= 1, got #{line}" if line < 1
+        raise OutOfRangeError, "column must be >= 1, got #{column}" if column < 1
+
+        offset = 0
+        current_line = 1
+        @source.each_line do |chunk|
+          break if current_line == line
+
+          offset += chunk.bytesize
+          current_line += 1
+        end
+
+        raise OutOfRangeError, "line #{line} is past the end of the source buffer" if current_line != line
+
+        offset + (column - 1)
+      end
+
+      private
+
+      def descend(node, offset)
+        return nil unless node.is_a?(Prism::Node)
+        return nil unless contains?(node, offset)
+
+        node.compact_child_nodes.each do |child|
+          deeper = descend(child, offset)
+          return deeper if deeper
+        end
+
+        node
+      end
+
+      def contains?(node, offset)
+        location = node.location
+        return false if location.nil?
+
+        location.start_offset <= offset && offset < location.end_offset
+      end
+    end
+  end
+end

data/lib/rigor/source/node_walker.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Source
+    # Yields every `Prism::Node` reachable from a root in DFS pre-order.
+    #
+    # The walker is the source-positioning analogue to `NodeLocator`: where the
+    # locator answers "what node is at this point?", the walker enumerates the
+    # full set of Prism nodes for tooling that needs to operate on each one
+    # (coverage probes, lint passes, IDE outlines).
+    #
+    # Non-Prism children (literals embedded in node attributes, virtual nodes,
+    # or `nil` slots) are silently skipped so callers can rely on every yielded
+    # value responding to the `Prism::Node` API.
+    module NodeWalker
+      module_function
+
+      # @yieldparam node [Prism::Node]
+      # @return [Enumerator] when no block is given.
+      def each(root, &)
+        return to_enum(__method__, root) unless block_given?
+
+        walk(root, &)
+        nil
+      end
+
+      def walk(node, &)
+        return unless node.is_a?(Prism::Node)
+
+        yield node
+        node.compact_child_nodes.each { |child| walk(child, &) }
+      end
+    end
+  end
+end

data/lib/rigor/source.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Source-text and AST positioning utilities.
+#
+# Anything that maps between a Ruby source buffer and Prism AST nodes belongs
+# here. The contents of this namespace deliberately stay independent of the
+# inference engine so that future tooling (LSP, refactoring helpers, doc
+# extractors) can reuse the same primitives without dragging in `Rigor::Type`.
+module Rigor
+  module Source
+  end
+end
+
+require_relative "source/node_locator"
+require_relative "source/node_walker"

data/lib/rigor/testing.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Rigor
+  # Slice 7 phase 19 — PHPStan-style typing helpers.
+  #
+  # `Rigor::Testing` ships two runtime no-op helpers that serve
+  # as anchors for static-analysis diagnostics:
+  #
+  # - `dump_type(value)` — returns `value` unchanged at runtime.
+  #   The Rigor analyzer surfaces an `:info`-severity diagnostic
+  #   at the call site showing the inferred type of `value` so
+  #   the user can see what the engine sees at that program point.
+  # - `assert_type(expected, value)` — returns `value` unchanged
+  #   at runtime. The analyzer compares `value`'s inferred type
+  #   (rendered through `Rigor::Type#describe(:short)`) against
+  #   the literal `expected` String; a mismatch produces an
+  #   `:error`-severity diagnostic. This lets a user-written
+  #   fixture be self-asserting: `rigor check fixture.rb` exits
+  #   non-zero exactly when the engine's inference drifts from
+  #   what the fixture documents.
+  #
+  # Three usage shapes are recognised by the static rules:
+  #
+  #   require "rigor/testing"
+  #   include Rigor::Testing
+  #   dump_type(x)
+  #   assert_type("Constant[1]", x)
+  #
+  # ... or fully qualified:
+  #
+  #   Rigor::Testing.dump_type(x)
+  #   Rigor::Testing.assert_type("String | nil", x)
+  #
+  # ... or via the convenience top-level alias `Rigor` itself:
+  #
+  #   Rigor.dump_type(x)
+  #   Rigor.assert_type("Constant[\"hello\"]", x)
+  #
+  # All three resolve to the same no-op runtime body, so a
+  # fixture may freely run under MRI without depending on the
+  # analyzer being present.
+  module Testing
+    module_function
+
+    def dump_type(value)
+      value
+    end
+
+    def assert_type(_expected, value)
+      value
+    end
+  end
+
+  class << self
+    # Convenience aliases on `Rigor` itself, so fixtures can
+    # write `Rigor.dump_type(x)` without an `include` line.
+    def dump_type(value)
+      Testing.dump_type(value)
+    end
+
+    def assert_type(expected, value)
+      Testing.assert_type(expected, value)
+    end
+  end
+end