steep-activesupport-4 1.9.3

data/lib/steep/services/content_change.rb

@@ -0,0 +1,61 @@
+module Steep
+  module Services
+    class ContentChange
+      class Position
+        attr_reader :line, :column
+
+        def initialize(line:, column:)
+          @line = line
+          @column = column
+        end
+
+        def ==(other)
+          other.is_a?(Position) && other.line == line && other.column == column
+        end
+
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ line ^ column
+        end
+      end
+
+      attr_reader :range, :text
+
+      def initialize(range: nil, text:)
+        @range = range
+        @text = text
+      end
+
+      def ==(other)
+        other.is_a?(ContentChange) && other.range == range && other.text == text
+      end
+
+      alias eql? ==
+
+      def hash
+        self.class.hash ^ range.hash ^ text.hash
+      end
+
+      def self.string(string)
+        new(text: string)
+      end
+
+      def apply_to(text)
+        if range
+          text = text.dup
+          start_pos, end_pos = range
+
+          buf = RBS::Buffer.new(name: :_, content: text)
+          start_pos = buf.loc_to_pos([start_pos.line, start_pos.column])
+          end_pos = buf.loc_to_pos([end_pos.line, end_pos.column])
+
+          text[start_pos...end_pos] = self.text
+          text
+        else
+          self.text
+        end
+      end
+    end
+  end
+end

data/lib/steep/services/file_loader.rb

@@ -0,0 +1,74 @@
+module Steep
+  module Services
+    class FileLoader
+      attr_reader :base_dir
+
+      def initialize(base_dir:)
+        @base_dir = base_dir
+      end
+
+      def each_path_in_target(target, command_line_patterns = [], &block)
+        if block
+          done = Set[] #: Set[Pathname]
+
+          handler = -> (path) do
+            unless done.include?(path)
+              done << path
+              yield path
+            end
+          end
+
+          target.groups.each do |group|
+            each_path_in_patterns(group.source_pattern, command_line_patterns, &handler)
+            each_path_in_patterns(group.signature_pattern, &handler)
+          end
+
+          each_path_in_patterns(target.source_pattern, command_line_patterns, &handler)
+          each_path_in_patterns(target.signature_pattern, &handler)
+        else
+          enum_for :each_path_in_target, target, command_line_patterns
+        end
+      end
+
+      def each_path_in_patterns(pattern, commandline_patterns = [])
+        if block_given?
+          pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
+
+          pats.each do |path|
+            Pathname.glob((base_dir + path).to_s).each do |absolute_path|
+              if absolute_path.file?
+                relative_path = absolute_path.relative_path_from(base_dir)
+                if pattern =~ relative_path
+                  yield relative_path
+                end
+              else
+                files = Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+
+                files.sort.each do |source_path|
+                  if source_path.file?
+                    relative_path = source_path.relative_path_from(base_dir)
+                    unless pattern.ignore?(relative_path)
+                      yield relative_path
+                    end
+                  end
+                end
+              end
+            end
+          end
+        else
+          enum_for :each_path_in_patterns, pattern, commandline_patterns
+        end
+      end
+
+      def load_changes(pattern, command_line_patterns = [], changes:)
+        each_path_in_patterns(pattern, command_line_patterns) do |path|
+          unless changes.key?(path)
+            changes[path] = [ContentChange.string((base_dir + path).read)]
+          end
+        end
+
+        changes
+      end
+    end
+  end
+end

data/lib/steep/services/goto_service.rb

