steep 1.10.0 → 2.1.0.dev.1

data/lib/steep/locator.rb

@@ -0,0 +1,377 @@
+module Steep
+  class Locator
+    extend NodeHelper
+
+    module TypeNameLocator
+      def type_name_at(position, type)
+        buffer = type.location&.buffer or raise
+
+        locator = RBS::Locator.new(buffer: buffer, decls: [], dirs: [])
+        components = [] #: Array[RBS::Locator::component]
+
+        if locator.find_in_type(position, type: type, array: components)
+          symbol, type, * = components
+          if symbol.is_a?(Symbol)
+            case type
+            when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Alias, RBS::Types::Interface
+              if symbol == :name
+                type_loc = type.location or raise
+                name_loc = type.location[:name]
+                return [type.name, name_loc]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    NodeResult = Data.define(:node, :parents)
+
+    TypeAssertionResult = Data.define(:assertion, :node)
+
+    TypeApplicationResult = Data.define(:application, :node)
+
+    AnnotationResult = Data.define(:annotation, :node, :block)
+
+    CommentResult = Data.define(:comment, :node)
+
+    InlineAnnotationResult = Data.define(:annotation, :attached_ast)
+
+    InlineTypeResult = Data.define(:type, :annotation_result)
+
+    InlineTypeNameResult = Data.define(:type_name, :location, :enclosing_result)
+
+    class TypeAssertionResult
+      include TypeNameLocator
+
+      def locate_type_name(position, nesting, subtyping, type_vars)
+        if type = assertion.rbs_type(nesting, subtyping, type_vars)
+          location = type.location or raise
+          if location.start_pos <= position && position <= location.end_pos
+            if loc = type_name_at(position, type)
+              return loc
+            end
+          end
+        end
+      end
+    end
+
+    class TypeApplicationResult
+      include TypeNameLocator
+
+      def locate_type_name(position, nesting, subtyping, type_vars)
+        application.each_rbs_type(nesting, subtyping, type_vars) do |type|
+          location = type.location or raise
+          if location.start_pos <= position && position <= location.end_pos
+            if loc = type_name_at(position, type)
+              return loc
+            end
+          end
+        end
+
+        nil
+      end
+    end
+
+    class Ruby
+      include NodeHelper
+
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def find(line, column)
+        position = source.buffer.loc_to_pos([line, column])
+
+        if nodes = source.find_heredoc_nodes(line, column, position)
+          heredoc_node, *parent_nodes = nodes
+          heredoc_node or raise
+          each_child_node(heredoc_node) do |child_node|
+            if result = find_ruby_node_in(position, child_node, nodes)
+              return ruby_result_from_node(result, position)
+            end
+          end
+          return NodeResult.new(heredoc_node, parent_nodes)
+        end
+
+        if source.node && node = find_ruby_node_in(position, source.node, [])
+          ruby_result_from_node(node, position)
+        else
+          comment = source.comments.find { _1.location.expression.begin_pos <= position && position <= _1.location.expression.end_pos }
+          if comment
+            CommentResult.new(comment, nil)
+          end
+        end
+      end
+
+      def ruby_result_from_node(node, position)
+        case node.node.type
+        when :assertion
+          TypeAssertionResult.new(node.node.children[1], node)
+        when :tapp
+          application = node.node.children[1] #: AST::Node::TypeApplication
+          TypeApplicationResult.new(application, node)
+        else
+          comment = source.comments.find do
+            _1.location.expression.begin_pos <= position && position <= _1.location.expression.end_pos
+          end
+
+          if block_node = source.find_block_node([node.node, *node.parents])
+            source.each_block_annotation(block_node) do |annotation|
+              if location = annotation.location
+                if location.start_pos <= position && position <= location.end_pos
+                  return AnnotationResult.new(annotation, node, block_node)
+                end
+              end
+            end
+          end
+
+          if comment
+            return CommentResult.new(comment, NodeResult.new(node.node, node.parents))
+          end
+
+          node
+        end
+      end
+
+      def find_ruby_node_in(position, node, parents)
+        return unless node
+
+        range = node.location.expression&.to_range
+
+        return unless range
+
+        if range.begin <= position && position <= range.end
+          parents.unshift(node)
+          each_child_node(node) do |child|
+            if result = find_ruby_node_in(position, child, parents)
+              return result
+            end
+          end
+
+          parents.shift
+          return NodeResult.new(node, parents)
+        end
+      end
+    end
+
+    class Inline
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      def find(line, column)
+        position = source.buffer.loc_to_pos([line, column])
+
+        source.declarations.each do |decl|
+          if ast = find0(position, decl)
+            return inline_result(position, ast)
+          end
+        end
+
+        nil
+      end
+
+      def find0(position, ast)
+        case ast
+        when RBS::AST::Ruby::Declarations::ClassDecl
+          if ast.location.start_pos <= position && position <= ast.location.end_pos
+            # Check if position is within super class
+            if ast.super_class
+              if ast.super_class.location.start_pos <= position && position <= ast.super_class.location.end_pos
+                # Check if position is on type arguments
+                if ast.super_class.type_annotation
+                  if ast.super_class.type_annotation.location.start_pos <= position && position <= ast.super_class.type_annotation.location.end_pos
+                    return InlineAnnotationResult.new(ast.super_class.type_annotation, ast)
+                  end
+                end
+              end
+            end
+
+            ast.members.each do |member|
+              if sub = find0(position, member)
+                return sub
+              end
+            end
+          end
+        when RBS::AST::Ruby::Declarations::ModuleDecl
+          if ast.location.start_pos <= position && position <= ast.location.end_pos
+            ast.members.each do |member|
+              if sub = find0(position, member)
+                return sub
+              end
+            end
+          end
+        when RBS::AST::Ruby::Members::DefMember
+          case annotations = ast.method_type.type_annotations
+          when RBS::AST::Ruby::Members::MethodTypeAnnotation::DocStyle
+            if annotation = annotations.return_type_annotation
+              if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+                return InlineAnnotationResult.new(annotations.return_type_annotation, ast)
+              end
+            end
+          when Array
+            annotations.each do |annotation|
+              case annotation
+              when RBS::AST::Ruby::Annotations::ColonMethodTypeAnnotation
+                if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+                  return InlineAnnotationResult.new(annotation, ast)
+                end
+              when RBS::AST::Ruby::Annotations::MethodTypesAnnotation
+                if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+                  return InlineAnnotationResult.new(annotation, ast)
+                end
+              end
+            end
+          end
+        when RBS::AST::Ruby::Members::IncludeMember, RBS::AST::Ruby::Members::ExtendMember, RBS::AST::Ruby::Members::PrependMember
+          if ast.annotation.is_a?(RBS::AST::Ruby::Annotations::TypeApplicationAnnotation)
+            if ast.annotation.location.start_pos <= position && position <= ast.annotation.location.end_pos
+              return InlineAnnotationResult.new(ast.annotation, ast)
+            end
+          end
+        when RBS::AST::Ruby::Members::AttrReaderMember, RBS::AST::Ruby::Members::AttrWriterMember, RBS::AST::Ruby::Members::AttrAccessorMember
+          if annotation = ast.type_annotation
+            if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+              return InlineAnnotationResult.new(annotation, ast)
+            end
+          end
+        when RBS::AST::Ruby::Members::InstanceVariableMember
+          annotation = ast.annotation
+          if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+            return InlineAnnotationResult.new(annotation, ast)
+          end
+        when RBS::AST::Ruby::Declarations::ConstantDecl
+          if annotation = ast.type_annotation
+            if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+              return InlineAnnotationResult.new(annotation, ast)
+            end
+          end
+        when RBS::AST::Ruby::Declarations::ClassModuleAliasDecl
+          if annotation = ast.annotation
+            if annotation.location.start_pos <= position && position <= annotation.location.end_pos
+              return InlineAnnotationResult.new(annotation, ast)
+            end
+          end
+        end
+
+        nil
+      end
+
+      def inline_result(position, result)
+        type_result = nil #: InlineTypeResult?
+
+        case result.annotation
+        when RBS::AST::Ruby::Annotations::ReturnTypeAnnotation
+          if type_location = result.annotation.return_type.location
+            if type_location.start_pos <= position && position <= type_location.end_pos
+              type_result = InlineTypeResult.new(result.annotation.return_type, result)
+            end
+          end
+        when RBS::AST::Ruby::Annotations::ColonMethodTypeAnnotation
+          type = result.annotation.method_type.each_type.find do |type|
+            if type_location = type.location
+              type_location.start_pos <= position && position <= type_location.end_pos
+            end
+          end
+
+          if type
+            type_result = InlineTypeResult.new(type, result)
+          end
+        when RBS::AST::Ruby::Annotations::MethodTypesAnnotation
+          overload = result.annotation.overloads.find do
+            if location = _1.method_type.location
+              location.start_pos <= position && position <= location.end_pos
+            end
+          end
+
+          if overload
+            type = overload.method_type.each_type.find do |type|
+              if type_location = type.location
+                type_location.start_pos <= position && position <= type_location.end_pos
+              end
+            end
+
+            if type
+              type_result = InlineTypeResult.new(type, result)
+            end
+          end
+        when RBS::AST::Ruby::Annotations::TypeApplicationAnnotation
+          # Find type argument that contains the position
+          type = result.annotation.type_args.find do |type_arg|
+            if type_location = type_arg.location
+              type_location.start_pos <= position && position <= type_location.end_pos
+            end
+          end
+
+          if type
+            type_result = InlineTypeResult.new(type, result)
+          end
+        when RBS::AST::Ruby::Annotations::NodeTypeAssertion
+          # Handle type annotations for attr_reader/writer/accessor
+          if type_location = result.annotation.type.location
+            if type_location.start_pos <= position && position <= type_location.end_pos
+              type_result = InlineTypeResult.new(result.annotation.type, result)
+            end
+          end
+        when RBS::AST::Ruby::Annotations::InstanceVariableAnnotation
+          # Handle type annotations for instance variables
+          if type_location = result.annotation.type.location
+            if type_location.start_pos <= position && position <= type_location.end_pos
+              type_result = InlineTypeResult.new(result.annotation.type, result)
+            end
+          end
+        when RBS::AST::Ruby::Annotations::ClassAliasAnnotation, RBS::AST::Ruby::Annotations::ModuleAliasAnnotation
+          # Handle class-alias and module-alias annotations with explicit type names
+          if result.annotation.type_name && result.annotation.type_name_location
+            if result.annotation.type_name_location.start_pos <= position && position <= result.annotation.type_name_location.end_pos
+              return InlineTypeNameResult.new(
+                result.annotation.type_name,
+                result.annotation.type_name_location,
+                result
+              )
+            end
+          end
+        end
+
+        if type_result
+          type_name_result(position, type_result)
+        else
+          result
+        end
+      end
+
+      def type_name_result(position, result)
+        locator = RBS::Locator.new(buffer: source.buffer, decls: [], dirs: [])
+        components = [] #: Array[RBS::Locator::component]
+
+        if locator.find_in_type(position, type: result.type, array: components)
+          symbol, type, * = components
+          if symbol.is_a?(Symbol)
+            type_name = nil #: RBS::TypeName?
+            location = nil #: RBS::Location?
+
+            case type
+            when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Alias, RBS::Types::Interface
+              if symbol == :name
+                type_loc = type.location or raise
+                type_name = type.name
+                location = type_loc[:name] or raise
+              end
+            end
+
+            if type_name && location
+              return InlineTypeNameResult.new(type_name, location, result)
+            end
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/steep/node_helper.rb

