steep 1.4.0.dev.1 → 1.4.0.dev.2

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

data/lib/steep/services/signature_service.rb

@@ -75,7 +75,7 @@ module Steep
         end
       end
 
-      FileStatus = _ = Struct.new(:path, :content, :decls, keyword_init: true)
+      FileStatus = _ = Struct.new(:path, :content, :signature, keyword_init: true)
 
       def initialize(env:)
         builder = RBS::DefinitionBuilder.new(env: env)
@@ -150,7 +150,7 @@ module Steep
       def apply_changes(files, changes)
         Steep.logger.tagged "#apply_changes" do
           Steep.measure2 "Applying change" do |sampler|
-            changes.each.with_object({}) do |pair, update|
+            changes.each.with_object({}) do |pair, update|  # $ Hash[Pathname, FileStatus]
               path, cs = pair
               sampler.sample "#{path}" do
                 old_text = files[path]&.content
@@ -158,17 +158,18 @@ module Steep
 
                 buffer = RBS::Buffer.new(name: path, content: content)
 
-                update[path] = begin
-                                 FileStatus.new(path: path, content: content, decls: RBS::Parser.parse_signature(buffer))
-                               rescue ArgumentError => exn
-                                 error = Diagnostic::Signature::UnexpectedError.new(
-                                   message: exn.message,
-                                   location: RBS::Location.new(buffer: buffer, start_pos: 0, end_pos: content.size)
-                                 )
-                                 FileStatus.new(path: path, content: content, decls: error)
-                               rescue RBS::ParsingError => exn
-                                 FileStatus.new(path: path, content: content, decls: exn)
-                               end
+                update[path] =
+                  begin
+                    FileStatus.new(path: path, content: content, signature: RBS::Parser.parse_signature(buffer))
+                  rescue ArgumentError => exn
+                    error = Diagnostic::Signature::UnexpectedError.new(
+                      message: exn.message,
+                      location: RBS::Location.new(buffer: buffer, start_pos: 0, end_pos: content.size)
+                    )
+                    FileStatus.new(path: path, content: content, signature: error)
+                  rescue RBS::ParsingError => exn
+                    FileStatus.new(path: path, content: content, signature: exn)
+                  end
               end
             end
           end
@@ -181,16 +182,16 @@ module Steep
           paths = Set.new(updates.each_key)
           paths.merge(pending_changed_paths)
 
-          if updates.each_value.any? {|file| !file.decls.is_a?(Array) }
-            diagnostics = []
+          if updates.each_value.any? {|file| !file.signature.is_a?(Array) }
+            diagnostics = [] #: Array[Diagnostic::Signature::Base]
 
             updates.each_value do |file|
-              unless file.decls.is_a?(Array)
-                diagnostic = if file.decls.is_a?(Diagnostic::Signature::Base)
-                               file.decls
+              unless file.signature.is_a?(Array)
+                diagnostic = if file.signature.is_a?(Diagnostic::Signature::Base)
+                               file.signature
                              else
                                # factory is not used here because the error is a syntax error.
-                               Diagnostic::Signature.from_rbs_error(file.decls, factory: _ = nil)
+                               Diagnostic::Signature.from_rbs_error(file.signature, factory: _ = nil)
                              end
                 diagnostics << diagnostic
               end
@@ -204,9 +205,7 @@ module Steep
             )
           else
             files = self.files.merge(updates)
-            updated_files = paths.each_with_object({}) do |path, hash|
-              hash[path] = files[path]
-            end
+            updated_files = files.slice(*paths.to_a)
             result =
               Steep.measure "#update_env with updated #{paths.size} files" do
                 update_env(updated_files, paths: paths)
@@ -229,33 +228,29 @@ module Steep
       end
 
       def update_env(updated_files, paths:)
+
         Steep.logger.tagged "#update_env" do
-          # @type var errors: Array[RBS::BaseError]
-          errors = []
-          new_decls = Set[].compare_by_identity
+          errors = [] #: Array[RBS::BaseError]
+          new_decls = Set[].compare_by_identity #: Set[RBS::AST::Declarations::t]
 
           env =
             Steep.measure "Deleting out of date decls" do
