steep 1.5.3 → 1.6.0.pre.2

data/lib/steep/server/master.rb

@@ -402,6 +402,7 @@ module Steep
 
       attr_reader :initialize_params
       attr_accessor :typecheck_automatically
+      attr_reader :start_type_checking_queue
 
       def initialize(project:, reader:, writer:, interaction_worker:, typecheck_workers:, queue: Queue.new)
         @project = project
@@ -416,6 +417,7 @@ module Steep
 
         @controller = TypeCheckController.new(project: project)
         @result_controller = ResultController.new()
+        @start_type_checking_queue = DelayQueue.new(delay: 0.1)
       end
 
       def start
@@ -488,6 +490,8 @@ module Steep
                     Steep.logger.info { "Processing SendMessageJob: dest=#{job.dest.name}, method=#{job.message[:method] || "-"}, id=#{job.message[:id] || "-"}" }
                     job.dest << job.message
                   end
+                when Proc
+                  job.call()
                 end
               end
             end
@@ -529,6 +533,10 @@ module Steep
         initialize_params&.dig(:capabilities, :window, :workDoneProgress) ? true : false
       end
 
+      def file_system_watcher_supported?
+        initialize_params&.dig(:capabilities, :workspace, :didChangeWatchedFiles, :dynamicRegistration) || false
+      end
+
       def process_message_from_client(message)
         Steep.logger.info "Processing message from client: method=#{message[:method]}, id=#{message[:id]}"
         id = message[:id]
@@ -551,7 +559,6 @@ module Steep
                     capabilities: LSP::Interface::ServerCapabilities.new(
                       text_document_sync: LSP::Interface::TextDocumentSyncOptions.new(
                         change: LSP::Constant::TextDocumentSyncKind::INCREMENTAL,
-                        save: LSP::Interface::SaveOptions.new(include_text: false),
                         open_close: true
                       ),
                       hover_provider: {
@@ -575,6 +582,52 @@ module Steep
                   )
                 }
               )
+
+              if file_system_watcher_supported?
+                patterns = [] #: Array[String]
+                project.targets.each do |target|
+                  target.source_pattern.patterns.each do |pat|
+                    path = project.base_dir + pat
+                    patterns << path.to_s unless path.directory?
+                  end
+                  target.source_pattern.prefixes.each do |pat|
+                    path = project.base_dir + pat
+                    patterns << (path + "**/*.rb").to_s unless path.file?
+                  end
+                  target.signature_pattern.patterns.each do |pat|
+                    path = project.base_dir + pat
+                    patterns << path.to_s unless path.directory?
+                  end
+                  target.signature_pattern.prefixes.each do |pat|
+                    path = project.base_dir + pat
+                    patterns << (path + "**/*.rbs").to_s unless path.file?
+                  end
+                end
+                patterns.sort!
+                patterns.uniq!
+
+                Steep.logger.info { "Setting up didChangeWatchedFiles with pattern: #{patterns.inspect}" }
+
+                job_queue << SendMessageJob.to_client(
+                  message: {
+                    id: SecureRandom.uuid,
+                    method: "client/registerCapability",
+                    params: {
+                      registrations: [
+                        {
+                          id: SecureRandom.uuid,
+                          method: "workspace/didChangeWatchedFiles",
+                          registerOptions: {
+                            watchers: patterns.map do |pattern|
+                              { globPattern: pattern }
+                            end
+                          }
+                        }
+                      ]
+                    }
+                  }
+                )
+              end
             end
           end
 
@@ -585,28 +638,71 @@ module Steep
             end
           end
 
+        when "workspace/didChangeWatchedFiles"
+          message[:params][:changes].each do |change|
+            uri = change[:uri]
+            type = change[:type]
+
+            path = PathHelper.to_pathname(uri) or next
+
+            controller.push_changes(path)
+
+            case type
+            when 1, 2
+              content = path.read
+            when 4
+              # Deleted
+              content = ""
+            end
+
+            broadcast_notification({
+              method: "$/file/reset",
+              params: { uri: uri, content: content }
+            })
+          end
+
+          if typecheck_automatically
+            start_type_checking_queue.execute do
+              job_queue.push(
+                -> do
+                  last_request = current_type_check_request
+                  if request = controller.make_request(last_request: last_request)
+                    start_type_check(request, last_request: last_request, start_progress: request.total > 10)
+                  end
+                end
+              )
+            end
+          end
+
         when "textDocument/didChange"
           if path = pathname(message[:params][:textDocument][:uri])
             broadcast_notification(message)
             controller.push_changes(path)
-          end
 
-        when "textDocument/didSave"
-          if path = pathname(message[:params][:textDocument][:uri])
             if typecheck_automatically
