steep 1.0.2 → 1.1.0.pre.1

data/sig/steep/services/completion_provider.rbs

@@ -0,0 +1,123 @@
+module Steep
+  module Services
+    class CompletionProvider
+      class Position
+        attr_reader line: Integer
+
+        attr_reader column: Integer
+
+        def initialize: (line: Integer, column: Integer) -> void
+
+        def -: (Integer) -> Position
+      end
+
+      class Range
+        attr_reader start: Position
+
+        attr_reader end: Position
+
+        def initialize: (start: Position, end: Position) -> void
+      end
+
+      class InstanceVariableItem
+        attr_reader identifier: Symbol
+
+        attr_reader range: Range
+
+        attr_reader type: AST::Types::t
+
+        def initialize: (identifier: Symbol, range: Range, type: AST::Types::t) -> void
+      end
+
+      class LocalVariableItem
+        attr_reader identifier: Symbol
+
+        attr_reader range: Range
+
+        attr_reader type: AST::Types::t
+
+        def initialize: (identifier: Symbol, range: Range, type: AST::Types::t) -> void
+      end
+
+      class ConstantItem
+        attr_reader env: RBS::Environment
+
+        attr_reader identifier: Symbol
+
+        attr_reader range: Range
+
+        attr_reader type: AST::Types::t
+
+        attr_reader full_name: RBS::TypeName
+
+        def initialize: (env: RBS::Environment, identifier: Symbol, range: Range, type: AST::Types::t, full_name: RBS::TypeName) -> void
+      end
+
+      class MethodNameItem
+        attr_reader identifier: Symbol
+
+        attr_reader range: Range
+
+        attr_reader receiver_type: AST::Types::t
+
+        attr_reader method_type: untyped
+
+        attr_reader method_decls: Array[TypeInference::MethodCall::MethodDecl]
+
+        def initialize: (identifier: Symbol, range: Range, method_type: untyped, method_decls: Array[TypeInference::MethodCall::MethodDecl]) -> void
+
+        def comment: () -> RBS::AST::Comment?
+
+        def inherited?: () -> bool
+      end
+
+      attr_reader source_text: untyped
+
+      attr_reader path: untyped
+
+      attr_reader subtyping: untyped
+
+      attr_reader modified_text: untyped
+
+      attr_reader source: untyped
+
+      attr_reader typing: Typing
+
+      def initialize: (source_text: untyped, path: untyped, subtyping: untyped) -> void
+
+      def type_check!: (untyped text, line: untyped, column: untyped) -> untyped
+
+      def env: () -> untyped
+
+      def run: (line: untyped, column: untyped) -> untyped
+
+      def range_from_loc: (untyped loc) -> untyped
+
+      def at_end?: (untyped pos, of: untyped) -> (untyped | nil)
+
+      def range_for: (untyped position, ?prefix: ::String) -> untyped
+
+      def items_for_trigger: (position: untyped) -> (::Array[untyped] | untyped)
+
+      def items_for_dot: (position: Position) -> ::Array[MethodNameItem]
+
+      def items_for_colon2: (position: untyped) -> untyped
+
+      def items_for_atmark: (position: untyped) -> (::Array[untyped] | untyped)
+
+      def method_items_for_receiver_type: (untyped `type`, include_private: untyped, prefix: untyped, position: untyped, items: untyped) -> untyped
+
+      def word_name?: (String name) -> void
+
+      def local_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[LocalVariableItem]) -> void
+
+      def constant_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[ConstantItem], ?parent: Parser::AST::Node?) -> void
+
+      def instance_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[InstanceVariableItem]) -> void
+
+      def index_for: (untyped string, line: untyped, column: untyped) -> untyped
+
+      def disallowed_method?: (Symbol name) -> bool
+    end
+  end
+end

data/sig/steep/services/content_change.rbs

@@ -0,0 +1,35 @@
+module Steep
+  module Services
+    class ContentChange
+      class Position
+        attr_reader line: untyped
+
+        attr_reader column: untyped
+
+        def initialize: (line: untyped, column: untyped) -> void
+
+        def ==: (untyped other) -> untyped
+
+        alias eql? ==
+
+        def hash: () -> untyped
+      end
+
+      attr_reader range: untyped
+
+      attr_reader text: untyped
+
+      def initialize: (text: untyped, ?range: untyped?) -> void
+
+      def ==: (untyped other) -> untyped
+
+      alias eql? ==
+
+      def hash: () -> untyped
+
+      def self.string: (untyped string) -> untyped
+
+      def apply_to: (untyped text) -> untyped
+    end
+  end
+end

data/sig/steep/services/file_loader.rbs

@@ -0,0 +1,13 @@
+module Steep
+  module Services
+    class FileLoader
+      attr_reader base_dir: untyped
+
+      def initialize: (base_dir: untyped) -> void
+
+      def each_path_in_patterns: (untyped pattern, ?untyped commandline_patterns) { (untyped) -> untyped } -> untyped
+
+      def load_changes: (untyped pattern, ?untyped command_line_patterns, changes: untyped) -> untyped
+    end
+  end
+end

