steep-activesupport-4 1.9.3

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

@@ -0,0 +1,221 @@
+module Steep
+  module Services
+    module HoverProvider
+      class Ruby
+        TypeContent = _ = Struct.new(:node, :type, :location, keyword_init: true)
+        VariableContent = _ = Struct.new(:node, :name, :type, :location, keyword_init: true)
+        TypeAssertionContent = _ = Struct.new(:node, :original_type, :asserted_type, :location, keyword_init: true)
+        MethodCallContent = _ = Struct.new(:node, :method_call, :location, keyword_init: true)
+        DefinitionContent = _ = Struct.new(:node, :method_name, :method_type, :definition, :location, keyword_init: true)
+        ConstantContent = _ = Struct.new(:location, :full_name, :type, :decl, keyword_init: true) do
+          # @implements ConstantContent
+
+          def comments
+            case
+            when decl = class_decl
+              decl.decls.map {|d| d.decl.comment }
+            when decl = class_alias
+              [decl.decl.comment]
+            when decl = constant_decl
+              [decl.decl.comment]
+            else
+              raise
+            end.compact
+          end
+
+          def class_decl
+            case decl
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
+              decl
+            end
+          end
+
+          def class_alias
+            case decl
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
+              decl
+            end
+          end
+
+          def constant_decl
+            if decl.is_a?(::RBS::Environment::ConstantEntry)
+              decl
+            end
+          end
+
+          def constant?
+            constant_decl ? true : false
+          end
+
+          def class_or_module?
+            (class_decl || class_alias) ?  true : false
+          end
+        end
+
+        attr_reader :service
+
+        def initialize(service:)
+          @service = service
+        end
+
+        def project
+          service.project
+        end
+
+        def method_definition_for(factory, type_name, singleton_method: nil, instance_method: nil)
+          case
+          when instance_method
+            factory.definition_builder.build_instance(type_name).methods.fetch(instance_method)
+          when singleton_method
+            methods = factory.definition_builder.build_singleton(type_name).methods
+
+            if singleton_method == :new
+              methods[:new] || methods.fetch(:initialize)
+            else
+              methods.fetch(singleton_method)
+            end
+          else
+            raise "One of the instance_method or singleton_method is required"
+          end
+        end
+
+        def typecheck(target, path:, content:, line:, column:)
+          subtyping = service.signature_services.fetch(target.name).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)
+          pos = source.buffer.loc_to_pos([line, column])
+          Services::TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: pos)
+        rescue
+          nil
+        end
+
+        def method_name_from_method(context, builder:)
+          context.method or raise
+          defined_in = context.method.defined_in or raise
+          method_name = context.name or raise
+
+          case
+          when defined_in.class?
+            case
+            when builder.build_instance(defined_in).methods.key?(method_name)
+              InstanceMethodName.new(type_name: defined_in, method_name: method_name)
+            when builder.build_singleton(defined_in).methods.key?(method_name)
+              SingletonMethodName.new(type_name: defined_in, method_name: method_name)
+            else
+              raise
+            end
+          else
+            InstanceMethodName.new(type_name: defined_in, method_name: method_name)
+          end
+        end
+
+        def content_for(target:, path:, line:, column:)
+          file = service.source_files[path] or return
+          typing = typecheck(target, path: path, content: file.content, line: line, column: column) or return
+          node, *parents = typing.source.find_nodes(line: line, column: column)
+
+          if node && parents
+            case node.type
+            when :lvar
+              var_name = node.children[0]
+              context = typing.cursor_context.context or raise
+              var_type = context.type_env[var_name] || AST::Types::Any.instance()
+
+              return VariableContent.new(
+                node: node,
+                name: var_name,
+                type: var_type,
+                location: node.location.name # steep:ignore NoMethod
+              )
+
+            when :lvasgn
+              var_name, rhs = node.children
+              context = typing.cursor_context.context or raise
+              type = context.type_env[var_name] || typing.type_of(node: node)
+
+              return VariableContent.new(
+                node: node,
+                name: var_name,
+                type: type,
+                location: node.location.name # steep:ignore NoMethod
+              )
+
+            when :send, :csend
+              result_node =
+                case parents[0]&.type
+                when :block, :numblock
+                  if node == parents.fetch(0).children[0]
+                    parents.fetch(0)
+                  else
+                    node
+                  end
+                else
+                  node
+                end
+
+              case call = typing.call_of(node: result_node)
+              when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+                unless call.method_decls.empty?
+                  return MethodCallContent.new(
+                    node: result_node,
+                    method_call: call,
+                    location: node.location.selector # steep:ignore NoMethod
+                  )
+                end
+              end
+
+            when :def, :defs
+              context = typing.cursor_context.context or raise
+              method_context = context.method_context
+
+              if method_context && method_context.method
+                if method_context.method_type
+                  return DefinitionContent.new(
+                    node: node,
+                    method_name: method_name_from_method(method_context, builder: context.factory.definition_builder),
+                    method_type: method_context.method_type,
+                    definition: method_context.method,
+                    location: node.loc.name # steep:ignore NoMethod
+                  )
+                end
+              end
+
+            when :const, :casgn
+              context = typing.cursor_context.context or raise
+
+              type = typing.type_of(node: node)
+              const_name = typing.source_index.reference(constant_node: node)
+
+              if const_name
+                entry = context.env.constant_entry(const_name) or return
+
+                return ConstantContent.new(
+                  location: node.location.name, # steep:ignore NoMethod
+                  full_name: const_name,
+                  type: type,
+                  decl: entry
+                )
+              end
+            when :assertion
+              original_node, _ = node.children
+
+              original_type = typing.type_of(node: original_node)
+              asserted_type = typing.type_of(node: node)
+
+              if original_type != asserted_type
+                return TypeAssertionContent.new(node: node, original_type: original_type, asserted_type: asserted_type, location: node.location.expression)
+              end
+            end
+
+            TypeContent.new(
+              node: node,
+              type: typing.type_of(node: node),
+              location: node.location.expression
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Steep
+  module Services
+    module HoverProvider
+      module SingletonMethods
+        def content_for(service:, path:, line:, column:)
+          project = service.project
+
+          case
+          when target = project.target_for_source_path(path)
+            Ruby.new(service: service).content_for(target: target, path: path, line: line, column: column)
+          when target = project.target_for_signature_path(path)
+            RBS.new(service: service).content_for(target: target, path: path, line: line, column: column)
+          end
+        end
+      end
+
+      extend SingletonMethods
+    end
+  end
+end

data/lib/steep/services/path_assignment.rb

@@ -0,0 +1,46 @@
+module Steep
+  module Services
+    class PathAssignment
+      attr_reader :index, :max_index, :cache
+
+      def initialize(index:, max_index:)
+        @index = index
+        @max_index = max_index
+        @cache = {}
+      end
+
+      def self.all
+        new(index: 0, max_index: 1)
+      end
+
+      def =~(target_path)
+        key = stringify(target_path)
+        (cache[key] ||= self.class.index_for(key: key, max_index: max_index)) == index
+      end
+
+      alias === =~
+
+      def assign!(path, index)
+        key = stringify(path)
+        cache[key] = index
+        self
+      end
+
+      def stringify(target_path)
+        target =
+          case target_path[0]
+          when Project::Target
+            target_path[0].name.to_s
+          else
+            target_path[0].to_s
+          end
+        path = target_path[1].to_s
+        "#{target}::#{path}"
+      end
+
+      def self.index_for(key:, max_index:)
+        Digest::MD5.hexdigest(key).hex % max_index
+      end
+    end
+  end
+end

data/lib/steep/services/signature_help_provider.rb

@@ -0,0 +1,202 @@
+module Steep
+  module Services
+    class SignatureHelpProvider
+      MethodCall = TypeInference::MethodCall
+
+      Item = _ = Struct.new(:method_type, :comment, :active_parameter) do
+        # @implements Item
+
+        def parameters
+          if method_type.type.is_a?(RBS::Types::Function)
+            arguments = [] #: Array[String]
+            arguments.push(*method_type.type.required_positionals.map(&:to_s))
+            arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
+            arguments.push("*#{method_type.type.rest_positionals}") if method_type.type.rest_positionals
+            arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
+            arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
+            arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
+            arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
+            arguments
+          end
+        end
+      end
+
+      include NodeHelper
+
+      attr_reader :source, :path, :subtyping, :typing, :buffer
+
+      def env
+        subtyping.factory.env
+      end
+
+      def initialize(source:, subtyping:)
+        @source = source
+        @subtyping = subtyping
+        @buffer = source.buffer
+      end
+
+      def run(line:, column:)
+        nodes = source.find_nodes(line: line, column: column)
+
+        return unless nodes
+
+        typing = type_check!(line: line, column: column)
+        argument_nodes = [] #: Array[Parser::AST::Node]
+
+        while true
+          node = nodes.shift()
+          parent = nodes.first
+
+          node or return
+          argument_nodes << node
+
+          if node.type == :send || node.type == :csend
+            pos = buffer.loc_to_pos([line, column])
+            begin_loc = (_ = node.loc).begin #: Parser::Source::Range?
+            end_loc = (_ = node.loc).end #: Parser::Source::Range?
+
+            if begin_loc && end_loc
+              if begin_loc.end_pos <= pos && pos <= end_loc.begin_pos
+                # Given position is between open/close parens of args of send node
+
+                if parent && (parent.type == :block || parent.type == :numblock) && node.equal?(parent.children[0])
+                  send_node = parent
+                else
+                  send_node = node
+                end
+
+                last_argument_nodes = last_argument_nodes_for(argument_nodes: argument_nodes, line: line, column: column)
+                return signature_help_for(send_node, argument_nodes, last_argument_nodes, typing)
+              end
+            end
+          end
+        end
+      end
+
+      def type_check!(line:, column:)
+        source = self.source.without_unrelated_defs(line: line, column: column)
+        resolver = RBS::Resolver::ConstantResolver.new(builder: subtyping.factory.definition_builder)
+        pos = self.source.buffer.loc_to_pos([line, column])
+        TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver, cursor: pos)
+      end
+
+      def last_argument_nodes_for(argument_nodes:, line:, column:)
+        last = argument_nodes.last or raise
+        return unless last.children[2]  # No arguments
+        return argument_nodes if argument_nodes.size > 1  # Cursor is on the last argument
+
+        pos = buffer.loc_to_pos([line, column])
+
+        while true
+          pos -= 1
+          line, column = buffer.pos_to_loc(pos)
+          nodes = source.find_nodes(line: line, column: column)
+          return unless nodes
+
+          index = nodes.index { |n| n.type == :send || n.type == :csend }
+          return nodes[..index] if index.to_i > 0
+        end
+      end
+
+      def signature_help_for(node, argument, last_argument, typing)
+        call = typing.call_of(node: node)
+        context = typing.cursor_context.context or raise
+
+        items = [] #: Array[Item]
+        index = nil #: Integer?
+
+        case call
+        when MethodCall::Typed, MethodCall::Error
+          type = call.receiver_type
+          config = Interface::Builder::Config.new(self_type: context.self_type, variable_bounds: context.variable_context.upper_bounds)
+
+          if shape = subtyping.builder.shape(type, config)
+            shape = shape.public_shape if private_send?(node)
+
+            if method = shape.methods[call.method_name]
+              method.overloads.each.with_index do |overload, i|
+                defn = overload.method_defs[0]
+
+                active_parameter = active_parameter_for(defn&.type, argument, last_argument, node)
+                items << Item.new(subtyping.factory.method_type_1(overload.method_type), defn&.comment, active_parameter)
+
+                if call.is_a?(MethodCall::Typed)
+                  if call.method_decls.intersect?(overload.method_decls(call.method_name).to_set)
+                    index = i
+                  end
+                end
+              end
+            end
+          end
+        when MethodCall::Untyped, MethodCall::NoMethodError
+          return
+        end
+
+        [items, index]
+      end
+
+      def active_parameter_for(method_type, argument_nodes, last_argument_nodes, node)
+        return unless method_type
+        return unless method_type.type.is_a?(RBS::Types::Function)
+
+        positionals = method_type.type.required_positionals.size + method_type.type.optional_positionals.size + (method_type.type.rest_positionals ? 1 : 0) + method_type.type.trailing_positionals.size
+
+        if argument_nodes.size == 1
+          # Cursor is not on the argument (maybe on comma after argument)
+          return 0 if last_argument_nodes.nil?  # No arguments
+
+          case last_argument_nodes.fetch(-2).type
+          when :splat
+            method_type.type.required_positionals.size + method_type.type.optional_positionals.size + 1 if method_type.type.rest_positionals
+          when :kwargs
+            case last_argument_nodes.fetch(-3).type
+            when :pair
+              argname = last_argument_nodes.fetch(-3).children.first.children.first
+              if method_type.type.required_keywords.key?(argname)
+                positionals + method_type.type.required_keywords.keys.index(argname).to_i + 1
+              elsif method_type.type.optional_keywords.key?(argname)
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i + 1
+              elsif method_type.type.rest_keywords
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+              end
+            when :kwsplat
+              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
+            end
+          else
+            pos = (node.children[2...] || raise).index { |c| c.location == last_argument_nodes.fetch(-2).location }.to_i
+            if method_type.type.rest_positionals
+              [pos + 1, positionals - 1].min
+            else
+              [pos + 1, positionals].min
+            end
+          end
+        else
+          # Cursor is on the argument
+          case argument_nodes.fetch(-2).type
+          when :splat
+            method_type.type.required_positionals.size + method_type.type.optional_positionals.size if method_type.type.rest_positionals
+          when :kwargs
+            if argument_nodes[-3]
+              case argument_nodes.fetch(-3).type
+              when :pair
+                argname = argument_nodes.fetch(-3).children.first.children.first
+                if method_type.type.required_keywords.key?(argname)
+                  positionals + method_type.type.required_keywords.keys.index(argname).to_i
+                elsif method_type.type.optional_keywords.key?(argname)
+                  positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
+                elsif method_type.type.rest_keywords
+                  positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+                end
+              when :kwsplat
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
+              end
+            end
+          else
+            pos = (node.children[2...] || raise).index { |c| c.location == argument_nodes.fetch(-2).location }.to_i
+            [pos, positionals - 1].min
+          end
+        end
+      end
+    end
+  end
+end