steep 1.0.2 → 1.1.0.pre.1

data/sig/steep/subtyping/check.rbs

@@ -0,0 +1,93 @@
+module Steep
+  module Subtyping
+    class Check
+      attr_reader factory: AST::Types::Factory
+
+      attr_reader cache: untyped
+
+      attr_reader assumptions: untyped
+
+      def initialize: (factory: untyped) -> void
+
+      def with_context: (self_type: untyped, instance_type: untyped, class_type: untyped, constraints: untyped) { () -> untyped } -> untyped
+
+      def push_assumption: (untyped relation) { () -> untyped } -> untyped
+
+      def push_variable_bounds: (untyped params) { () -> untyped } -> untyped
+
+      def variable_upper_bound: (untyped name) -> (untyped | nil)
+
+      def self_type: () -> untyped
+
+      def instance_type: () -> untyped
+
+      def class_type: () -> untyped
+
+      def constraints: () -> untyped
+
+      def each_ancestor: (untyped ancestors) { (untyped) -> untyped } -> untyped
+
+      def instance_super_types: (untyped type_name, args: untyped) -> untyped
+
+      def singleton_super_types: (untyped type_name) -> untyped
+
+      def check: (untyped relation, constraints: untyped, self_type: untyped, instance_type: untyped, class_type: untyped) -> untyped
+
+      def check_type: (untyped relation) -> untyped
+
+      def cache_bounds: (untyped relation) -> untyped
+
+      def alias?: (untyped `type`) -> untyped
+
+      def cacheable?: (untyped relation) -> untyped
+
+      def true_type?: (untyped `type`) -> untyped
+
+      def false_type?: (untyped `type`) -> untyped
+
+      include Result::Helper
+
+      def check_type0: (untyped relation) -> untyped
+
+      def definition_for_type: (untyped `type`) -> untyped
+
+      def arg_type?: (untyped `type`) -> untyped
+
+      def check_type_arg: (untyped relation) -> untyped
+
+      def same_type?: (untyped relation) -> (true | untyped)
+
+      def check_interface: (untyped relation) -> untyped
+
+      def check_method: (untyped name, untyped relation) -> untyped
+
+      def check_type_application: (untyped result, untyped type_params, untyped type_args) { () -> untyped } -> untyped
+
+      def check_generic_method_type: (untyped name, untyped relation) -> untyped
+
+      def check_constraints: (untyped relation, variables: untyped, variance: untyped) -> untyped
+
+      def check_method_type: (untyped name, untyped relation) -> untyped
+
+      def check_block_given: (untyped name, untyped relation) { () -> untyped } -> untyped
+
+      def check_function: (untyped name, untyped relation) -> untyped
+
+      def check_method_params: (untyped name, untyped relation) -> untyped
+
+      # ```rbs
+      # (Symbol, Relation[MethodType]) -> (Array[[Symbol, Symbol]] | Result::t)
+      # [A] (Symbol, Relation[MethodType]) { (Array[[Symbol, Symbol]]) -> A } -> (A | Result::t)
+      # ````
+      def match_method_type: (untyped name, untyped relation) { (untyped) -> untyped } -> untyped
+
+      def match_params: (untyped name, untyped relation) -> untyped
+
+      def expand_alias: (untyped `type`) { () -> untyped } -> untyped
+
+      # Returns the shortest type paths for one of the _unknown_ type variables.
+      # Returns nil if there is no path.
+      def hole_path: (untyped `type`, ?untyped path) -> untyped
+    end
+  end
+end

data/sig/steep/subtyping/constraints.rbs