-              latest_env.reject do |decl|
-                if decl.location
-                  paths.include?(decl.location.buffer.name)
-                end
-              end
+              bufs = latest_env.buffers.select {|buf| paths.include?(buf.name) }
+              latest_env.unload(Set.new(bufs))
             end
 
           Steep.measure "Loading new decls" do
             updated_files.each_value do |content|
-              case decls = content.decls
-              when RBS::BaseError
-                errors << decls
+              case content.signature
+              when RBS::ParsingError
+                errors << content.signature
               when Diagnostic::Signature::UnexpectedError
-                return [decls]
+                return [content.signature]
               else
                 begin
-                  decls.each do |decl|
-                    env << decl
-                    new_decls << decl
-                  end
+                  buffer, dirs, decls = content.signature
+                  env.add_signature(buffer: buffer, directives: dirs, decls: decls)
+                  new_decls.merge(decls)
                 rescue RBS::LoadingError => exn
                   errors << exn
                 end
@@ -375,8 +370,10 @@ module Steep
               type_name_from_decl(member, set: set)
             end
           end
-        when RBS::AST::Declarations::Alias
+        when RBS::AST::Declarations::TypeAlias
           set << decl.name
+        when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
+          set << decl.new_name
         end
       end
 

data/lib/steep/signature/validator.rb

@@ -36,7 +36,7 @@ module Steep
       end
 
       def type_name_resolver
-        @type_name_resolver ||= RBS::TypeNameResolver.from_env(env)
+        @type_name_resolver ||= RBS::Resolver::TypeNameResolver.new(env)
       end
 
       def validator
@@ -112,7 +112,7 @@ module Steep
               type.args
             ]
           when RBS::Types::Alias
-            entry = env.alias_decls[type.name]
+            entry = env.type_alias_decls[type.name]
 
             [
               type.name,
@@ -135,7 +135,7 @@ module Steep
       def validate_type(type)
         Steep.logger.debug "#{Location.to_string type.location}: Validating #{type}..."
 
-        validator.validate_type type, context: [RBS::Namespace.root]
+        validator.validate_type(type, context: nil)
         validate_type_application(type)
       end
 
@@ -235,7 +235,7 @@ module Steep
         end
       end
 
-      def validate_one_class(name)
+      def validate_one_class_decl(name)
         rescue_validation_errors(name) do
           Steep.logger.debug { "Validating class definition `#{name}`..." }
 
@@ -390,6 +390,17 @@ module Steep
         end
       end
 
+      def validate_one_class(name)
+        entry = env.constant_entry(name)
+
+        case entry
+        when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+          validate_one_class_decl(name)
+        when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+          validate_one_class_alias(name, entry)
+        end
+      end
+
       def validate_ancestor_application(name, ancestor)
         unless ancestor.args.empty?
           definition =
@@ -465,6 +476,10 @@ module Steep
           validate_one_class(name)
         end
 
+        env.class_alias_decls.each do |name, entry|
+          validate_one_class_alias(name, entry)
+        end
+
         env.interface_decls.each_key do |name|
           validate_one_interface(name)
         end
@@ -497,7 +512,7 @@ module Steep
         end
       end
 
-      def validate_one_alias(name, entry = env.alias_decls[name])
+      def validate_one_alias(name, entry = env.type_alias_decls[name])
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating alias `#{name}`..."
           upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
@@ -512,8 +527,15 @@ module Steep
         end
       end
 
+      def validate_one_class_alias(name, entry)
+        rescue_validation_errors(name) do
+          Steep.logger.debug "Validating class/module alias `#{name}`..."
+          validator.validate_class_alias(entry: entry)
+        end
+      end
+
       def validate_alias
-        env.alias_decls.each do |name, entry|
+        env.type_alias_decls.each do |name, entry|
           validate_one_alias(name, entry)
         end
       end

data/lib/steep/subtyping/check.rb

@@ -619,7 +619,7 @@ module Steep
           return true
         end
 
-        relation.sub_type == relation.super_type
+        builder.factory.normalize_type(relation.sub_type) == builder.factory.normalize_type(relation.super_type)
       end
 
       def check_interface(relation)