steep-relaxed 1.9.3.3

data/lib/steep/index/rbs_index.rb

@@ -0,0 +1,350 @@
+module Steep
+  module Index
+    class RBSIndex
+      class TypeEntry
+        attr_reader :type_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(type_name:)
+          @type_name = type_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+            declarations << decl
+          when RBS::AST::Declarations::Interface
+            declarations << decl
+          when RBS::AST::Declarations::TypeAlias
+            declarations << decl
+          when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
+            declarations << decl
+          else
+            raise "Unexpected type declaration: #{decl}"
+          end
+
+          self
+        end
+
+        def add_reference(ref)
+          case ref
+          when RBS::AST::Members::MethodDefinition
+            references << ref
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            references << ref
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassInstanceVariable, RBS::AST::Members::ClassVariable
+            references << ref
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            references << ref
+          when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+            references << ref
+          when RBS::AST::Declarations::Constant, RBS::AST::Declarations::Global
+            references << ref
+          when RBS::AST::Declarations::TypeAlias
+            references << ref
+          when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
+            references << ref
+          else
+            raise "Unexpected type reference: #{ref}"
+          end
+
+          self
+        end
+      end
+
+      class MethodEntry
+        attr_reader :method_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(method_name:)
+          @method_name = method_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Members::MethodDefinition,
+            RBS::AST::Members::Alias,
+            RBS::AST::Members::AttrWriter,
+            RBS::AST::Members::AttrReader,
+            RBS::AST::Members::AttrAccessor
+            declarations << decl
+          else
+            raise "Unexpected method declaration: #{decl}"
+          end
+
+          self
+        end
+      end
+
+      class ConstantEntry
+        attr_reader :const_name
+        attr_reader :declarations
+
+        def initialize(const_name:)
+          @const_name = const_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Constant
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      class GlobalEntry
+        attr_reader :global_name
+        attr_reader :declarations
+
+        def initialize(global_name:)
+          @global_name = global_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Global
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      attr_reader :type_index
+      attr_reader :method_index
+      attr_reader :const_index
+      attr_reader :global_index
+
+      def initialize()
+        @type_index = {}
+        @method_index = {}
+        @const_index = {}
+        @global_index = {}
+      end
+
+      def entry(type_name: nil, method_name: nil, const_name: nil, global_name: nil)
+        case
+        when type_name
+          type_index[type_name] ||= TypeEntry.new(type_name: type_name)
+        when method_name
+          method_index[method_name] ||= MethodEntry.new(method_name: method_name)
+        when const_name
+          const_index[const_name] ||= ConstantEntry.new(const_name: const_name)
+        when global_name
+          global_index[global_name] ||= GlobalEntry.new(global_name: global_name)
+        else
+          raise
+        end
+      end
+
+      def each_entry(&block)
+        if block
+          type_index.each_value(&block)
+          method_index.each_value(&block)
+          const_index.each_value(&block)
+          global_index.each_value(&block)
+        else
+          enum_for(:each_entry)
+        end
+      end
+
+      def add_type_declaration(type_name, declaration)
+        entry(type_name: type_name).add_declaration(declaration)
+      end
+
+      def add_method_declaration(method_name, member)
+        entry(method_name: method_name).add_declaration(member)
+      end
+
+      def add_constant_declaration(const_name, decl)
+        entry(const_name: const_name).add_declaration(decl)
+      end
+
+      def add_global_declaration(global_name, decl)
+        entry(global_name: global_name).add_declaration(decl)
+      end
+
+      def each_declaration(type_name: nil, method_name: nil, const_name: nil, global_name: nil, &block)
+        if block
+          entry = __skip__ = entry(type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+          entry.declarations.each(&block)
+        else
+          enum_for(:each_declaration, type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+        end
+      end
+
+      def add_type_reference(type_name, ref)
+        entry(type_name: type_name).add_reference(ref)
+      end
+
+      def each_reference(type_name:, &block)
+        if block
+          case
+          when type_name
+            entry(type_name: type_name).references.each(&block)
+          end
+        else
+          enum_for(:each_reference, type_name: type_name)
+        end
+      end
+
+      class Builder
+        attr_reader :index
+
+        def initialize(index:)
+          @index = index
+        end
+
+        def member(type_name, member)
+          case member
+          when RBS::AST::Members::MethodDefinition
+            member.overloads.each do |overload|
+              overload.method_type.each_type do |type|
+                type_reference type, from: member
+              end
+            end
+
+            if member.instance?
+              method_name = InstanceMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.singleton?
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            type_reference member.type, from: member
+
+            if member.is_a?(RBS::AST::Members::AttrReader) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: member.name)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: member.name)
+                            else
+                              raise
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.is_a?(RBS::AST::Members::AttrWriter) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            else
+                              raise
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassVariable, RBS::AST::Members::ClassInstanceVariable
+            type_reference member.type, from: member
+
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            index.add_type_reference member.name, member
+            member.args.each do |type|
+              type_reference type, from: member
+            end
+
+          when RBS::AST::Members::Alias
+            if member.instance?
+              new_name = InstanceMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+
+            if member.singleton?
+              new_name = SingletonMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+          end
+        end
+
+        def type_reference(type, from:)
+          case type
+          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Alias, RBS::Types::Interface
+            index.add_type_reference(type.name, from)
+          end
+
+          type.each_type do |ty|
+            type_reference ty, from: from
+          end
+        end
+
+        def env(env)
+          env.class_decls.each do |name, decl|
+            decl.decls.each do |d|
+              index.add_type_declaration(name, d.decl)
+
+              case d.decl
+              when RBS::AST::Declarations::Class
+                if super_class = d.decl.super_class
+                  index.add_type_reference(super_class.name, d.decl)
+                  super_class.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              when RBS::AST::Declarations::Module
+                d.decl.self_types.each do |self_type|
+                  index.add_type_reference(self_type.name, d.decl)
+                  self_type.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              end
+
+              d.decl.members.each do |member|
+                member(name, member)
+              end
+            end
+          end
+
+          env.class_alias_decls.each do |name, entry|
+            index.add_type_declaration(name, entry.decl)
+            index.add_type_reference(entry.decl.old_name, entry.decl)
+          end
+
+          env.interface_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+
+            decl.decl.members.each do |member|
+              member(name, member)
+            end
+          end
+
+          env.type_alias_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.constant_decls.each do |name, decl|
+            index.add_constant_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.global_decls.each do |name, decl|
+            index.add_global_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+        end
+      end
+    end
+  end
+end