@@ -0,0 +1,111 @@
+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[Symbol], variance: VariableVariance, self_type: AST::Types::t, instance_type: AST::Types::t, class_type: AST::Types::t) -> Interface::Substitution
+                  | (Check checker, variables: Enumerable[Symbol], 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

@@ -0,0 +1,51 @@
+module Steep
+  module Subtyping
+    class Relation
+      attr_reader sub_type: untyped
+
+      attr_reader super_type: untyped
+
+      def initialize: (sub_type: untyped, super_type: untyped) -> void
+
+      def hash: () -> untyped
+
+      def ==: (untyped other) -> untyped
+
+      alias eql? ==
+
+      def to_s: () -> ::String
+
+      def to_ary: () -> ::Array[untyped]
+
+      def type?: () -> untyped
+
+      def interface?: () -> untyped
+
+      def method?: () -> untyped
+
+      def function?: () -> untyped
+
+      def params?: () -> untyped
+
+      def block?: () -> untyped
+
+      def assert_type: (untyped `type`) -> (untyped | nil)
+
+      def type!: () -> untyped
+
+      def interface!: () -> untyped
+
+      def method!: () -> untyped
+
+      def function!: () -> untyped
+
+      def params!: () -> untyped
+
+      def block!: () -> untyped
+
+      def map: () { (untyped) -> untyped } -> untyped
+
+      def flip: () -> untyped
+    end
+  end
+end

data/sig/steep/subtyping/result.rbs

@@ -0,0 +1,157 @@
+module Steep
+  module Subtyping
+    module Result
+      type t = Skip | Expand | All | Any | Success | Failure
+
+      class Base
+        attr_reader relation: Relation
+
+        def initialize: (Relation relation) -> void
+
+        def failure?: () -> bool
+
+        def success?: () -> bool
+
+        def then: [A] () { (self) -> A } -> A
+
+        def else: [A] () { (self) -> A } -> A
+
+        def failure_path: (?untyped path) -> untyped
+      end
+
+      class Skip < Base
+        def success?: () -> false
+
+        def failure?: () -> false
+
+        def failure_path: (?untyped path) -> untyped
+      end
+
+      class Expand < Base
+        attr_reader child: untyped
+
+        def initialize: (untyped relation) { (untyped) -> untyped } -> void
+
+        def success?: () -> untyped
+
+        def failure_path: (?untyped path) -> (untyped | nil)
+      end
+
+      class All < Base
+        attr_reader branches: untyped
+
+        def initialize: (untyped relation) -> void
+
+        # Returns `false` if no future `#add` changes the result.
+        def add: (*untyped relations) { (untyped) -> untyped } -> untyped
+
+        def success?: () -> untyped
+
+        def failure?: () -> untyped
+
+        def failure_path: (?untyped path) -> (untyped | nil)
+      end
+
+      class Any < Base
+        attr_reader branches: untyped
+
+        def initialize: (untyped relation) -> void
+
+        # Returns `false` if no future `#add` changes the result.
+        def add: (*untyped relations) { (untyped) -> untyped } -> untyped
+
+        def success?: () -> untyped
+
+        def failure_path: (?untyped path) -> (untyped | nil)
+      end
+
+      class Success < Base
+        def success?: () -> true
+
+        def failure_path: (?untyped path) -> nil
+      end
+
+      class Failure < Base
+        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
+
+        attr_reader error: untyped
+
+        def initialize: (untyped relation, untyped error) -> void
+
+        def success?: () -> false
+
+        def failure_path: (?untyped path) -> untyped
+      end
+
+      module Helper
+        def Skip: (untyped relation) -> untyped
+
+        def Expand: (untyped relation) { () -> untyped } -> untyped
+
+        def All: (untyped relation) { () -> untyped } -> untyped
+
+        def Any: (untyped relation) { () -> untyped } -> untyped
+
+        def Success: (untyped relation) -> untyped
+
+        alias success Success
+
+        def Failure: (untyped relation, ?untyped? error) { () -> untyped } -> untyped
+      end
+    end
+  end
+end

data/sig/steep/subtyping/variable_variance.rbs

@@ -0,0 +1,23 @@
+module Steep
+  module Subtyping
+    class VariableVariance
+      attr_reader covariants: untyped
+
+      attr_reader contravariants: untyped
+
+      def initialize: (covariants: untyped, contravariants: untyped) -> void
+
+      def covariant?: (untyped var) -> untyped
+
+      def contravariant?: (untyped var) -> untyped
+
+      def invariant?: (untyped var) -> untyped
+
+      def self.from_method_type: (untyped method_type) -> untyped
+
+      def self.add_params: (untyped params, block: untyped, covariants: untyped, contravariants: untyped) -> untyped
+
+      def self.add_type: (untyped `type`, variance: untyped, covariants: untyped, contravariants: untyped) -> untyped
+    end
+  end
+end