-              if request = controller.make_request(last_request: current_type_check_request)
-                start_type_check(
-                  request,
-                  last_request: current_type_check_request,
-                  start_progress: request.total > 10
+              start_type_checking_queue.execute do
+                job_queue.push(
+                  -> do
+                    last_request = current_type_check_request
+                    if request = controller.make_request(last_request: last_request)
+                      start_type_check(request, last_request: last_request, start_progress: request.total > 10)
+                    end
+                  end
                 )
               end
             end
           end
 
         when "textDocument/didOpen"
-          if path = pathname(message[:params][:textDocument][:uri])
+          uri = message[:params][:textDocument][:uri]
+          text = message[:params][:textDocument][:text]
+
+          if path = pathname(uri)
             controller.update_priority(open: path)
+            broadcast_notification({
+              method: "$/file/reset",
+              params: { uri: uri, content: text }
+            })
           end
 
         when "textDocument/didClose"

data/lib/steep/server/type_check_worker.rb

@@ -70,8 +70,15 @@ module Steep
         when "initialize"
           load_files(project: project, commandline_args: commandline_args)
           writer.write({ id: request[:id], result: nil})
+
         when "textDocument/didChange"
           collect_changes(request)
+
+        when "$/file/reset"
+          uri = request[:params][:uri]
+          text = request[:params][:content]
+          reset_change(uri: uri, text: text)
+
         when "workspace/symbol"
           query = request[:params][:query]
           queue << WorkspaceSymbolJob.new(id: request[:id], query: query)
@@ -165,7 +172,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: Steep::PathHelper.to_uri(job.path),
+                  uri: Steep::PathHelper.to_uri(job.path).to_s,
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
                 )
               )
@@ -183,7 +190,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: Steep::PathHelper.to_uri(job.path),
+                  uri: Steep::PathHelper.to_uri(job.path).to_s,
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
                 )
               )
@@ -202,7 +209,7 @@ module Steep
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: Steep::PathHelper.to_uri(job.path),
+                  uri: Steep::PathHelper.to_uri(job.path).to_s,
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq.compact
                 )
               )

data/lib/steep/services/completion_provider.rb

@@ -115,7 +115,7 @@ module Steep
             when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
               entry.decl
             else
-              raise
+              raise "absolute_type_name=#{absolute_type_name}, relative_type_name=#{relative_type_name}"
             end
           else
             raise
@@ -663,7 +663,7 @@ module Steep
         if parent
           case parent.type
           when :const
-            const_name = typing.source_index.reference(constant_node: parent)
+            const_name = typing.source_index.reference(constant_node: parent) or raise "Unknown node in source_index: #{parent}"
             consts = context.type_env.constant_env.children(const_name)
           end
         else

data/lib/steep/services/stats_calculator.rb

@@ -1,7 +1,7 @@
 module Steep
   module Services
     class StatsCalculator
-      SuccessStats = Struct.new(:target, :path, :typed_calls_count, :untyped_calls_count, :error_calls_count, keyword_init: true) do
+      class SuccessStats < Struct.new(:target, :path, :typed_calls_count, :untyped_calls_count, :error_calls_count, keyword_init: true)
         def as_json
           {
             type: "success",
@@ -14,7 +14,7 @@ module Steep
           }
         end
       end
-      ErrorStats = Struct.new(:target, :path, keyword_init: true) do
+      class ErrorStats < Struct.new(:target, :path, keyword_init: true)
         def as_json
           {
             type: "error",

data/lib/steep/services/type_name_completion.rb

@@ -31,15 +31,20 @@ module Steep
 
           case prefix
           when /\A((::\w+[A-Z])+(::)?)/
-            NamespacePrefix.new(RBS::Namespace.parse($1.reverse), $1.size)
+            namespace = $1 or raise
+            NamespacePrefix.new(RBS::Namespace.parse(namespace.reverse), namespace.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)
+            namespace = $1 or raise
+            identifier = $2 or raise
+            NamespacedIdentPrefix.new(RBS::Namespace.parse(identifier.reverse), namespace.reverse, namespace.size + identifier.size)
           when /\A(\w*[A-Za-z_])::/
-            NamespacedIdentPrefix.new(RBS::Namespace.root, $1.reverse, $1.size + 2)
+            namespace = $1 or raise
+            NamespacedIdentPrefix.new(RBS::Namespace.root, namespace.reverse, namespace.size + 2)
           when /\A(\w*[A-Za-z_])/
-            RawIdentPrefix.new($1.reverse)
+            identifier = $1 or raise
+            RawIdentPrefix.new(identifier.reverse)
           end
         end
       end
@@ -92,36 +97,97 @@ module Steep
         if block
           env = self.env
 
+          table = {} #: Hash[RBS::Namespace, Array[RBS::TypeName]]
+          env.class_decls.each_key do |type_name|
+            yield(type_name)
+            (table[type_name.namespace] ||= []) << type_name
+          end
+          env.type_alias_decls.each_key do |type_name|
+            yield(type_name)
+            (table[type_name.namespace] ||= []) << type_name
+          end
+          env.interface_decls.each_key do |type_name|
+            yield(type_name)
+            (table[type_name.namespace] ||= []) << type_name
+          end
+          env.class_alias_decls.each_key do |type_name|
+            yield(type_name)
+            (table[type_name.namespace] ||= []) << type_name
+          end
+
+          env.class_alias_decls.each_key do |alias_name|
+            normalized_name = env.normalize_module_name?(alias_name) or next
+            each_type_name_under(alias_name, normalized_name, table: table, &block)
+          end
+
+          resolve_pairs = [] #: Array[[RBS::TypeName, RBS::TypeName]]
+
           map.instance_eval do
             @map.each_key do |name|
               relative_name = RBS::TypeName.new(name: name, namespace: RBS::Namespace.empty)
               if absolute_name = resolve?(relative_name)
                 if env.type_name?(absolute_name)
                   # Yields only if the relative type name resolves to existing absolute type name
-                  yield relative_name
+                  resolve_pairs << [relative_name, absolute_name]
                 end
               end
             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)
