steep 1.0.0 → 1.1.0.pre.1

data/sig/steep/services/type_check_service.rbs

@@ -0,0 +1,93 @@
+module Steep
+  module Services
+    class TypeCheckService
+      attr_reader project: untyped
+
+      attr_reader signature_validation_diagnostics: untyped
+
+      attr_reader source_files: untyped
+
+      attr_reader signature_services: untyped
+
+      class SourceFile
+        attr_reader path: untyped
+
+        attr_reader target: untyped
+
+        attr_reader content: untyped
+
+        attr_reader node: untyped
+
+        attr_reader typing: untyped
+
+        attr_reader errors: untyped
+
+        def initialize: (path: untyped, node: untyped, content: untyped, typing: untyped, errors: untyped) -> void
+
+        def self.with_syntax_error: (path: untyped, content: untyped, error: untyped) -> untyped
+
+        def self.with_typing: (path: untyped, content: untyped, typing: untyped, node: untyped) -> untyped
+
+        def self.no_data: (path: untyped, content: untyped) -> untyped
+
+        def update_content: (untyped content) -> untyped
+
+        def diagnostics: () -> untyped
+      end
+
+      class TargetRequest
+        attr_reader target: untyped
+
+        attr_reader source_paths: untyped
+
+        def initialize: (target: untyped) -> void
+
+        def signature_updated!: (?bool value) -> self
+
+        def signature_updated?: () -> untyped
+
+        def empty?: () -> untyped
+
+        def ==: (untyped other) -> untyped
+
+        alias eql? ==
+
+        def hash: () -> untyped
+      end
+
+      def initialize: (project: untyped) -> void
+
+      def signature_diagnostics: () -> untyped
+
+      def has_diagnostics?: () -> untyped
+
+      def diagnostics: () -> untyped
+
+      def each_diagnostics: () { (untyped) -> untyped } -> untyped
+
+      def update: (changes: untyped) -> untyped
+
+      def update_and_check: (changes: untyped, assignment: untyped) ?{ () -> untyped } -> untyped
+
+      def validate_signature: (path: untyped) { (untyped) -> untyped } -> untyped
+
+      def typecheck_source: (path: untyped, ?target: untyped) { (untyped) -> untyped } -> (nil | untyped)
+
+      def update_signature: (changes: untyped, requests: untyped) -> untyped
+
+      def update_sources: (changes: untyped, requests: untyped) -> untyped
+
+      def type_check_file: (target: untyped, subtyping: untyped, path: untyped, text: untyped) -> untyped
+
+      def self.type_check: (source: Source, subtyping: Subtyping::Check) -> Typing
+
+      def source_file?: (Pathname path) -> (untyped | nil)
+
+      def signature_file?: (Pathname path) -> untyped
+
+      def app_signature_file?: (Pathname path) -> untyped
+
+      def lib_signature_file?: (Pathname path) -> untyped
+    end
+  end
+end

data/sig/steep/source.rbs

@@ -0,0 +1,55 @@
+module Steep
+  class Source
+    class LocatedAnnotation
+      attr_reader line: untyped
+
+      attr_reader annotation: untyped
+
+      attr_reader source: untyped
+
+      def initialize: (line: untyped, source: untyped, annotation: untyped) -> void
+
+      def ==: (untyped other) -> untyped
+    end
+
+    attr_reader path: untyped
+
+    attr_reader node: untyped
+
+    attr_reader mapping: untyped
+
+    def initialize: (path: untyped, node: untyped, mapping: untyped) -> void
+
+    class Builder
+      def string_value: (untyped token) -> untyped
+    end
+
+    def self.new_parser: () -> untyped
+
+    def self.parse: (untyped source_code, path: untyped, factory: untyped) -> untyped
+
+    def self.construct_mapping: (node: untyped, annotations: untyped, mapping: untyped, ?line_range: untyped?) -> untyped
+
+    def self.each_child_node: (untyped node) { (untyped) -> untyped } -> untyped
+
+    def self.map_child_nodes: (untyped node) { (untyped) -> untyped } -> untyped
+
+    def annotations: (block: Parser::AST::Node, factory: AST::Types::Factory, context: RBS::Resolver::context) -> AST::Annotation::Collection
+
+    def each_annotation: () { (untyped, untyped) -> untyped } -> untyped
+
+    def each_heredoc_node: (?untyped node, ?untyped parents) { (untyped) -> untyped } -> untyped
+
+    def find_heredoc_nodes: (untyped line, untyped column, untyped position) -> (untyped | nil)
+
+    def find_nodes_loc: (untyped node, untyped position, untyped parents) -> untyped
+
+    def find_nodes: (line: Integer, column: Integer) -> ::Array[Parser::AST::Node]?
+
+    def self.delete_defs: (untyped node, untyped allow_list) -> untyped
+
+    def without_unrelated_defs: (line: untyped, column: untyped) -> (untyped | self)
+
+    def compact_siblings: (untyped node) -> untyped
+  end
+end

data/sig/steep/subtyping/cache.rbs

@@ -0,0 +1,17 @@
+module Steep
+  module Subtyping
+    class Cache
+      attr_reader subtypes: untyped
+
+      def initialize: () -> void
+
+      def subtype: (untyped relation, untyped self_type, untyped instance_type, untyped class_type, untyped bounds) -> untyped
+
+      def []: (untyped relation, untyped self_type, untyped instance_type, untyped class_type, untyped bounds) -> untyped
+
+      def []=: (untyped relation, untyped self_type, untyped instance_type, untyped class_type, untyped bounds, untyped value) -> untyped
+
+      def no_subtype_cache?: () -> untyped
+    end
+  end
+end

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