steep 1.3.0 → 1.4.0.dev.2

data/lib/steep/index/rbs_index.rb

@@ -18,7 +18,9 @@ module Steep
             declarations << decl
           when RBS::AST::Declarations::Interface
             declarations << decl
-          when RBS::AST::Declarations::Alias
+          when RBS::AST::Declarations::TypeAlias
+            declarations << decl
+          when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
             declarations << decl
           else
             raise "Unexpected type declaration: #{decl}"
@@ -41,7 +43,9 @@ module Steep
             references << ref
           when RBS::AST::Declarations::Constant, RBS::AST::Declarations::Global
             references << ref
-          when RBS::AST::Declarations::Alias
+          when RBS::AST::Declarations::TypeAlias
+            references << ref
+          when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
             references << ref
           else
             raise "Unexpected type reference: #{ref}"
@@ -148,7 +152,7 @@ module Steep
       end
 
       def each_entry(&block)
-        if block_given?
+        if block
           type_index.each_value(&block)
           method_index.each_value(&block)
           const_index.each_value(&block)
@@ -176,7 +180,7 @@ module Steep
 
       def each_declaration(type_name: nil, method_name: nil, const_name: nil, global_name: nil, &block)
         if block
-          entry = entry(type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+          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)
@@ -187,9 +191,12 @@ module Steep
         entry(type_name: type_name).add_reference(ref)
       end
 
-      def each_reference(type_name: nil, &block)
+      def each_reference(type_name:, &block)
         if block
-          entry(type_name: type_name).references.each(&block)
+          case
+          when type_name
+            entry(type_name: type_name).references.each(&block)
+          end
         else
           enum_for(:each_reference, type_name: type_name)
         end
@@ -205,8 +212,8 @@ module Steep
         def member(type_name, member)
           case member
           when RBS::AST::Members::MethodDefinition
-            member.types.each do |method_type|
-              method_type.each_type do |type|
+            member.overloads.each do |overload|
+              overload.method_type.each_type do |type|
                 type_reference type, from: member
               end
             end
@@ -230,6 +237,8 @@ module Steep
                               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
@@ -240,6 +249,8 @@ module Steep
                               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
@@ -305,6 +316,11 @@ module Steep
             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)
 
@@ -313,7 +329,7 @@ module Steep
             end
           end
 
-          env.alias_decls.each do |name, decl|
+          env.type_alias_decls.each do |name, decl|
             index.add_type_declaration(name, decl.decl)
             type_reference decl.decl.type, from: decl.decl
           end

data/lib/steep/index/signature_symbol_provider.rb

@@ -84,7 +84,7 @@ module Steep
                     kind: LSP::Constant::SymbolKind::INTERFACE,
                     container_name: container_name
                   )
-                when RBS::AST::Declarations::Alias
+                when RBS::AST::Declarations::TypeAlias
                   symbols << SymbolInformation.new(
                     name: name,
                     location: decl.location,

data/lib/steep/project/dsl.rb

@@ -172,8 +172,12 @@ module Steep
           yield code_diagnostics_config if block_given?
         end
 
+        def project!
+          project or raise "TargetDSL doesn't have project (#{name})"
+        end
+
         def collection_config(path)
-          @collection_config_path = project.absolute_path(path)
+          @collection_config_path = project!.absolute_path(path)
         end
 
         def disable_collection
@@ -196,7 +200,6 @@ module Steep
 
       def initialize(project:)
         @project = project
-        @global_signatures = []
       end
 
       def self.register_template(name, target)
@@ -218,13 +221,18 @@ module Steep
                  end
 
         Steep.logger.tagged "target=#{name}" do
-          target.instance_eval(&block) if block_given?
+          target.instance_eval(&block) if block
         end
 
         source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
         signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
 
-        collection_lock = target.collection_config_path&.then { |p| RBS::Collection::Config.lockfile_of(p) }
+
+        if config_path = target.collection_config_path
+          lockfile_path = RBS::Collection::Config.to_lockfile_path(config_path)
+          content = YAML.load_file(lockfile_path.to_s)
+          collection_lock = RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: lockfile_path, data: content)
+        end
 
         Project::Target.new(
           name: target.name,

data/lib/steep/project/options.rb

@@ -1,7 +1,9 @@
 module Steep
   class Project
     class Options
-      PathOptions = Struct.new(:core_root, :stdlib_root, :repo_paths, keyword_init: true) do
+      PathOptions = _ = Struct.new(:core_root, :stdlib_root, :repo_paths, keyword_init: true) do
+        # @implements PathOptions
+        
         def customized_stdlib?
           stdlib_root != nil
         end

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

@@ -128,7 +128,7 @@ module Steep
               )
             when (targets = project.targets_for_path(job.path)).is_a?(Array)
               target = targets[0] or return
-              sig_service = service.signature_services[target.name]
+              sig_service = service.signature_services[target.name] #: Services::SignatureService
               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])
@@ -139,10 +139,12 @@ module Steep
                 return
               end
 
-              decls = sig_service.files[relative_path].decls
-              locator = RBS::Locator.new(decls: decls)
+              sig = sig_service.files[relative_path].signature
+              sig.is_a?(Array) or raise
+              decls = sig[2]
+              locator = RBS::Locator.new(buffer: sig[0], dirs: sig[1], decls: decls)
 
-              _hd, tail = locator.find2(line: job.line, column: job.column)
+              (_hd, tail = locator.find2(line: job.line, column: job.column)) or return []
 
               namespace = []
               tail.each do |t|
@@ -160,11 +162,12 @@ module Steep
 
               context.map!(&:absolute!)
 
-              class_items = sig_service.latest_env.class_decls.keys.map { |type_name|
+              class_names = sig_service.latest_env.class_decls.keys + sig_service.latest_env.class_alias_decls.keys
+              class_items = class_names.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|
+              alias_items = sig_service.latest_env.type_alias_decls.keys.map { |type_name|
                 format_completion_item_for_rbs(sig_service, type_name, context, job, prefix)
               }.compact
 
@@ -201,21 +204,35 @@ module Steep
 
         case type_name.kind
         when :class
-          class_decl = sig_service.latest_env.class_decls[type_name]&.decls[0]&.decl or raise
-
-          LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: "#{name}",
-            documentation:  format_comment(class_decl.comment),
-            text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
-              range: range,
-              new_text: name
-            ),
-            kind: LSP::Constant::CompletionItemKind::CLASS,
-            insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
-
-          )
+          env = sig_service.latest_env #: RBS::Environment
+          class_entry = env.module_class_entry(type_name) or raise
+
+          case class_entry
+          when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+            LanguageServer::Protocol::Interface::CompletionItem.new(
+              label: "#{name}",
+              documentation:  format_comment(class_entry.primary.decl.comment),
+              text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+                range: range,
+                new_text: name
+              ),
+              kind: LSP::Constant::CompletionItemKind::CLASS,
+              insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+            )
+          when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+            LanguageServer::Protocol::Interface::CompletionItem.new(
+              label: "#{name}",
+              documentation:  format_comment(class_entry.decl.comment),
+              text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
+                range: range,
+                new_text: name
+              ),
+              kind: LSP::Constant::CompletionItemKind::CLASS,
+              insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET
+            )
+          end
         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}",
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(

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