+
+          resolve_pairs.each do |use_name, absolute_name|
+            yield use_name
+            each_type_name_under(use_name, absolute_name, table: table, &block)
+          end
         else
           enum_for :each_type_name
         end
       end
 
+      def each_type_name_under(module_name, normalized_name, table:, &block)
+        if children = table.fetch(normalized_name.to_namespace, nil)
+          module_namespace = module_name.to_namespace
+
+          children.each do |normalized_child_name|
+            child_name = RBS::TypeName.new(namespace: module_namespace, name: normalized_child_name.name)
+
+            yield child_name
+
+            if normalized_child_name.class?
+              each_type_name_under(child_name, env.normalize_module_name(normalized_child_name), table: table, &block)
+            end
+          end
+        end
+      end
+
+      def resolve_used_name(name)
+        return nil if name.absolute?
+
+        case
+        when resolved = map.resolve?(name)
+          resolved
+        when name.namespace.empty?
+          nil
+        else
+          if resolved_parent = resolve_used_name(name.namespace.to_type_name)
+            resolved_name = RBS::TypeName.new(namespace: resolved_parent.to_namespace, name: name.name)
+            if env.normalize_type_name?(resolved_name)
+              resolved_name
+            end
+          end
+        end
+      end
+
       def resolve_name_in_context(name)
-        if resolved_name = map.resolve?(name)
+        if resolved_name = resolve_used_name(name)
           return [resolved_name, name]
         end
 
         name.absolute? or raise
+        normalized_name = env.normalize_type_name?(name) or raise "Cannot normalize given type name `#{name}`"
 
         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]
+            return [normalized_name, relative_name]
           end
 
           RBS::TypeName.new(
@@ -130,10 +196,10 @@ module Steep
           )
         end
 
-        if type_name_resolver.resolve(name.relative!, context: context) == name && !map.resolve?(name.relative!)
-          [name, name.relative!]
+        if type_name_resolver.resolve(name.relative!, context: context) == name && !resolve_used_name(name.relative!)
+          [normalized_name, name.relative!]
         else
-          [name, name]
+          [normalized_name, name]
         end
       end
 
@@ -144,7 +210,12 @@ module Steep
             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
+          absolute_namespace =
+            if prefix.namespace.empty?
+              RBS::Namespace.root
+            else
+              type_name_resolver.resolve(prefix.namespace.to_type_name, context: context)&.to_namespace || prefix.namespace
+            end
 
           each_type_name.filter do|name|
             name.namespace == absolute_namespace &&

data/lib/steep/signature/validator.rb

@@ -112,10 +112,11 @@ module Steep
               type.args
             ]
           when RBS::Types::Alias
-            entry = env.type_alias_decls[type.name]
+            type_name = env.normalize_type_name?(type.name) or return
+            entry = env.type_alias_decls[type_name]
 
             [
-              type.name,
+              type_name,
               entry.decl.type_params,
               type.args
             ]
@@ -520,6 +521,12 @@ module Steep
       def validate_one_alias(name, entry = env.type_alias_decls[name])
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating alias `#{name}`..."
+
+          unless name.namespace.empty?
+            outer = name.namespace.to_type_name
+            builder.validate_type_name(outer, entry.decl.location&.aref(:name))
+          end
+
           upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
             bounds[param.name] = factory.type_opt(param.upper_bound)
           end

data/lib/steep/subtyping/check.rb

@@ -79,11 +79,11 @@ module Steep
       end
 
       def instance_type
-        @instance_type
+        @instance_type || AST::Types::Instance.instance
       end
 
       def class_type
-        @class_type
+        @class_type || AST::Types::Class.instance
       end
 
       def constraints
