steep 1.4.0.dev.1 → 1.4.0.dev.3

data/lib/steep/interface/block.rb

@@ -69,6 +69,16 @@ module Steep
         )
       end
 
+      def to_proc_type
+        proc = AST::Types::Proc.new(type: type, self_type: self_type, block: nil)
+
+        if optional?
+          AST::Types::Union.build(types: [proc, AST::Builtin.nil_type])
+        else
+          proc
+        end
+      end
+
       def +(other)
         optional = self.optional? || other.optional?
         type = Function.new(

data/lib/steep/module_helper.rb

@@ -1,21 +1,23 @@
 module Steep
   module ModuleHelper
     def module_name_from_node(parent_node, constant_name)
-      namespace = namespace_from_node(parent_node) or return
-      name = constant_name
-      RBS::TypeName.new(name: name, namespace: namespace)
+      if namespace = namespace_from_node(parent_node)
+        RBS::TypeName.new(name: constant_name, namespace: namespace)
+      end
     end
 
     def namespace_from_node(node)
-      case node&.type
-      when nil
-        RBS::Namespace.empty
-      when :cbase
-        RBS::Namespace.root
-      when :const
-        namespace_from_node(node.children[0])&.yield_self do |parent|
-          parent.append(node.children[1])
+      if node
+        case node.type
+        when :cbase
+          RBS::Namespace.root
+        when :const
+          if parent = namespace_from_node(node.children[0])
+            parent.append(node.children[1])
+          end
         end
+      else
+        RBS::Namespace.empty
       end
     end
   end

data/lib/steep/path_helper.rb

@@ -11,6 +11,10 @@ module Steep
       end
     end
 
+    def to_pathname!(uri, dosish: Gem.win_platform?)
+      to_pathname(uri, dosish: dosish) or raise "Cannot translate a URI to pathname: #{uri}"
+    end
+
     def to_uri(path, dosish: Gem.win_platform?)
       str_path = path.to_s
       if dosish

data/lib/steep/project/target.rb

@@ -14,9 +14,6 @@ module Steep
         @source_pattern = source_pattern
         @signature_pattern = signature_pattern
         @code_diagnostics_config = code_diagnostics_config
-
-        @source_files = {}
-        @signature_files = {}
       end
 
       def possible_source_file?(path)
@@ -55,6 +52,7 @@ module Steep
 
         options.libraries.each do |lib|
           name, version = lib.split(/:/, 2)
+          name or raise
           loader.add(library: name, version: version)
         end
         loader.add_collection(options.collection_lock) if options.collection_lock

data/lib/steep/server/interaction_worker.rb

@@ -3,9 +3,9 @@ module Steep
     class InteractionWorker < BaseWorker
       include ChangeBuffer
 
-      ApplyChangeJob = Class.new()
-      HoverJob = Struct.new(:id, :path, :line, :column, keyword_init: true)
-      CompletionJob = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
+      ApplyChangeJob = _ = Class.new()
+      HoverJob = _ = Struct.new(:id, :path, :line, :column, keyword_init: true)
+      CompletionJob = _ = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
 
       LSP = LanguageServer::Protocol
 
@@ -53,7 +53,7 @@ module Steep
         when "textDocument/hover"
           id = request[:id]
 
-          path = project.relative_path(Steep::PathHelper.to_pathname(request[:params][:textDocument][:uri]))
+          path = project.relative_path(Steep::PathHelper.to_pathname!(request[:params][:textDocument][:uri]))
           line = request[:params][:position][:line]+1
           column = request[:params][:position][:character]
 
@@ -63,7 +63,8 @@ module Steep
           id = request[:id]
 
           params = request[:params]
-          path = project.relative_path(Steep::PathHelper.to_pathname(params[:textDocument][:uri]))
+
+          path = project.relative_path(Steep::PathHelper.to_pathname!(params[:textDocument][:uri]))
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
           trigger = params.dig(:context, :triggerCharacter)
 
@@ -104,6 +105,7 @@ module Steep
         Steep.logger.tagged("#response_to_completion") do
           Steep.measure "Generating response" do
             Steep.logger.info "path: #{job.path}, line: #{job.line}, column: #{job.column}, trigger: #{job.trigger}"
+
             case
             when target = project.target_for_source_path(job.path)
               file = service.source_files[job.path] or return
@@ -127,53 +129,78 @@ module Steep
                 items: completion_items
               )
             when (targets = project.targets_for_path(job.path)).is_a?(Array)
-              target = targets[0] or return
-              sig_service = service.signature_services[target.name]
+              target = targets[0] or raise
+              sig_service = service.signature_services[target.name] or raise
               relative_path = job.path