data/lib/steep/index/signature_symbol_provider.rb

@@ -0,0 +1,185 @@
+module Steep
+  module Index
+    class SignatureSymbolProvider
+      LSP = LanguageServer::Protocol
+
+      class SymbolInformation < Struct.new(:name, :kind, :container_name, :location, keyword_init: true)
+      end
+
+      attr_reader :project
+      attr_reader :indexes
+      attr_reader :assignment
+
+      def initialize(project:, assignment:)
+        @indexes = {}
+        @project = project
+        @assignment = assignment
+      end
+
+      def self.test_type_name(query, type_name)
+        case
+        when query == ""
+          true
+        else
+          type_name.to_s.upcase.include?(query.upcase)
+        end
+      end
+
+      class <<self
+        alias test_const_name test_type_name
+        alias test_global_name test_type_name
+      end
+
+      def self.test_method_name(query, method_name)
+        case
+        when query == ""
+          true
+        else
+          method_name.to_s.upcase.include?(query.upcase)
+        end
+      end
+
+      def assigned?(target, path)
+        if path.relative?
+          if project.targets.any? {|target| target.possible_signature_file?(path) }
+            path = project.absolute_path(path)
+          end
+        end
+
+        assignment =~ [target, path]
+      end
+
+      def query_symbol(query)
+        symbols = [] #: Array[SymbolInformation]
+
+        indexes.each do |target, index|
+          index.each_entry do |entry|
+            case entry
+            when RBSIndex::TypeEntry
+              next unless SignatureSymbolProvider.test_type_name(query, entry.type_name)
+
+              container_name = entry.type_name.namespace.relative!.to_s.delete_suffix("::")
+              name = entry.type_name.name.to_s
+
+              entry.declarations.each do |decl|
+                location = decl.location or next
+                next unless assigned?(target, Pathname(location.buffer.name))
+
+                case decl
+                when RBS::AST::Declarations::Class
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::CLASS,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Module
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::MODULE,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::Interface
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::INTERFACE,
+                    container_name: container_name
+                  )
+                when RBS::AST::Declarations::TypeAlias
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::ENUM,
+                    container_name: container_name
+                  )
+                end
+              end
+            when RBSIndex::MethodEntry
+              next unless SignatureSymbolProvider.test_method_name(query, entry.method_name)
+
+              name = case entry.method_name
+                     when InstanceMethodName
+                       "##{entry.method_name.method_name}"
+                     when SingletonMethodName
+                       ".#{entry.method_name.method_name}"
+                     else
+                       raise
+                     end
+              container_name = entry.method_name.type_name.relative!.to_s
+
+              entry.declarations.each do |decl|
+                location = decl.location or next
+                next unless assigned?(target, Pathname(location.buffer.name))
+
+                case decl
+                when RBS::AST::Members::MethodDefinition
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
+                when RBS::AST::Members::Alias
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
+                when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::PROPERTY,
+                    container_name: container_name
+                  )
+
+                  if decl.ivar_name
+                    symbols << SymbolInformation.new(
+                      name: decl.ivar_name.to_s,
+                      location: location,
+                      kind: LSP::Constant::SymbolKind::FIELD,
+                      container_name: container_name
+                    )
+                  end
+                end
+              end
+            when RBSIndex::ConstantEntry
+              next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
+
+              entry.declarations.each do |decl|
+                next unless decl.location
+                next unless assigned?(target, Pathname(decl.location.buffer.name))
+
+                symbols << SymbolInformation.new(
+                  name: entry.const_name.name.to_s,
+                  location: decl.location,
+                  kind: LSP::Constant::SymbolKind::CONSTANT,
+                  container_name: entry.const_name.namespace.relative!.to_s.delete_suffix("::")
+                )
+              end
+            when RBSIndex::GlobalEntry
+              next unless SignatureSymbolProvider.test_global_name(query, entry.global_name)
+
+              entry.declarations.each do |decl|
+                next unless decl.location
+                next unless assigned?(target, Pathname(decl.location.buffer.name))
+
+                symbols << SymbolInformation.new(
+                  name: decl.name.to_s,
+                  location: decl.location,
+                  kind: LSP::Constant::SymbolKind::VARIABLE,
+                  container_name: nil
+                )
+              end
+            end
+          end
+        end
+
+        symbols.uniq {|symbol| [symbol.name, symbol.location] }.sort_by {|symbol| symbol.name.to_s }
+      end
+    end
+  end
+end