@@ -193,7 +193,7 @@ module Steep
           bounds = cache_bounds(relation)
           fvs = relation.sub_type.free_variables + relation.super_type.free_variables
           cached = cache[relation, @self_type, @instance_type, @class_type, bounds]
-          if cached && fvs.none? {|var| constraints.unknown?(var) }
+          if cached && fvs.none? {|var| var.is_a?(Symbol) && constraints.unknown?(var) }
             cached
           else
             if assumptions.member?(relation)
@@ -212,7 +212,8 @@ module Steep
 
       def cache_bounds(relation)
         vars = relation.sub_type.free_variables + relation.super_type.free_variables
-        vars.each.with_object({}) do |var, hash|
+        vars.each.with_object({}) do |var, hash| #$ Hash[Symbol, AST::Types::t]
+          next unless var.is_a?(Symbol)
           if upper_bound = variable_upper_bound(var)
             hash[var] = upper_bound
           end
@@ -232,7 +233,7 @@ module Steep
         when AST::Types::Literal
           type.value == true
         else
-          AST::Builtin::TrueClass.instance_type?(type)
+          AST::Builtin::TrueClass.instance_type?(type) ? true : false
         end
       end
 
@@ -241,7 +242,7 @@ module Steep
         when AST::Types::Literal
           type.value == false
         else
-          AST::Builtin::FalseClass.instance_type?(type)
+          AST::Builtin::FalseClass.instance_type?(type) ? true : false
         end
       end
 
@@ -410,7 +411,7 @@ module Steep
                     class_type: class_type,
                     variable_bounds: variable_upper_bounds
                   )
-                ) or raise
+                ) or return Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
               }
             )
           end
@@ -492,7 +493,7 @@ module Steep
             Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
           end
 
-        when relation.sub_type.is_a?(AST::Types::Tuple) && AST::Builtin::Array.instance_type?(relation.super_type)
+        when relation.sub_type.is_a?(AST::Types::Tuple) && (super_type = AST::Builtin::Array.instance_type?(relation.super_type))
           Expand(relation) do
             tuple_element_type =
               AST::Types::Union.build(
@@ -500,7 +501,7 @@ module Steep
                 location: relation.sub_type.location
               )
 
-            check_type(Relation.new(sub_type: tuple_element_type, super_type: relation.super_type.args[0]))
+            check_type(Relation.new(sub_type: tuple_element_type, super_type: super_type.args[0]))
           end
 
         when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
@@ -549,9 +550,7 @@ module Steep
           end
 
         when relation.super_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.sub_type)
-          Success(relation)
-
-        when relation.sub_type.is_a?(AST::Types::Nil) && AST::Builtin::NilClass.instance_type?(relation.super_type)
+          # NilClass <: nil
           Success(relation)
 
         when relation.sub_type.is_a?(AST::Types::Literal)
@@ -742,10 +741,17 @@ module Steep
             args = sub_type.type_params.map {|type_param| AST::Types::Var.fresh(type_param.name) }
             args.each {|arg| constraints.unknown!(arg.name) }
 
-            upper_bounds = {}
-            relations = [] #: Array[Relation]
+            upper_bounds = {} #: Hash[Symbol, AST::Types::t]
+            relations = [] #: Array[Relation[AST::Types::t]]
 
             args.zip(sub_type.type_params, super_type.type_params).each do |arg, sub_param, sup_param|
+              # @type var arg: AST::Types::Var
+              # @type var sub_param: Interface::TypeParam?
+              # @type var super_param: Interface::TypeParam?
+
+              sub_param or raise
+              sup_param or raise
+
               sub_ub = sub_param.upper_bound
               sup_ub = sup_param.upper_bound
 
@@ -927,7 +933,7 @@ module Steep
 
         sub_params, super_params = relation
 
-        pairs = []
+        pairs = [] #: Array[[AST::Types::t, AST::Types::t]]
 
         sub_flat = sub_params.flat_unnamed_params
         sup_flat = super_params.flat_unnamed_params
@@ -939,7 +945,7 @@ module Steep
           return failure unless sub_params.rest
 
           while sub_flat.size > 0
-            sub_type = sub_flat.shift
+            sub_type = sub_flat.shift or raise
             sup_type = sup_flat.shift
 
             if sup_type
@@ -955,7 +961,7 @@ module Steep
 
         when sub_params.rest
           while sub_flat.size > 0
-            sub_type = sub_flat.shift
+            sub_type = sub_flat.shift or raise
             sup_type = sup_flat.shift
 
             if sup_type
@@ -972,7 +978,7 @@ module Steep
           end
         when sub_params.required.size + sub_params.optional.size >= super_params.required.size + super_params.optional.size
           while sub_flat.size > 0
-            sub_type = sub_flat.shift
+            sub_type = sub_flat.shift or raise
             sup_type = sup_flat.shift
 
             if sup_type