-              buffer = RBS::Buffer.new(name: relative_path, content: sig_service.files[relative_path].content)
-              pos = buffer.loc_to_pos([job.line, job.column])
-              prefix = buffer.content[0...pos].reverse[/\A[\w\d]*/].reverse
+
+              context = nil #: RBS::Resolver::context
 
               case sig_service.status
               when Steep::Services::SignatureService::SyntaxErrorStatus, Steep::Services::SignatureService::AncestorErrorStatus
-                return
-              end
-
-              decls = sig_service.files[relative_path].decls
-              locator = RBS::Locator.new(decls: decls)
-
-              _hd, tail = locator.find2(line: job.line, column: job.column)
 
-              namespace = []
-              tail.each do |t|
-                case t
-                when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
-                  namespace << t.name.to_namespace
+                if buffer = sig_service.latest_env.buffers.find {|buf| Pathname(buf.name) == Pathname(relative_path) }
+                  dirs = sig_service.latest_env.signatures[buffer][0]
+                else
+                  dirs = [] #: Array[RBS::AST::Directives::t]
+                end
+              else
+                signature = sig_service.files[relative_path].signature
+                signature.is_a?(Array) or raise
+                buffer, dirs, decls = signature
+
+                locator = RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
+
+                _hd, tail = locator.find2(line: job.line, column: job.column)
+                tail ||= []
+
+                tail.reverse_each do |t|
+                  case t
+                  when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+                    if (last_type_name = context&.[](1)).is_a?(RBS::TypeName)
+                      context = [context, last_type_name + t.name]
+                    else
+                      context = [context, t.name.absolute!]
+                    end
+                  end
                 end
               end
-              context = []
 
-              namespace.each do |ns|
-                context.map! { |n| ns + n }
-                context << ns
+              buffer = RBS::Buffer.new(name: relative_path, content: sig_service.files[relative_path].content)
+              prefix = Services::TypeNameCompletion::Prefix.parse(buffer, line: job.line, column: job.column)
+
+              completion = Services::TypeNameCompletion.new(env: sig_service.latest_env, context: context, dirs: dirs)
+              type_names = completion.find_type_names(prefix)
+              prefix_size = prefix ? prefix.size : 0
+
+              completion_items = type_names.map {|type_name|
+                absolute_name, relative_name = completion.resolve_name_in_context(type_name)
+
+                format_completion_item_for_rbs(sig_service, absolute_name, job, relative_name.to_s, prefix_size)
+              }
+
+              ["untyped", "void", "bool", "class", "module", "instance", "nil"].each do |name|
+                completion_items << LanguageServer::Protocol::Interface::CompletionItem.new(
+                  label: name,
+                  detail: "(builtin type)",
+                  text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+                    range: LanguageServer::Protocol::Interface::Range.new(
+                      start: LanguageServer::Protocol::Interface::Position.new(
+                        line: job.line - 1,
+                        character: job.column - prefix_size
+                      ),
+                      end: LanguageServer::Protocol::Interface::Position.new(
+                        line: job.line - 1,
+                        character: job.column
+                      )
+                    ),
+                    new_text: name
+                  ),
+                  kind: LSP::Constant::CompletionItemKind::KEYWORD,
+                  filter_text: name,
+                  sort_text: "zz__#{name}"
+                )
               end
 
-              context.map!(&:absolute!)
-
-              class_items = sig_service.latest_env.class_decls.keys.map { |type_name|
-                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
-              }.compact
-
-              alias_items = sig_service.latest_env.alias_decls.keys.map { |type_name|
-                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
-              }.compact
-
-              interface_items = sig_service.latest_env.interface_decls.keys.map {|type_name|
-                format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
-              }.compact
-
-              completion_items = class_items + alias_items + interface_items
-
               LSP::Interface::CompletionList.new(
                 is_incomplete: false,
                 items: completion_items
@@ -183,11 +210,11 @@ module Steep
         end
       end
 
-      def format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
+      def format_completion_item_for_rbs(sig_service, type_name, job, complete_text, prefix_size)
         range = LanguageServer::Protocol::Interface::Range.new(
           start: LanguageServer::Protocol::Interface::Position.new(
             line: job.line - 1,
-            character: job.column - prefix.size
+            character: job.column - prefix_size
           ),
           end: LanguageServer::Protocol::Interface::Position.new(
             line: job.line - 1,
@@ -195,50 +222,64 @@ module Steep
           )
         )
 
-        name = relative_name_in_context(type_name, context).to_s
-
-        return unless name.start_with?(prefix)
-
         case type_name.kind
         when :class
-          class_decl = sig_service.latest_env.class_decls[type_name]&.decls[0]&.decl or raise
+          env = sig_service.latest_env #: RBS::Environment
+          class_entry = env.module_class_entry(type_name) or raise
+
+          comment =
+            case class_entry
+            when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+              class_entry.decls.flat_map {|decl| [decl.decl.comment] }.first
+            when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+              class_entry.decl.comment
+            end
 
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: "#{name}",
-            documentation:  format_comment(class_decl.comment),
+            label: complete_text,
+            detail: type_name.to_s,
+            documentation:  format_comment(comment),
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
               range: range,
-              new_text: name
+              new_text: complete_text
             ),
             kind: LSP::Constant::CompletionItemKind::CLASS,
