steep 1.5.3 → 1.6.0.pre.1

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

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

data/lib/steep/type_construction.rb

@@ -1305,29 +1305,39 @@ module Steep
             var = node.children[0]
             rhs = node.children[1]
 
-            var_type = context.type_env[var]
+            if SPECIAL_LVAR_NAMES.include?(var)
+              synthesize(rhs)
+              add_typing(node, type: AST::Builtin.any_type)
+            else
+              var_type = context.type_env[var]
 
-            if var_type
-              type, constr = check(rhs, var_type) do |expected_type, actual_type, result|
-                typing.add_error(
-                  Diagnostic::Ruby::IncompatibleAssignment.new(
-                    node: node,
-                    lhs_type: expected_type,
-                    rhs_type: actual_type,
-                    result: result
+              if var_type
+                type, constr = check(rhs, var_type) do |expected_type, actual_type, result|
+                  typing.add_error(
+                    Diagnostic::Ruby::IncompatibleAssignment.new(
+                      node: node,
+                      lhs_type: expected_type,
+                      rhs_type: actual_type,
+                      result: result
+                    )
                   )
-                )
+                end
+              else
+                type, constr = synthesize(rhs)
               end
-            else
-              type, constr = synthesize(rhs)
-            end
 
-            constr.add_typing(node, type: type)
+              constr.add_typing(node, type: type)
+            end
           end
 
         when :restarg
           yield_self do
             var = node.children[0]
+
+            if SPECIAL_LVAR_NAMES.include?(var)
+              return add_typing(node, type: AST::Builtin.any_type)
+            end
+
             type = context.type_env[var]
 
             unless type
@@ -1344,6 +1354,11 @@ module Steep
         when :kwrestarg
           yield_self do
             var = node.children[0]
+
+            if SPECIAL_LVAR_NAMES.include?(var)
+              return add_typing(node, type: AST::Builtin.any_type)
+            end
+
             type = context.type_env[var]
             unless type
               if context.method_context&.method_type
@@ -3046,6 +3061,7 @@ module Steep
           end
         else
           parent_type, constr = synthesize(parent_node).to_ary
+          parent_type = expand_self(parent_type)
           parent_type = deep_expand_alias(parent_type)
 
           case parent_type
@@ -3284,7 +3300,14 @@ module Steep
 
         if call && constr
           case method_name.to_s
-          when "[]=", /\w=\Z/
+          when "[]="
+            if test_send_node(node) {|_, _, _, loc| !loc.dot }
+              last_arg = arguments.last or raise
+              if typing.has_type?(last_arg)
+                call = call.with_return_type(typing.type_of(node: last_arg))
+              end
+            end
+          when /\w=\Z/
             last_arg = arguments.last or raise
             if typing.has_type?(last_arg)
               call = call.with_return_type(typing.type_of(node: last_arg))
@@ -3292,7 +3315,7 @@ module Steep
           end
 
           if call.is_a?(TypeInference::MethodCall::Typed)
-            if (pure_call, type = constr.context.type_env.pure_method_calls[node])
+            if (pure_call, type = constr.context.type_env.pure_method_calls.fetch(node, nil))
               if type
                 call = pure_call.update(node: node, return_type: type)
                 constr.add_typing(node, type: call.return_type)
@@ -3345,12 +3368,14 @@ module Steep
             method_name: method_name,
             method_types: method.method_types
           )
+          decls = method.method_types.each_with_object(Set[]) {|type, decls| decls.merge(type.method_decls) }
           call = TypeInference::MethodCall::Error.new(
             node: node,
             context: context.call_context,
             method_name: method_name,
             receiver_type: receiver_type,
-            errors: errors
+            errors: errors,
+            method_decls: decls
           )
         end
 
@@ -3665,6 +3690,23 @@ module Steep
         end
       end
 
+      non_arity_errors = fails.reject do |call, _|
+        if call.is_a?(TypeInference::MethodCall::Error)
+          call.errors.any? do |error|
+            error.is_a?(Diagnostic::Ruby::UnexpectedBlockGiven) ||
+              error.is_a?(Diagnostic::Ruby::RequiredBlockMissing) ||
+              error.is_a?(Diagnostic::Ruby::UnexpectedPositionalArgument) ||
+              error.is_a?(Diagnostic::Ruby::InsufficientPositionalArguments) ||
+              error.is_a?(Diagnostic::Ruby::UnexpectedKeywordArgument) ||
+              error.is_a?(Diagnostic::Ruby::InsufficientKeywordArguments)
+          end
+        end
+      end
+
+      unless non_arity_errors.empty?
+        fails = non_arity_errors
+      end
+
       if fails.one?
         call, constr = fails[0]
 

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -367,6 +367,32 @@ module Steep
               [truthy_result, falsy_result]
             end
           end