@@ -220,7 +220,7 @@ module Steep
 
     def private_send?(node)
       case node.type
-      when :block, :numblock
+      when :block, :numblock, :itblock
         private_send?(node.children[0])
       when :send, :csend
         receiver, = deconstruct_send_node!(node)
@@ -243,7 +243,7 @@ module Steep
         when :send, :csend, :super
           if block_node
             case block_node.type
-            when :block, :numblock
+            when :block, :numblock, :itblock
               if send_node.equal?(block_node.children[0])
                 return [send_node, block_node]
               end

data/lib/steep/project/dsl.rb

@@ -70,12 +70,20 @@ module Steep
       end
 
       module WithPattern
-        def check(*args)
-          sources.concat(args)
+        def check(*args, inline: false)
+          if inline
+            inline_sources.concat(args)
+          else
+            sources.concat(args)
+          end
         end
 
-        def ignore(*args)
-          ignored_sources.concat(args)
+        def ignore(*args, inline: false)
+          if inline
+            ignored_inline_sources.concat(args)
+          else
+            ignored_sources.concat(args)
+          end
         end
 
         def signature(*args)
@@ -94,6 +102,14 @@ module Steep
           @ignored_sources ||= []
         end
 
+        def inline_sources
+          @inline_sources ||= []
+        end
+
+        def ignored_inline_sources
+          @ignored_inline_sources ||= []
+        end
+
         def signatures
           @signatures ||= []
         end
