steep 1.7.0.dev.3 → 1.7.0

data/sig/steep/subtyping/check.rbs

@@ -1,131 +0,0 @@
-module Steep
-  module Subtyping
-    class Check
-      ABORT_LIMIT: Integer
-
-      attr_reader builder: Interface::Builder
-
-      attr_reader cache: Cache
-
-      @assumptions: Set[Relation[untyped]]?
-
-      @bounds: Array[Hash[Symbol, AST::Types::t?]]
-
-      @self_type: AST::Types::t?
-
-      @instance_type: AST::Types::t?
-
-      @class_type: AST::Types::t?
-
-      @constraints: Constraints?
-
-      def initialize: (builder: Interface::Builder) -> void
-
-      def factory: () -> AST::Types::Factory
-
-      def with_context: [A] (self_type: AST::Types::t?, instance_type: AST::Types::t?, class_type: AST::Types::t?, constraints: Constraints?) { () -> A } -> A
-
-      def self_type: () -> AST::Types::t
-
-      def instance_type: () -> AST::Types::t
-
-      def class_type: () -> AST::Types::t
-
-      def constraints: () -> Constraints
-
-      def push_variable_bounds: [A] (Array[Interface::TypeParam] | Hash[Symbol, AST::Types::t?] params) { () -> A } -> A
-
-      def variable_upper_bound: (Symbol name) -> AST::Types::t?
-
-      def variable_upper_bounds: () -> Hash[Symbol, AST::Types::t?]
-
-      def push_assumption: [A] (Relation[untyped] relation) { () -> A } -> A
-
-      def assumptions: () -> Set[Relation[untyped]]
-
-      def each_ancestor: (RBS::DefinitionBuilder::AncestorBuilder::OneAncestors ancestors) { (RBS::Definition::Ancestor::t) -> void } -> void
-                       | (RBS::DefinitionBuilder::AncestorBuilder::OneAncestors ancestors) -> Enumerator[RBS::Definition::Ancestor::t, void]
-
-      type super_type = AST::Types::Name::Instance | AST::Types::Name::Interface | AST::Types::Name::Singleton
-
-      def instance_super_types: (RBS::TypeName type_name, args: Array[AST::Types::t]) -> Array[super_type]
-
-      def singleton_super_types: (RBS::TypeName type_name) -> Array[super_type]
-
-      def check: (Relation[AST::Types::t] relation, constraints: Constraints, self_type: AST::Types::t?, instance_type: AST::Types::t?, class_type: AST::Types::t?) -> Result::t
-
-      def check_type: (Relation[AST::Types::t] relation) -> Result::t
-
-      def cache_bounds: (Relation[AST::Types::t] relation) -> Hash[Symbol, AST::Types::t?]
-
-      def alias?: (AST::Types::t `type`) -> bool
-
-      def cacheable?: (Relation[AST::Types::t] relation) -> bool
-
-      def true_type?: (AST::Types::t `type`) -> bool
-
-      def false_type?: (AST::Types::t `type`) -> bool
-
-      include Result::Helper
-
-      def check_type0: (Relation[AST::Types::t] relation) -> Result::t
-
-      def definition_for_type: (AST::Types::t `type`) -> RBS::Definition
-
-      # Returns true if given `type` is with one or more type arguments.
-      #
-      def arg_type?: (AST::Types::t `type`) -> bool
-
-      type application_type = AST::Types::Name::Instance | AST::Types::Name::Interface | AST::Types::Name::Alias
-
-      def check_type_arg: (Relation[application_type] relation) -> untyped
-
-      def same_type?: (Relation[AST::Types::t] relation) -> bool
-
-      def check_interface: (Relation[Interface::Shape] relation) -> Result::t
-
-      def check_method: (Symbol name, Relation[Interface::Shape::Entry] relation) -> Result::t
-
-      def check_generic_method_type: (Symbol name, Relation[Interface::MethodType] relation) -> Result::t
-
-      def check_constraints: (Relation[untyped] relation, variables: Enumerable[Symbol], variance: VariableVariance) -> Result::t
-
-      def check_method_type: (Symbol name, Relation[Interface::MethodType] relation) -> Result::t
-
-      # Receives subtyping relation of blocks `b <: b'` where `b` and `b'` are expanded from
-      # subtyping relation of two method types `(...) _b_ -> T <: (...) _b'_ -> S`.
-      #
-      # Returns `true` is the relation is satisfied immediately.
-      # Returns a Relation when the given relation can be expanded to relation between Interface::Block.
-      # Returns a failure otherwise.
-      #
-      def expand_block_given: (Symbol name, Relation[Interface::Block?] relation) -> (Relation[Interface::Block] | true | Result::Failure)
-
-      # Receives a subtyping relation between self bindings `S <: S'` that is included in procs or blocks as:
-      #
-      # *             `^() [self: S] -> T <: ^() [self: S'] -> T`           (proc)
-      # * `() { () [self: S'] -> T } -> T <: () { () [self: S] -> T } -> T` (block in method type)
-      #
-      def check_self_type_binding: (Relation[untyped], AST::Types::t? sub_self, AST::Types::t? super_self) -> Result::t?
-
-      def check_function: (Symbol name, Relation[Interface::Function] relation) -> Result::t
-
-      def check_method_params: (Symbol name, Relation[Interface::Function::Params] relation) -> Result::t
-
-      # Returns `nil` when given two method_types are structually comparable.
-      # Returns a failure otherwise.
-      #
-      def match_method_type_fails?: (Symbol name, Interface::MethodType method_type1, Interface::MethodType method_type2) -> (nil | Result::t)
-
-      def match_params: (Symbol name, Relation[Interface::Function::Params] relation) -> (Array[[AST::Types::t, AST::Types::t]] | Result::t)
-
-      def expand_alias: (AST::Types::t `type`) -> AST::Types::t
-
-      # Returns the shortest type paths for one of the _unknown_ type variables.
-      # Returns nil if there is no path.
-      def hole_path: (AST::Types::t `type`, ?Array[AST::Types::t] path) -> Array[AST::Types::t]?
-
-      def Relation: [T < Relation::_Subject] (T sub, T sup) -> Relation[T]
-    end
-  end
-end