data/lib/steep/index/source_index.rb

@@ -0,0 +1,167 @@
+module Steep
+  module Index
+    class SourceIndex
+      class ConstantEntry
+        attr_reader :name
+
+        attr_reader :definitions
+        attr_reader :references
+
+        def initialize(name:)
+          @name = name
+
+          @definitions = Set[].compare_by_identity
+          @references = Set[].compare_by_identity
+        end
+
+        def add_definition(node)
+          case node.type
+          when :casgn, :const
+            @definitions << node
+          else
+            raise "Unexpected constant definition: #{node.type}"
+          end
+
+          self
+        end
+
+        def add_reference(node)
+          case node.type
+          when :const
+            @references << node
+          else
+            raise "Unexpected constant reference: #{node.type}"
+          end
+
+          self
+        end
+
+        def merge!(other)
+          definitions.merge(other.definitions)
+          references.merge(other.references)
+          self
+        end
+      end
+
+      class MethodEntry
+        attr_reader :name
+
+        attr_reader :definitions
+        attr_reader :references
+
+        def initialize(name:)
+          @name = name
+
+          @definitions = Set[].compare_by_identity
+          @references = Set[].compare_by_identity
+        end
+
+        def add_definition(node)
+          case node.type
+          when :def, :defs
+            @definitions << node
+          else
+            raise "Unexpected method definition: #{node.type}"
+          end
+
+          self
+        end
+
+        def add_reference(node)
+          case node.type
+          when :send, :block
+            @references << node
+          else
+            raise "Unexpected method reference: #{node.type}"
+          end
+
+          self
+        end
+
+        def merge!(other)
+          definitions.merge(other.definitions)
+          references.merge(other.references)
+          self
+        end
+      end
+
+      attr_reader :source
+      attr_reader :constant_index
+      attr_reader :method_index
+
+      attr_reader :parent
+      attr_reader :count
+      attr_reader :parent_count
+
+      def initialize(source:, parent: nil)
+        @source = source
+        @parent = parent
+        @parent_count = parent&.count
+
+        @count = @parent_count || 0
+
+        @constant_index = {}
+        @method_index = {}
+      end
+
+      def new_child
+        SourceIndex.new(source: source, parent: self)
+      end
+
+      def merge!(child)
+        raise unless child.parent == self
+        raise unless child.parent_count == count
+
+        constant_index.merge!(child.constant_index) do |_, entry, child_entry|
+          entry.merge!(child_entry)
+        end
+
+        method_index.merge!(child.method_index) do |_, entry, child_entry|
+          entry.merge!(child_entry)
+        end
+
+        @count = child.count + 1
+      end
+
+      def add_definition(constant: nil, method: nil, definition:)
+        @count += 1
+        entry(constant: constant, method: method).add_definition(definition)
+        self
+      end
+
+      def add_reference(constant: nil, method: nil, ref:)
+        @count += 1
+        entry(constant: constant, method: method).add_reference(ref)
+        self
+      end
+
+      def entry(constant: nil, method: nil)
+        case
+        when constant
+          constant_index[constant] ||= ConstantEntry.new(name: constant)
+        when method
+          method_index[method] ||= MethodEntry.new(name: method)
+        else
+          raise
+        end
+      end
+
+      def reference(constant_node: nil)
+        case
+        when constant_node
+          constant_index.each do |name, entry|
+            if entry.references.include?(constant_node)
+              return name
+            end
+
+            if entry.definitions.include?(constant_node)
+              return name
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end