@@ -109,6 +125,10 @@ module Steep
         def signature_pattern
           Pattern.new(patterns: signatures, ignores: ignored_signatures, ext: ".rbs")
         end
+
+        def inline_source_pattern
+          Pattern.new(patterns: inline_sources, ignores: ignored_inline_sources, ext: ".rb")
+        end
       end
 
       class TargetDSL
@@ -248,6 +268,7 @@ module Steep
         target = Project::Target.new(
           name: dsl.name,
           source_pattern: dsl.source_pattern,
+          inline_source_pattern: dsl.inline_source_pattern,
           signature_pattern: dsl.signature_pattern,
           options: dsl.library_configured? ? dsl.to_library_options : nil,
           code_diagnostics_config: dsl.code_diagnostics_config,
@@ -257,7 +278,7 @@ module Steep
         )
 
         dsl.groups.each do
-          group = Group.new(target, _1.name, _1.source_pattern, _1.signature_pattern, _1.code_diagnostics_config || target.code_diagnostics_config)
+          group = Group.new(target, _1.name, _1.source_pattern, _1.inline_source_pattern, _1.signature_pattern, _1.code_diagnostics_config || target.code_diagnostics_config)
           target.groups << group
         end
 

data/lib/steep/project/group.rb

@@ -3,14 +3,16 @@ module Steep
     class Group
       attr_reader :name
       attr_reader :source_pattern