data/sig/steep/services/goto_service.rbs

@@ -0,0 +1,45 @@
+module Steep
+  module Services
+    class GotoService
+      include ModuleHelper
+
+      module SourceHelper
+        def from_ruby?: () -> untyped
+
+        def from_rbs?: () -> untyped
+      end
+
+      ConstantQuery: untyped
+
+      MethodQuery: untyped
+
+      TypeNameQuery: untyped
+
+      attr_reader type_check: untyped
+
+      attr_reader assignment: untyped
+
+      def initialize: (type_check: untyped, assignment: untyped) -> void
+
+      def project: () -> untyped
+
+      def implementation: (path: untyped, line: untyped, column: untyped) -> untyped
+
+      def definition: (path: untyped, line: untyped, column: untyped) -> untyped
+
+      def test_ast_location: (untyped loc, line: untyped, column: untyped) -> (false | true)
+
+      def query_at: (path: untyped, line: untyped, column: untyped) -> untyped
+
+      def type_check_path: (target: untyped, path: untyped, content: untyped, line: untyped, column: untyped) -> untyped
+
+      def constant_definition_in_rbs: (untyped name, locations: untyped) -> untyped
+
+      def constant_definition_in_ruby: (untyped name, locations: untyped) -> untyped
+
+      def method_locations: (untyped name, in_ruby: untyped, in_rbs: untyped, locations: untyped) -> untyped
+
+      def type_name_locations: (untyped name, ?locations: untyped) -> untyped
+    end
+  end
+end

data/sig/steep/services/hover_provider/rbs.rbs

@@ -0,0 +1,21 @@
+module Steep
+  module Services
+    module HoverProvider
+      class RBS
+        TypeAliasContent: untyped
+
+        ClassContent: untyped
+
+        InterfaceContent: untyped
+
+        attr_reader service: untyped
+
+        def initialize: (service: untyped) -> void
+
+        def project: () -> untyped
+
+        def content_for: (target: untyped, path: untyped, line: untyped, column: untyped) -> (nil | untyped)
+      end
+    end
+  end
+end

data/sig/steep/services/hover_provider/ruby.rbs

@@ -0,0 +1,109 @@
+module Steep
+  module Services
+    module HoverProvider
+      class Ruby
+        class TypeContent
+          attr_reader node: Parser::AST::Node
+
+          attr_reader type: AST::Types::t
+
+          attr_reader location: Parser::Source::Range
+
+          def initialize: (node: Parser::AST::Node, type: AST::Types::t, location: Parser::Source::Range) -> void
+        end
+
+        # Hover content for a local variable, references or assignments
+        #
+        # ```ruby
+        #   a = 123
+        # # ^^^^        Hover popups
+        # # ^           Location covers
+        #
+        #   a + 1
+        # # ^           Hover popups
+        # # ^           Location covers
+        # ```
+        class VariableContent
+          attr_reader node: Parser::AST::Node
+
+          attr_reader name: Symbol
+
+          attr_reader type: AST::Types::t
+
+          attr_reader location: Parser::Source::Range
+
+          def initialize: (node: Parser::AST::Node, name: Symbol, type: AST::Types::t, location: Parser::Source::Range) -> void
+        end
+
+        class MethodCallContent
+          attr_reader node: Parser::AST::Node
+
+          attr_reader method_call: TypeInference::MethodCall::t
+
+          attr_reader location: Parser::Source::Range
+
+          def initialize: (node: Parser::AST::Node, method_call: TypeInference::MethodCall::t, location: Parser::Source::Range) -> void
+        end
+
+        class DefinitionContent
+          attr_reader node: Parser::AST::Node
+
+          attr_reader method_name: method_name
+
+          attr_reader method_type: Interface::MethodType
+
+          attr_reader definition: ::RBS::Definition::Method
+
+          attr_reader location: Parser::Source::Range
+
+          def initialize: (node: Parser::AST::Node, method_name: method_name, method_type: Interface::MethodType, definition: ::RBS::Definition::Method, location: Parser::Source::Range) -> void
+        end
+
+        class ConstantContent
+          attr_reader location: Parser::Source::Range
+
+          attr_reader full_name: ::RBS::TypeName
+
+          attr_reader type: AST::Types::t
+
+          type decl = ::RBS::Environment::ClassEntry
+                    | ::RBS::Environment::ModuleEntry
+                    | ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]
+
+          attr_reader decl: decl
+
+          attr_reader class_decl(): ::RBS::Environment::ClassEntry | ::RBS::Environment::ModuleEntry | nil
+
+          attr_reader constant_decl(): ::RBS::Environment::SingleEntry[::RBS::TypeName, ::RBS::AST::Declarations::Constant]?
+
+          def initialize: (location: Parser::Source::Range, full_name: ::RBS::TypeName, type: AST::Types::t, decl: decl) -> void
+
+          def comments: () -> Array[::RBS::AST::Comment]
+
+          # Returns true if `decl` is a class/module definition
+          def class_or_module?: () -> bool
+
+          # Returns true if `decl` is a constant definition
+          def constant?: () -> bool
+        end
+
+        type content = TypeContent | VariableContent | MethodCallContent | DefinitionContent | ConstantContent
+
+        attr_reader service: TypeCheckService
+
+        def initialize: (service: TypeCheckService) -> void
+
+        def project: () -> Project
+
+        def method_definition_for: (AST::Types::Factory factory, ::RBS::TypeName type_name, singleton_method: Symbol) -> ::RBS::Definition::Method
+                                 | (AST::Types::Factory factory, ::RBS::TypeName type_name, instance_method: Symbol) -> ::RBS::Definition::Method
+
+        def typecheck: (Project::Target target, path: Pathname, content: String, line: Integer, column: Integer) -> Typing?
+
+        def method_name_from_method: (TypeInference::Context::MethodContext context, builder: ::RBS::DefinitionBuilder) -> method_name
+
+        def content_for: (target: Project::Target, path: Pathname, line: Integer, column: Integer) -> content?
+      end
+    end
+  end
+end