data/sig/steep/subtyping/constraints.rbs

@@ -1,111 +0,0 @@
-module Steep
-  module Subtyping
-    class Constraints
-      class UnsatisfiedInvariantError < StandardError
-        attr_reader constraints: untyped
-
-        attr_reader reason: untyped
-
-        def initialize: (reason: untyped, constraints: untyped) -> void
-
-        class VariablesUnknownsNotDisjoint
-          attr_reader vars: untyped
-
-          def initialize: (vars: untyped) -> void
-
-          def message: () -> ::String
-        end
-
-        class VariablesFreeVariablesNotDisjoint
-          attr_reader var: untyped
-
-          attr_reader lower_bound: untyped
-
-          attr_reader upper_bound: untyped
-
-          def initialize: (?var: untyped?, ?lower_bound: untyped?, ?upper_bound: untyped?) -> void
-
-          def message: () -> ::String
-        end
-
-        class UnknownsFreeVariableNotDisjoint
-          attr_reader var: untyped
-
-          attr_reader upper_bound: untyped
-
-          attr_reader lower_bound: untyped
-
-          def initialize: (var: untyped, lower_bound: untyped, upper_bound: untyped) -> void
-
-          def message: () -> ::String
-        end
-      end
-
-      class UnsatisfiableConstraint < StandardError
-        attr_reader var: untyped
-
-        attr_reader sub_type: untyped
-
-        attr_reader super_type: untyped
-
-        attr_reader result: untyped
-
-        def initialize: (var: untyped, sub_type: untyped, super_type: untyped, result: untyped) -> void
-      end
-
-      class Context
-        attr_reader variance: untyped
-
-        attr_reader self_type: AST::Types::t
-
-        attr_reader instance_type: AST::Types::t
-
-        attr_reader class_type: AST::Types::t
-
-        def initialize: (variance: untyped, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> void
-      end
-
-      attr_reader dictionary: Hash[Symbol, [Set[AST::Types::t], Set[AST::Types::t], Set[AST::Types::t]]]
-
-      attr_reader vars: Set[Symbol]
-
-      def initialize: (unknowns: _Each[Symbol]) -> void
-
-      def self.empty: () -> Constraints
-
-      def add_var: (*Symbol vars) -> void
-
-      def add: (Symbol var, ?sub_type: untyped?, ?super_type: untyped?, ?skip: bool) -> untyped
-
-      def eliminate_variable: (AST::Types::t `type`, to: AST::Types::t) -> AST::Types::t
-
-      def unknown?: (Symbol var) -> bool
-
-      def unknowns: () -> Set[Symbol]
-
-      def unknown!: (Symbol var) -> void
-
-      def empty?: () -> bool
-
-      def upper_bound: (Symbol var, ?skip: bool) -> AST::Types::t
-
-      def lower_bound: (Symbol var, ?skip: bool) -> AST::Types::t
-
-      def solution: (Check checker, variables: Enumerable[AST::Types::variable], variance: VariableVariance, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> Interface::Substitution
-                  | (Check checker, variables: Enumerable[AST::Types::variable], context: Context) -> Interface::Substitution
-
-      def has_constraint?: (Symbol var) -> bool
-
-      def each: () { ([Symbol, AST::Types::t, AST::Types::t]) -> void } -> void
-              | () -> Enumerator[[Symbol, AST::Types::t, AST::Types::t], void]
-
-      def to_s: () -> ::String
-
-      private
-
-      def lower_bound_types: (Symbol var_name) -> Set[AST::Types::t]
-
-      def upper_bound_types: (Symbol var_name) -> Set[AST::Types::t]
-    end
-  end
-end

data/sig/steep/subtyping/relation.rbs

@@ -1,63 +0,0 @@
-module Steep
-  module Subtyping
-    class Relation[out Subject < _Subject]
-      interface _Subject
-        def hash: () -> Integer
-
-        def is_a?: (Module) -> bool
-
-        def class: () -> Class
-
-        def !: () -> bool
-      end
-
-      attr_reader sub_type: Subject
-
-      attr_reader super_type: Subject
-
-      def initialize: (sub_type: Subject, super_type: Subject) -> void
-
-      def hash: () -> Integer
-
-      def ==: (untyped other) -> bool
-
-      alias eql? ==
-
-      def to_s: () -> ::String
-
-      def to_ary: () -> [Subject, Subject]
-
-      def type?: () -> bool
-
-      def interface?: () -> bool
-
-      def method?: () -> bool
-
-      def function?: () -> bool
-
-      def params?: () -> bool
-
-      def block?: () -> bool
-
-      type relation_type = :type | :interface | :method | :function | :params | :block
-
-      def assert_type: (relation_type `type`) -> void
-
-      def type!: () -> void
-
-      def interface!: () -> void
-
-      def method!: () -> void
-
-      def function!: () -> void
-
-      def params!: () -> void
-
-      def block!: () -> void
-
-      def map: [T < Object] () { (Subject) -> T } -> Relation[T]
-
-      def flip: () -> Relation[Subject]
-    end
-  end
-end

data/sig/steep/subtyping/result.rbs

@@ -1,179 +0,0 @@
-module Steep
-  module Subtyping
-    module Result
-      type t = Skip | Expand | All | Any | Success | Failure
-
-      class Base
-        attr_reader relation: Relation[untyped]
-
-        def initialize: (Relation[untyped] relation) -> void
-
-        def failure?: () -> bool
-
-        def success?: () -> bool
-
-        def then: () { (self) -> void } -> self
-
-        def else: () { (self) -> void } -> self
-
-        def failure_path: (?Array[t] path) -> Array[t]?
-      end
-
-      class Skip < Base
-        def success?: () -> false
-
-        def failure?: () -> false
-
-        def failure_path: (?untyped path) -> untyped
-      end
-
-      class Expand < Base
-        attr_reader child: t
-
-        def initialize: (Relation[untyped] relation) { (Relation[untyped]) -> t } -> void
-
-        def success?: () -> bool
-
-        def failure_path: (?Array[t] path) -> Array[t]?
-      end
-
-      class All < Base
-        attr_reader branches: Array[t]
-
-        def initialize: (Relation[untyped] relation) -> void
-
-        @failure: bool
-
-        # Returns `false` if no future `#add` changes the result.
-        def add: [T < Relation::_Subject] (*Relation[T] relations) { (Relation[T]) -> t? } -> bool
-
-        # Returns `false` if no future `#add` changes the result.
-        def add_result: (t?) -> bool
-
-        def success?: () -> bool
-
-        def failure?: () -> bool
-
-        def failure_path: (?Array[t] path) -> Array[t]?
-      end
-
-      class Any < Base
-        attr_reader branches: Array[t]
-
-        def initialize: (Relation[untyped] relation) -> void
-
-        @success: bool
-
-        # Returns `false` if no future `#add` changes the result.
-        def add: [T < Object] (*Relation[T] relations) { (Relation[T]) -> t } -> bool
-
-        def success?: () -> bool
-
-        def failure_path: (?Array[t] path) -> Array[t]?
-      end
-
-      class Success < Base
-        def success?: () -> true
-
-        def failure_path: (?Array[t] path) -> Array[t]?
-      end
-
-      class Failure < Base
-        type error = MethodMissingError | BlockMismatchError | ParameterMismatchError
-                   | UnknownPairError | PolyMethodSubtyping | UnsatisfiedConstraints
-                   | SelfBindingMismatch | LoopAbort
-
-        class MethodMissingError
-          attr_reader name: untyped
-
-          def initialize: (name: untyped) -> void
-
-          def message: () -> ::String
-        end
-
-        class BlockMismatchError
-          attr_reader name: untyped
-
-          def initialize: (name: untyped) -> void
-
-          def message: () -> ::String
-        end
-
-        class ParameterMismatchError
-          attr_reader name: untyped
-
-          def initialize: (name: untyped) -> void
-
-          def message: () -> ::String
-        end
-
-        class UnknownPairError
-          attr_reader relation: untyped
-
-          def initialize: (relation: untyped) -> void
-
-          def message: () -> ::String
-        end
-
-        class PolyMethodSubtyping
-          attr_reader name: untyped
-
-          def initialize: (name: untyped) -> void
-
-          def message: () -> ::String
-        end
-
-        class UnsatisfiedConstraints
-          attr_reader error: untyped
-
-          def initialize: (untyped error) -> void
-
-          def var: () -> untyped
-
-          def sub_type: () -> untyped
-
-          def super_type: () -> untyped
-
-          def result: () -> untyped
-
-          def message: () -> ::String
-        end
-
-        class SelfBindingMismatch
-          def initialize: () -> void
-
-          def message: () -> String
-        end
-
-        class LoopAbort
-          def message: () -> String
-        end
-
-        attr_reader error: error
-
-        def initialize: (Relation[untyped] relation, error error) -> void
-
-        def success?: () -> false
-
-        def failure_path: (?Array[t] path) -> Array[t]?
-      end
-
-      module Helper
-        def Skip: (Relation[untyped] relation) -> Skip
-
-        def Expand: [T < Object] (Relation[T] relation) { (Relation[T]) -> t } -> Expand
-
-        def All: (Relation[untyped] relation) { (All) -> void } -> All
-
-        def Any: (Relation[untyped] relation) { (Any) -> void } -> Any
-
-        def Success: (Relation[untyped] relation) -> Success
-
-        alias success Success
-
-        def Failure: (Relation[untyped] relation, Failure::error) -> Failure
-                   | (Relation[untyped]) { () -> Failure::error } -> Failure
-      end
-    end
-  end
-end

data/sig/steep/subtyping/variable_variance.rbs

@@ -1,25 +0,0 @@
-module Steep
-  module Subtyping
-    class VariableVariance
-      attr_reader covariants: Set[Symbol]
-
-      attr_reader contravariants: Set[Symbol]
-
-      def initialize: (covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
-
-      def covariant?: (Symbol var) -> bool
-
-      def contravariant?: (Symbol var) -> bool
-
-      def invariant?: (Symbol var) -> bool
-
-      def self.from_type: (AST::Types::t) -> VariableVariance
-
-      def self.from_method_type: (Interface::MethodType method_type) -> VariableVariance
-
-      def self.add_params: (Interface::Function::Params params, block: bool, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
-
-      def self.add_type: (AST::Types::t `type`, variance: :covariant | :contravariant | :invariant, covariants: Set[Symbol], contravariants: Set[Symbol]) -> void
-    end
-  end
-end

data/sig/steep/thread_waiter.rbs

@@ -1,13 +0,0 @@
-module Steep
-  class ThreadWaiter[A]
-    attr_reader objects: Array[A]
-
-    attr_reader queue: Thread::Queue
-
-    attr_reader waiter_threads: Set[Thread]
-
-    def initialize: (Array[A]) { (A) -> Thread } -> void
-
-    def wait_one: () -> Thread?
-  end
-end