@@ -0,0 +1,441 @@
+module Steep
+  module Services
+    class GotoService
+      include ModuleHelper
+
+      module SourceHelper
+        def from_ruby?
+          from == :ruby
+        end
+
+        def from_rbs?
+          from == :rbs
+        end
+      end
+
+      class ConstantQuery < Struct.new(:name, :from, keyword_init: true)
+        include SourceHelper
+      end
+      class MethodQuery < Struct.new(:name, :from, keyword_init: true)
+        include SourceHelper
+      end
+      class TypeNameQuery < Struct.new(:name, keyword_init: true)
+      end
+
+      attr_reader :type_check, :assignment
+
+      def initialize(type_check:, assignment:)
+        @type_check = type_check
+        @assignment = assignment
+      end
+
+      def project
+        type_check.project
+      end
+
+      def implementation(path:, line:, column:)
+        locations = [] #: Array[target_loc]
+
+        queries = query_at(path: path, line: line, column: column)
+        queries.uniq!
+
+        queries.each do |query|
+          case query
+          when ConstantQuery
+            constant_definition_in_ruby(query.name, locations: locations)
+          when MethodQuery
+            method_locations(query.name, locations: locations, in_ruby: true, in_rbs: false)
+          when TypeNameQuery
+            constant_definition_in_ruby(query.name, locations: locations)
+          end
+        end
+
+        locations.map { _1[1] }.uniq
+      end
+
+      def definition(path:, line:, column:)
+        locations = [] #: Array[target_loc]
+
+        queries = query_at(path: path, line: line, column: column)
+        queries.uniq!
+
+        queries.each do |query|
+          case query
+          when ConstantQuery
+            constant_definition_in_rbs(query.name, locations: locations) if query.from_ruby?
+            constant_definition_in_ruby(query.name, locations: locations) if query.from_rbs?
+          when MethodQuery
+            method_locations(
+              query.name,
+              locations: locations,
+              in_ruby: query.from_rbs?,
+              in_rbs: query.from_ruby?
+            )
+          when TypeNameQuery
+            type_name_locations(query.name, locations: locations)
+          end
+        end
+
+        # Drop un-assigned paths here.
+        # The path assignment makes sense only for `.rbs` files, because un-assigned `.rb` files are already skipped since they are not type checked.
+        #
+        locations.filter_map do |target, loc|
+          case loc
+          when RBS::Location
+            if assignment =~ [target, loc.name]
+              loc
+            end
+          else
+            loc
+          end
+        end.uniq
+      end
+
+      def type_definition(path:, line:, column:)
+        locations = [] #: Array[target_loc]
+
+        relative_path = project.relative_path(path)
+
+        target = type_check.project.target_for_path(relative_path) or return []
+        source = type_check.source_files.fetch(relative_path)
+        typing, signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
+
+        typing or return []
+        signature or return []
+
+        node, *_parents = typing.source.find_nodes(line: line, column: column)
+        node or return []
+
+        type = typing.type_of(node: node)
+
+        subtyping = signature.current_subtyping or return []
+
+        each_type_name(type).uniq.each do |name|
+          type_name_locations(name, locations: locations)
+        end
+
+        locations.filter_map do |target, loc|
+          case loc
+          when RBS::Location
+            if assignment =~ [target, loc.name]
+              loc
+            end
+          else
+            loc
+          end
+        end.uniq
+      end
+
+      def each_type_name(type, &block)
+        if block
+          case type
+          when AST::Types::Name::Instance, AST::Types::Name::Alias, AST::Types::Name::Singleton, AST::Types::Name::Interface
+            yield type.name
+          when AST::Types::Literal
+            yield type.back_type.name
+          when AST::Types::Nil
+            yield RBS::TypeName.new(name: :NilClass, namespace: RBS::Namespace.root)
+          when AST::Types::Boolean
+            yield RBS::BuiltinNames::TrueClass.name
+            yield RBS::BuiltinNames::FalseClass.name
+          end
+
+          type.each_child do |child|
+            each_type_name(child, &block)
+          end
+        else
+          enum_for :each_type_name, type
+        end
+      end
+
+      def test_ast_location(loc, line:, column:)
+        return false if line < loc.line
+        return false if line == loc.line && column < loc.column
+        return false if loc.last_line < line
+        return false if line == loc.last_line && loc.last_column < column
+        true
+      end
+
+      def query_at(path:, line:, column:)
+        queries = [] #: Array[query]
+
+        relative_path = project.relative_path(path)
+
+        case
+        when target = type_check.project.target_for_source_path(relative_path)
+          source = type_check.source_files.fetch(relative_path, nil) or return []
+          typing, _signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
+          if typing
+            node, *parents = typing.source.find_nodes(line: line, column: column)
+
+            if node && parents
+              case node.type
+              when :const, :casgn
+                named_location = (_ = node.location) #: Parser::AST::_NamedLocation
+                if test_ast_location(named_location.name, line: line, column: column)
+                  if name = typing.source_index.reference(constant_node: node)
+                    queries << ConstantQuery.new(name: name, from: :ruby)
+                  end
+                end
+              when :def, :defs
+                named_location = (_ = node.location) #: Parser::AST::_NamedLocation
+                if test_ast_location(named_location.name, line: line, column: column)
+                  if method_context = typing.cursor_context.context&.method_context
+                    if method = method_context.method
+                      method.defs.each do |defn|
+                        singleton_method =
+                          case defn.member
+                          when RBS::AST::Members::MethodDefinition
+                            defn.member.singleton?
+                          when RBS::AST::Members::Attribute
+                            defn.member.kind == :singleton
+                          end
+
+                        name =
+                          if singleton_method
+                            SingletonMethodName.new(type_name: defn.defined_in, method_name: method_context.name)
+                          else
+                            InstanceMethodName.new(type_name: defn.defined_in, method_name: method_context.name)
+                          end
+
+                        queries << MethodQuery.new(name: name, from: :ruby)
+                      end
+                    end
+                  end
+                end
+              when :send
+                location = (_ = node.location) #: Parser::AST::_SelectorLocation
+                if test_ast_location(location.selector, line: line, column: column)
+                  if (parent = parents[0]) && parent.type == :block && parent.children[0] == node
+                    node = parents[0]
+                  end
+
+                  case call = typing.call_of(node: node)
+                  when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+                    call.method_decls.each do |decl|
+                      queries << MethodQuery.new(name: decl.method_name, from: :ruby)
+                    end
+                  when TypeInference::MethodCall::Untyped
+                    # nop
+                  when TypeInference::MethodCall::NoMethodError
+                    # nop
+                  end
+                end
+              end
+            end
+          end
+        when target_names = type_check.signature_file?(path) #: Array[Symbol]
+          target_names.each do |target_name|
+            signature_service = type_check.signature_services[target_name] #: SignatureService
+
+            env = signature_service.latest_env
+            buffer = env.buffers.find {|buf| buf.name.to_s == relative_path.to_s } or raise
+            (dirs, decls = env.signatures[buffer]) or raise
+
+            locator = RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
+            last, nodes = locator.find2(line: line, column: column)
+
+            nodes or raise
+
+            case nodes[0]
+            when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+              if last == :name
+                queries << ConstantQuery.new(name: nodes[0].name, from: :rbs)
+              end
+            when RBS::AST::Declarations::Constant
+              if last == :name
+                queries << ConstantQuery.new(name: nodes[0].name, from: :rbs)
+              end
+            when RBS::AST::Members::MethodDefinition
+              if last == :name
+                parent_node = nodes[1] #: RBS::AST::Declarations::Class | RBS::AST::Declarations::Module | RBS::AST::Declarations::Interface
+                type_name = parent_node.name
+                method_name = nodes[0].name
+                if nodes[0].instance?
+                  queries << MethodQuery.new(
+                    name: InstanceMethodName.new(type_name: type_name, method_name: method_name),
+                    from: :rbs
+                  )
+                end
+                if nodes[0].singleton?
+                  queries << MethodQuery.new(
+                    name: SingletonMethodName.new(type_name: type_name, method_name: method_name),
+                    from: :rbs
+                  )
+                end
+              end
+            when RBS::AST::Members::Include, RBS::AST::Members::Extend, RBS::AST::Members::Prepend
+              if last == :name
+                queries << TypeNameQuery.new(name: nodes[0].name)
+              end
+            when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Interface, RBS::Types::Alias
+              if last == :name
+                queries << TypeNameQuery.new(name: nodes[0].name)
+              end
+            when RBS::AST::Declarations::Class::Super, RBS::AST::Declarations::Module::Self
+              if last == :name
+                queries << TypeNameQuery.new(name: nodes[0].name)
+              end
+            end
+          end
+        end
+
+        queries
+      end
+
+      def type_check_path(target:, path:, content:, line:, column:)
+        signature_service = type_check.signature_services.fetch(target.name)
+        subtyping = signature_service.current_subtyping or return
+        source = Source.parse(content, path: path, factory: subtyping.factory)
+        source = source.without_unrelated_defs(line: line, column: column)
+        resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+        loc = source.buffer.loc_to_pos([line, column])
+        [
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: loc),
+          signature_service
+        ]
+      rescue
+        nil
+      end
+
+      def constant_definition_in_rbs(name, locations:)
+        project.targets.each do |target|
+          signature = type_check.signature_services.fetch(target.name)
+          env = signature.latest_env #: RBS::Environment
+
+          case entry = env.constant_entry(name)
+          when RBS::Environment::ConstantEntry
+            if entry.decl.location
+              locations << [target, entry.decl.location[:name]]
+            end
+          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+            entry.decls.each do |d|
+              if d.decl.location
+                locations << [target, d.decl.location[:name]]
+              end
+            end
+          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            if entry.decl.location
+              locations << [target, entry.decl.location[:new_name]]
+            end
+          end
+        end
+
+        locations
+      end
+
+      def constant_definition_in_ruby(name, locations:)
+        type_check.source_files.each do |path, source|
+          if typing = source.typing
+            target = project.target_for_source_path(path) or raise
+            entry = typing.source_index.entry(constant: name)
+            entry.definitions.each do |node|
+              case node.type
+              when :const
+                locations << [target, node.location.expression]
+              when :casgn
+                parent = node.children[0]
+                location =
+                  if parent
+                    parent.location.expression.join(node.location.name)
+                  else
+                    node.location.name
+                  end
+                locations << [target, location]
+              end
+            end
+          end
+        end
+
+        locations
+      end
+
+      def method_locations(name, in_ruby:, in_rbs:, locations:)
+        if in_ruby
+          type_check.source_files.each do |path, source|
+            if typing = source.typing
+              target = project.target_for_source_path(path) or raise
+              entry = typing.source_index.entry(method: name)
+
+              if entry.definitions.empty?
+                if name.is_a?(SingletonMethodName) && name.method_name == :new
+                  initialize = InstanceMethodName.new(method_name: :initialize, type_name: name.type_name)
+                  entry = typing.source_index.entry(method: initialize)
+                end
+              end
+
+              entry.definitions.each do |node|
+                case node.type
+                when :def
+                  locations << [target, node.location.name]
+                when :defs
+                  locations << [target, node.location.name]
+                end
+              end
+            end
+          end
+        end
+
+        if in_rbs
+          project.targets.each do |target|
+            signature = type_check.signature_services.fetch(target.name)
+            index = signature.latest_rbs_index
+
+            entry = index.entry(method_name: name)
+
+            if entry.declarations.empty?
+              if name.is_a?(SingletonMethodName) && name.method_name == :new
+                initialize = InstanceMethodName.new(method_name: :initialize, type_name: name.type_name)
+                entry = index.entry(method_name: initialize)
+              end
+            end
+
+            entry.declarations.each do |decl|
+              case decl
+              when RBS::AST::Members::MethodDefinition
+                if decl.location
+                  locations << [target, decl.location[:name]]
+                end
+              when RBS::AST::Members::Alias
+                if decl.location
+                  locations << [target, decl.location[:new_name]]
+                end
+              when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+                if decl.location
+                  locations << [target, decl.location[:name]]
+                end
+              end
+            end
+          end
+        end
+
+        locations
+      end
+
+      def type_name_locations(name, locations: [])
+        project.targets.each do |target|
+          signature = type_check.signature_services.fetch(target.name)
+          index = signature.latest_rbs_index
+
+          entry = index.entry(type_name: name)
+          entry.declarations.each do |decl|
+            case decl
+            when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface, RBS::AST::Declarations::TypeAlias
+              if decl.location
+                locations << [target, decl.location[:name]]
+              end
+            when RBS::AST::Declarations::AliasDecl
+              if decl.location
+                locations << [target, decl.location[:new_name]]
+              end
+            else
+              raise
+            end
+          end
+        end
+
+        locations
+      end
+    end
+  end
+end

