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

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/services/type_name_completion.rb

@@ -0,0 +1,157 @@
+module Steep
+  module Services
+    class TypeNameCompletion
+      module Prefix
+        RawIdentPrefix = _ = Struct.new(:ident) do
+          # @implements RawIdentPrefix
+
+          def const_name?
+            ident.start_with?(/[A-Z]/)
+          end
+
+          def size
+            ident.length
+          end
+        end
+
+        NamespacedIdentPrefix = _ = Struct.new(:namespace, :ident, :size) do
+          # @implements NamespacedIdentPrefix
+
+          def const_name?
+            ident.start_with?(/[A-Z]/)
+          end
+        end
+
+        NamespacePrefix = _ = Struct.new(:namespace, :size)
+
+        def self.parse(buffer, line:, column:)
+          pos = buffer.loc_to_pos([line, column])
+          prefix = buffer.content[0...pos] or raise
+          prefix.reverse!
+
+          case prefix
+          when /\A((::\w+[A-Z])+(::)?)/
+            NamespacePrefix.new(RBS::Namespace.parse($1.reverse), $1.size)
+          when /\A::/
+            NamespacePrefix.new(RBS::Namespace.root, 2)
+          when /\A(\w*[A-Za-z_])((::\w+[A-Z])+(::)?)/
+            NamespacedIdentPrefix.new(RBS::Namespace.parse($2.reverse), $1.reverse, $1.size + $2.size)
+          when /\A(\w*[A-Za-z_])::/
+            NamespacedIdentPrefix.new(RBS::Namespace.root, $1.reverse, $1.size + 2)
+          when /\A(\w*[A-Za-z_])/
+            RawIdentPrefix.new($1.reverse)
+          end
+        end
+      end
+
+      attr_reader :env, :context, :type_name_resolver, :map
+
+      def initialize(env:, context:, dirs:)
+        @env = env
+        @context = context
+
+        table = RBS::Environment::UseMap::Table.new()
+        table.known_types.merge(env.class_decls.keys)
+        table.known_types.merge(env.class_alias_decls.keys)
+        table.known_types.merge(env.type_alias_decls.keys)
+        table.known_types.merge(env.interface_decls.keys)
+        table.compute_children
+
+        @map = RBS::Environment::UseMap.new(table: table)
+        dirs.each do |dir|
+          dir.clauses.each do |clause|
+            @map.build_map(clause)
+          end
+        end
+
+        @type_name_resolver = RBS::Resolver::TypeNameResolver.new(env)
+      end
+
+      def each_outer_module(context = self.context, &block)
+        if block
+          if (parent, con = context)
+            namespace = each_outer_module(parent, &block)
+            case con
+            when false
+              namespace
+            when RBS::TypeName
+              ns = con.with_prefix(namespace).to_namespace
+              yield(ns)
+              ns
+            end
+          else
+            yield(RBS::Namespace.root)
+            RBS::Namespace.root
+          end
+        else
+          enum_for :each_outer_module
+        end
+      end
+
+      def each_type_name(&block)
+        if block
+          map.instance_eval do
+            @map.each_key do |name|
+              yield RBS::TypeName.new(name: name, namespace: RBS::Namespace.empty)
+            end
+          end
+          env.class_decls.each_key(&block)
+          env.class_alias_decls.each_key(&block)
+          env.type_alias_decls.each_key(&block)
+          env.interface_decls.each_key(&block)
+        else
+          enum_for :each_type_name
+        end
+      end
+
+      def resolve_name_in_context(name)
+        if resolved_name = map.resolve?(name)
+          return [resolved_name, name]
+        end
+
+        name.absolute? or raise
+
+        name.namespace.path.reverse_each.inject(RBS::TypeName.new(namespace: RBS::Namespace.empty, name: name.name)) do |relative_name, component|
+          if type_name_resolver.resolve(relative_name, context: context) == name
+            return [name, relative_name]
+          end
+
+          RBS::TypeName.new(
+            namespace: RBS::Namespace.new(path: [component, *relative_name.namespace.path], absolute: false),
+            name: name.name
+          )
+        end
+
+        if type_name_resolver.resolve(name.relative!, context: context) == name && !map.resolve?(name.relative!)
+          [name, name.relative!]
+        else
+          [name, name]
+        end
+      end
+
+      def find_type_names(prefix)
+        case prefix
+        when Prefix::RawIdentPrefix
+          each_type_name.filter do |type_name|
+            type_name.split.any? {|sym| sym.to_s.downcase.include?(prefix.ident.downcase) }
+          end
+        when Prefix::NamespacedIdentPrefix
+          absolute_namespace = type_name_resolver.resolve(prefix.namespace.to_type_name, context: context)&.to_namespace || prefix.namespace
+
+          each_type_name.filter do|name|
+            name.namespace == absolute_namespace &&
+              name.name.to_s.downcase.include?(prefix.ident.downcase)
+          end
+        when Prefix::NamespacePrefix
+          absolute_namespace = type_name_resolver.resolve(prefix.namespace.to_type_name, context: context)&.to_namespace || prefix.namespace
+          each_type_name.filter {|name| name.namespace == absolute_namespace }
+        else
+          # Returns all of the accessible type names from the context
+          namespaces = each_outer_module.to_set
+          # Relative type name means a *use*d type name
+          each_type_name.filter {|name| namespaces.include?(name.namespace) || !name.absolute? }
+        end
+      end
+    end
+  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/source.rb

@@ -20,6 +20,7 @@ module Steep
       self.emit_lambda = true
       self.emit_procarg0 = true
       self.emit_kwargs = true
+      self.emit_forward_arg = true
     end
 
     def self.new_parser

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)