+
+        when AST::Types::Logic::ArgIsAncestor
+          if receiver && (arg = arguments[0])
+            receiver_type = typing.type_of(node: receiver)
+            arg_type = factory.deep_expand_alias(typing.type_of(node: arg))
+
+            if arg_type.is_a?(AST::Types::Name::Singleton)
+              truthy_type = arg_type
+              falsy_type = receiver_type
+              truthy_env, falsy_env = refine_node_type(
+                env: env,
+                node: receiver,
+                truthy_type: truthy_type,
+                falsy_type: falsy_type
+              )
+
+              truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
+              truthy_result.unreachable! unless truthy_type
+
+              falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
+              falsy_result.unreachable! unless falsy_type
+
+              [truthy_result, falsy_result]
+            end
+          end
+
         when AST::Types::Logic::Not
           if receiver
             truthy_result, falsy_result = evaluate_node(env: env, node: receiver)

data/lib/steep/type_inference/method_params.rb

@@ -453,7 +453,7 @@ module Steep
           has_error = false
 
           keywords.each do |keyword|
-            rest_types << keyword_params.requireds[keyword] || keyword_params.optionals[keyword]
+            rest_types << (keyword_params.requireds[keyword] || keyword_params.optionals[keyword])
             has_error = true
           end
           keywords.clear

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.5.3"
+  VERSION = "1.6.0.pre.1"
 end

data/lib/steep.rb

@@ -23,9 +23,6 @@ require "rbs"
 
 require "steep/path_helper"
 
-require "steep/shims/filter_map"
-require "steep/shims/symbol_start_with"
-
 require "steep/thread_waiter"
 require "steep/equatable"
 require "steep/method_name"
@@ -113,6 +110,7 @@ require "steep/services/stats_calculator"
 require "steep/services/file_loader"
 require "steep/services/goto_service"
 
+require "steep/server/delay_queue"
 require "steep/server/lsp_formatter"
 require "steep/server/change_buffer"
 require "steep/server/base_worker"

data/sig/shims/language-server_protocol.rbs

@@ -78,6 +78,18 @@ module LanguageServer
         MARKDOWN: "markdown"
       end
 
+      class MessageType
+        type t = 1 | 2 | 3 | 4
+
+        ERROR: 1
+
+        WARNING: 2
+
+        INFO: 3
+
+        LOG: 4
+      end
+
       module DiagnosticSeverity
         type t = 1 | 2 | 3 | 4
 

data/sig/steep/ast/types/logic.rbs

@@ -52,6 +52,11 @@ module Steep
           def initialize: (?location: untyped?) -> void
         end
 
+        # A type for `Class#<` or `Class#<=` call results.
+        class ArgIsAncestor < Base
+          def initialize: (?location: untyped?) -> void
+        end
+
         # A type with truthy/falsy type environment.
         class Env < Base
           attr_reader truthy: TypeInference::TypeEnv

data/sig/steep/ast/types.rbs

@@ -6,7 +6,7 @@ module Steep
            | Intersection  | Record | Tuple | Union
            | Name::Alias | Name::Instance | Name::Interface | Name::Singleton
            | Proc | Var
-           | Logic::Not | Logic::ReceiverIsNil | Logic::ReceiverIsNotNil | Logic::ReceiverIsArg | Logic::ArgIsReceiver | Logic::ArgEqualsReceiver | Logic::Env
+           | Logic::Not | Logic::ReceiverIsNil | Logic::ReceiverIsNotNil | Logic::ReceiverIsArg | Logic::ArgIsReceiver | Logic::ArgEqualsReceiver | Logic::ArgIsAncestor | Logic::Env
 
       # Variables and special types that is subject for substitution
       #

data/sig/steep/cli.rbs

@@ -24,6 +24,8 @@ module Steep
 
     def handle_jobs_option: (Drivers::Utils::JobsOption jobs_option, OptionParser opts) -> void
 
+    def setup_jobs_for_ci: (Drivers::Utils::JobsOption) -> void
+
     def process_init: () -> Integer
 
     def process_check: () -> Integer