-            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
-
+            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET,
+            sort_text: complete_text,
+            filter_text: complete_text
           )
         when :alias
-          alias_decl = sig_service.latest_env.alias_decls[type_name]&.decl or raise
+          alias_decl = sig_service.latest_env.type_alias_decls[type_name]&.decl or raise
+
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: "#{name}",
+            label: complete_text,
+            detail: type_name.to_s,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
               range: range,
-              new_text: name
+              new_text: complete_text
             ),
             documentation: format_comment(alias_decl.comment),
             # https://github.com/microsoft/vscode-languageserver-node/blob/6d78fc4d25719b231aba64a721a606f58b9e0a5f/client/src/common/client.ts#L624-L650
             kind: LSP::Constant::CompletionItemKind::FIELD,
-            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET,
+            sort_text: complete_text,
+            filter_text: complete_text
           )
         when :interface
           interface_decl = sig_service.latest_env.interface_decls[type_name]&.decl or raise
 
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: "#{name}",
+            label: complete_text,
+            detail: type_name.to_s,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
               range: range,
-              new_text: name
+              new_text: complete_text
             ),
             documentation: format_comment(interface_decl.comment),
             kind: LanguageServer::Protocol::Constant::CompletionItemKind::INTERFACE,
-            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
+            insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET,
+            sort_text: complete_text,
+            filter_text: complete_text
           )
         end
       end
@@ -400,17 +441,6 @@ module Steep
 
         params.join(", ")
       end
-
-      def relative_name_in_context(type_name, context)
-        context.each do |namespace|
-          if (type_name.to_s == namespace.to_type_name.to_s || type_name.namespace.to_s == "::")
-            return RBS::TypeName.new(namespace: RBS::Namespace.empty, name: type_name.name)
-          elsif type_name.to_s.start_with?(namespace.to_s)
-            return TypeName(type_name.to_s.sub(namespace.to_type_name.to_s, '')).relative!
-          end
-        end
-        type_name
-      end
     end
   end
 end

data/lib/steep/server/lsp_formatter.rb

@@ -110,19 +110,24 @@ EOM
           end
         when HoverProvider::Ruby::ConstantContent
           CommentBuilder.build do |builder|
-            if decl = content.class_or_module?
+            case
+            when decl = content.class_decl
               builder << <<EOM
 ```rbs
 #{declaration_summary(decl.primary.decl)}
 ```
 EOM
-            end
-
-            if content.constant?
+            when decl = content.constant_decl
               builder << <<EOM
 ```rbs
 #{content.full_name}: #{content.type}
 ```
+EOM
+            when decl = content.class_alias
+              builder << <<EOM
+```rbs
+#{decl.is_a?(::RBS::Environment::ClassAliasEntry) ? "class" : "module"} #{decl.decl.new_name} = #{decl.decl.old_name}
+```
 EOM
             end
 
@@ -245,10 +250,14 @@ EOM
                         " : #{decl.self_types.map {|s| name_and_args(s.name, s.args) }.join(", ")}"
                       end
           "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
-        when RBS::AST::Declarations::Alias
+        when RBS::AST::Declarations::TypeAlias
           "type #{decl.name} = #{decl.type}"
         when RBS::AST::Declarations::Interface
           "interface #{name_and_params(decl.name, decl.type_params)}"
+        when RBS::AST::Declarations::ClassAlias
+          "class #{decl.new_name} = #{decl.old_name}"
+        when RBS::AST::Declarations::ModuleAlias
+          "module #{decl.new_name} = #{decl.old_name}"
         end
       end
     end

data/lib/steep/services/completion_provider.rb

@@ -16,25 +16,23 @@ module Steep
         # @implements ConstantItem
 
         def class?
-          if decl = env.class_decls[full_name]
-            decl.primary.decl.is_a?(RBS::AST::Declarations::Class)
-          end
+          env.class_entry(full_name) ? true : false
         end
 
         def module?
-          if decl = env.class_decls[full_name]
-            decl.primary.decl.is_a?(RBS::AST::Declarations::Module)
-          end
+          env.module_entry(full_name) ? true : false
         end
 
         def comments