data/sig/steep/services/hover_provider/singleton_methods.rbs

@@ -0,0 +1,11 @@
+module Steep
+  module Services
+    module HoverProvider
+      module SingletonMethods
+        def content_for: (service: untyped, path: untyped, line: untyped, column: untyped) -> untyped
+      end
+
+      extend SingletonMethods
+    end
+  end
+end

data/sig/steep/services/path_assignment.rbs

@@ -0,0 +1,21 @@
+module Steep
+  module Services
+    class PathAssignment
+      attr_reader index: untyped
+
+      attr_reader max_index: untyped
+
+      attr_reader cache: untyped
+
+      def initialize: (index: untyped, max_index: untyped) -> void
+
+      def self.all: () -> untyped
+
+      def =~: (untyped path) -> untyped
+
+      alias === =~
+
+      def self.index_for: (path: untyped, max_index: untyped) -> untyped
+    end
+  end
+end

data/sig/steep/services/signature_service.rbs

@@ -0,0 +1,91 @@
+module Steep
+  module Services
+    class SignatureService
+      attr_reader status: untyped
+
+      class SyntaxErrorStatus
+        attr_reader files: untyped
+
+        attr_reader changed_paths: untyped
+
+        attr_reader diagnostics: untyped
+
+        attr_reader last_builder: untyped
+
+        def initialize: (files: untyped, changed_paths: untyped, diagnostics: untyped, last_builder: untyped) -> void
+
+        def rbs_index: () -> untyped
+      end
+
+      class AncestorErrorStatus
+        attr_reader files: untyped
+
+        attr_reader changed_paths: untyped
+
+        attr_reader diagnostics: untyped
+
+        attr_reader last_builder: untyped
+
+        def initialize: (files: untyped, changed_paths: untyped, diagnostics: untyped, last_builder: untyped) -> void
+
+        def rbs_index: () -> untyped
+      end
+
+      class LoadedStatus
+        attr_reader files: untyped
+
+        attr_reader builder: untyped
+
+        def initialize: (files: untyped, builder: untyped) -> void
+
+        def subtyping: () -> untyped
+
+        def rbs_index: () -> untyped
+      end
+
+      FileStatus: untyped
+
+      def initialize: (env: untyped) -> void
+
+      def self.load_from: (untyped loader) -> untyped
+
+      def env_rbs_paths: () -> untyped
+
+      def each_rbs_path: () { (untyped) -> untyped } -> untyped
+
+      def files: () -> untyped
+
+      def pending_changed_paths: () -> untyped
+
+      def latest_env: () -> untyped
+
+      def latest_builder: () -> untyped
+
+      def latest_rbs_index: () -> untyped
+
+      def current_subtyping: () -> (untyped | nil)
+
+      def apply_changes: (untyped files, untyped changes) -> untyped
+
+      def update: (untyped changes) -> untyped
+
+      def update_env: (untyped updated_files, paths: untyped) -> untyped
+
+      def rescue_rbs_error: (untyped errors) { () -> untyped } -> untyped
+
+      def update_builder: (ancestor_builder: untyped, paths: untyped) -> untyped
+
+      def type_names: (paths: untyped, env: untyped) -> untyped
+
+      def const_decls: (paths: untyped, env: untyped) -> untyped
+
+      def global_decls: (paths: untyped, ?env: untyped) -> untyped
+
+      def type_name_from_decl: (untyped decl, set: untyped) -> untyped
+
+      def add_descendants: (graph: untyped, names: untyped, set: untyped) -> untyped
+
+      def add_nested_decls: (env: untyped, names: untyped, set: untyped) -> untyped
+    end
+  end
+end

data/sig/steep/services/stats_calculator.rbs

@@ -0,0 +1,17 @@
+module Steep
+  module Services
+    class StatsCalculator
+      SuccessStats: untyped
+
+      ErrorStats: untyped
+
+      attr_reader service: untyped
+
+      def initialize: (service: untyped) -> void
+
+      def project: () -> untyped
+
+      def calc_stats: (untyped target, file: untyped) -> untyped
+    end
+  end
+end

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