data/lib/steep/services/hover_provider/rbs.rb

@@ -0,0 +1,88 @@
+module Steep
+  module Services
+    module HoverProvider
+      class RBS
+        TypeAliasContent = _ = Struct.new(:location, :decl, keyword_init: true)
+        ClassContent = _ = Struct.new(:location, :decl, keyword_init: true)
+        InterfaceContent = _ = Struct.new(:location, :decl, keyword_init: true)
+
+        attr_reader :service
+
+        def initialize(service:)
+          @service = service
+        end
+
+        def project
+          service.project
+        end
+
+        def content_for(target:, path:, line:, column:)
+          service = self.service.signature_services.fetch(target.name)
+
+          env = service.latest_env
+          buffer = env.buffers.find {|buf| buf.name.to_s == path.to_s } or return
+          (dirs, decls = env.signatures[buffer]) or raise
+
+          locator = ::RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
+          loc_key, path = locator.find2(line: line, column: column) || return
+          head, *_tail = path
+
+          case head
+          when ::RBS::Types::Alias
+            content_for_type_name(head.name, env: env, location: head.location || raise)
+
+          when ::RBS::Types::ClassInstance, ::RBS::Types::ClassSingleton
+            if loc_key == :name
+              location = head.location&.[](:name) or raise
+              content_for_type_name(head.name, env: env, location: location)
+            end
+
+          when ::RBS::Types::Interface
+            location = head.location&.[](:name) or raise
+            content_for_type_name(head.name, env: env, location: location)
+
+          when ::RBS::AST::Declarations::ClassAlias, ::RBS::AST::Declarations::ModuleAlias
+            if loc_key == :old_name
+              location = head.location&.[](:old_name) or raise
+              content_for_type_name(head.old_name, env: env, location: location)
+            end
+
+          when ::RBS::AST::Directives::Use::SingleClause
+            if loc_key == :type_name
+              location = head.location&.[](:type_name) or raise
+              content_for_type_name(head.type_name.absolute!, env: env, location: location)
+            end
+
+          when ::RBS::AST::Directives::Use::WildcardClause
+            if loc_key == :namespace
+              location = head.location&.[](:namespace) or raise
+              content_for_type_name(head.namespace.to_type_name.absolute!, env: env, location: location)
+            end
+          end
+        end
+
+        def content_for_type_name(type_name, env:, location:)
+          case
+          when type_name.alias?
+            alias_decl = env.type_alias_decls[type_name]&.decl or return
+            TypeAliasContent.new(location: location, decl: alias_decl)
+          when type_name.interface?
+            interface_decl = env.interface_decls[type_name]&.decl or return
+            InterfaceContent.new(location: location, decl: interface_decl)
+          when type_name.class?
+            class_entry = env.module_class_entry(type_name) or return
+
+            case class_entry
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+              class_decl = class_entry.primary.decl
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
+              class_decl = class_entry.decl
+            end
+
+            ClassContent.new(location: location, decl: class_decl)
+          end
+        end
+      end
+    end
+  end
+end