-          case
-          when decl = env.class_decls[full_name]
-            decl.decls.filter_map {|d| d.decl.comment }
-          when comment = env.constant_decls[full_name]&.decl&.comment
-            [comment]
+          case entry = env.constant_entry(full_name)
+          when RBS::Environment::ConstantEntry
+            [entry.decl.comment].compact
+          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+            entry.decls.filter_map {|d| d.decl.comment }
+          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            [entry.decl.comment].compact
           else
-            []
+            raise
           end
         end
       end

data/lib/steep/services/goto_service.rb

@@ -151,15 +151,15 @@ module Steep
               end
             end
           end
-        when target_names = type_check.signature_file?(path)
+        when target_names = type_check.signature_file?(path) #: Array[Symbol]
           target_names.each do |target_name|
-            signature_service = type_check.signature_services[target_name]
-            decls = signature_service.latest_env.declarations.select do |decl|
-              buffer_path = Pathname(decl.location.buffer.name)
-              buffer_path == relative_path || buffer_path == path
-            end
+            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(decls: decls)
+            locator = RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
             last, nodes = locator.find2(line: line, column: column)
             case nodes[0]
             when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
@@ -222,16 +222,17 @@ module Steep
 
       def constant_definition_in_rbs(name, locations:)
         type_check.signature_services.each_value do |signature|
-          env = signature.latest_env
+          env = signature.latest_env #: RBS::Environment
 
-          if entry = env.class_decls[name]
+          case entry = env.constant_entry(name)
+          when RBS::Environment::ConstantEntry
+            locations << entry.decl.location&.[](:name)
+          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
             entry.decls.each do |d|
-              locations << d.decl.location[:name]
+              locations << d.decl.location&.[](:name)
             end
-          end
-
-          if entry = env.constant_decls[name]
-            locations << entry.decl.location[:name]
+          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            locations << entry.decl.location&.[](:new_name)
           end
         end
 

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

@@ -19,18 +19,17 @@ module Steep
         def content_for(target:, path:, line:, column:)
           service = self.service.signature_services[target.name]
 
-          _, decls = service.latest_env.buffers_decls.find do |buffer, _|
-            Pathname(buffer.name) == path
-          end
-
-          return if decls.nil?
+          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
 
-          loc_key, path = ::RBS::Locator.new(decls: decls).find2(line: line, column: column) || return
+          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
-            alias_decl = service.latest_env.alias_decls[head.name]&.decl or raise
+            alias_decl = service.latest_env.type_alias_decls[head.name]&.decl or raise
 
             TypeAliasContent.new(
               location: head.location || raise,
@@ -38,9 +37,16 @@ module Steep
             )
           when ::RBS::Types::ClassInstance, ::RBS::Types::ClassSingleton
             if loc_key == :name
-              env = service.latest_env
-              class_decl = env.class_decls[head.name]&.decls&.[](0)&.decl or raise
               location = head.location&.[](:name) or raise
+
+              class_entry = service.latest_env.module_class_entry(head.name) or raise
+              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
@@ -55,6 +61,20 @@ module Steep
               location: location,
               decl: interface_decl
             )
+          when ::RBS::AST::Declarations::ClassAlias, ::RBS::AST::Declarations::ModuleAlias
+            if loc_key == :old_name
+              location = head.location&.[](:old_name) or raise
+
+              class_entry = service.latest_env.module_class_entry(head.old_name) or raise
+              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

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

@@ -14,6 +14,8 @@ module Steep
             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
@@ -22,27 +24,31 @@ module Steep
           end
 
           def class_decl
-            if (decl = decl()).is_a?(::RBS::Environment::MultiEntry)
+            case decl
+            when ::RBS::Environment::ClassEntry, ::RBS::Environment::ModuleEntry
               decl
             end
           end
 
-          def constant_decl
-            if (decl = decl()).is_a?(::RBS::Environment::SingleEntry)
+          def class_alias
+            case decl
+            when ::RBS::Environment::ClassAliasEntry, ::RBS::Environment::ModuleAliasEntry
               decl
             end
           end
 
-          def constant?
-            if decl.is_a?(::RBS::Environment::SingleEntry)
+          def constant_decl
+            if decl.is_a?(::RBS::Environment::ConstantEntry)
               decl
             end
           end
 
+          def constant?
+            constant_decl ? true : false
+          end
+
           def class_or_module?
-            if decl.is_a?(::RBS::Environment::MultiEntry)
-              decl
-            end
+            (class_decl || class_alias) ?  true : false
           end
         end
 
@@ -169,13 +175,13 @@ module Steep
               const_name = typing.source_index.reference(constant_node: node)
 
               if const_name
-                decl = context.env.class_decls[const_name] || context.env.constant_decls[const_name]
+                entry = context.env.constant_entry(const_name) or return
 
                 return ConstantContent.new(
                   location: node.location.name,
                   full_name: const_name,
                   type: type,
-                  decl: decl
+                  decl: entry
                 )
               end
             when :assertion