+      attr_reader :inline_source_pattern
       attr_reader :signature_pattern
       attr_reader :target
       attr_reader :code_diagnostics_config
 
-      def initialize(target, name, source_pattern, signature_pattern, code_diagnostics_config)
+      def initialize(target, name, source_pattern, inline_source_pattern, signature_pattern, code_diagnostics_config)
         @target = target
         @name = name
         @source_pattern = source_pattern
+        @inline_source_pattern = inline_source_pattern
         @signature_pattern = signature_pattern
         @code_diagnostics_config = code_diagnostics_config
       end
@@ -20,12 +22,16 @@ module Steep
       end
 
       def possible_source_file?(path)
-        source_pattern =~ path
+        source_pattern =~ path && inline_source_pattern !~ path
       end
 
       def possible_signature_file?(path)
         signature_pattern =~ path
       end
+
+      def possible_inline_source_file?(path)
+        inline_source_pattern =~ path
+      end
     end
   end
 end

data/lib/steep/project/target.rb

@@ -6,16 +6,18 @@ module Steep
 
       attr_reader :source_pattern
       attr_reader :signature_pattern
+      attr_reader :inline_source_pattern
       attr_reader :code_diagnostics_config
       attr_reader :project
       attr_reader :unreferenced
       attr_reader :groups
       attr_reader :implicitly_returns_nil
 
-      def initialize(name:, options:, source_pattern:, signature_pattern:, code_diagnostics_config:, project:, unreferenced:, implicitly_returns_nil:)
+      def initialize(name:, options:, source_pattern:, inline_source_pattern:, signature_pattern:, code_diagnostics_config:, project:, unreferenced:, implicitly_returns_nil:)
         @name = name
         @target_options = options
         @source_pattern = source_pattern
+        @inline_source_pattern = inline_source_pattern
         @signature_pattern = signature_pattern
         @code_diagnostics_config = code_diagnostics_config
         @project = project
@@ -33,7 +35,7 @@ module Steep
           return target
         end
 
-        if source_pattern =~ path
+        if source_pattern =~ path && inline_source_pattern !~ path
           return self
         end
 
@@ -52,6 +54,18 @@ module Steep
         nil
       end
 
+      def possible_inline_source_file?(path)
+        if group = groups.find { _1.possible_inline_source_file?(path) }
+          return group
+        end
+
+        if inline_source_pattern =~ path
+          return self
+        end
+
+        nil
+      end
+
       def new_env_loader()
         Target.construct_env_loader(options: options, project: project)
       end

data/lib/steep/project.rb

@@ -41,7 +41,7 @@ module Steep
     end
 
     def group_for_path(path)
-      group_for_source_path(path) || group_for_signature_path(path)
+      group_for_source_path(path) || group_for_signature_path(path) || group_for_inline_source_path(path)
     end
 
     def group_for_signature_path(path)
@@ -53,6 +53,16 @@ module Steep
       nil
     end
 
+    def group_for_inline_source_path(path)
+      relative = relative_path(path)
+      targets.each do
+        ret = _1.possible_inline_source_file?(relative)
+        return ret if ret
+      end
+
+      nil
+    end
+
     def target_for_source_path(path)
       case group = group_for_source_path(path)
       when Target
@@ -71,8 +81,17 @@ module Steep
       end
     end
 
+    def target_for_inline_source_path(path)
+      case group = group_for_inline_source_path(path)
+      when Target
+        group
+      when Group
+        group.target
+      end
+    end
+
     def target_for_path(path)
-      target_for_source_path(path) || target_for_signature_path(path)
+      target_for_source_path(path) || target_for_signature_path(path) || target_for_inline_source_path(path)
     end
   end
 end

data/lib/steep/server/base_worker.rb

@@ -38,11 +38,11 @@ module Steep
       end
 
       def run
-        tags = Steep.logger.formatter.current_tags.dup
+        tags = Steep.logger.current_tags.dup
         thread = Thread.new do
           Thread.current.abort_on_exception = true
 
-          Steep.logger.formatter.push_tags(*tags)
+          Steep.logger.push_tags(*tags)
           Steep.logger.tagged "background" do
             while job = queue.pop
               case job

data/lib/steep/server/change_buffer.rb

@@ -29,7 +29,8 @@ module Steep
           push_buffer do |changes|
             input.each do |filename, content|
               if content.is_a?(Hash)
-                content = Base64.decode64(content[:text]).force_encoding(Encoding::UTF_8)
+                base64_decoded = content[:text].unpack1("m") #: String
+                content = base64_decoded.force_encoding(Encoding::UTF_8)
               end
               changes[Pathname(filename.to_s)] = [Services::ContentChange.new(text: content)]
             end

data/lib/steep/server/custom_methods.rb

@@ -84,6 +84,18 @@ module Steep
           { id: id, result: result }
         end
       end
+
+      module Query__Definition
+        METHOD = "$/steep/query/definition"
+
+        def self.request(id, params)
+          { method: METHOD, id: id, params: params }
+        end
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
     end
   end
 end