steep 1.9.4 → 1.10.0.pre.1

data/lib/steep/server/worker_process.rb

@@ -8,32 +8,30 @@ module Steep
       attr_reader :name
       attr_reader :wait_thread
       attr_reader :index
+      attr_reader :io_socket
 
-      def initialize(reader:, writer:, stderr:, wait_thread:, name:, index: nil)
+      def initialize(reader:, writer:, io_socket: nil, stderr:, wait_thread:, name:, index: nil)
         @reader = reader
         @writer = writer
         @stderr = stderr
+        @io_socket = io_socket
         @wait_thread = wait_thread
         @name = name
         @index = index
       end
 
       def self.start_worker(type, name:, steepfile:, steep_command:, index: nil, delay_shutdown: false, patterns: [])
-        begin
-          unless steep_command
-            fork_worker(
-              type,
-              name: name,
-              steepfile: steepfile,
-              index: index,
-              delay_shutdown: delay_shutdown,
-              patterns: patterns
-            )
-          else
-            # Use `#spawn_worker`
-            raise NotImplementedError
-          end
-        rescue NotImplementedError
+        if Steep.can_fork? && !steep_command
+          fork_worker(
+            type,
+            name: name,
+            steepfile: steepfile,
+            index: index,
+            is_primary: index && (index[1] == 0 && index[0] >= 2),
+            delay_shutdown: delay_shutdown,
+            patterns: patterns
+          )
+        else
           spawn_worker(
             type,
             name: name,
@@ -46,9 +44,10 @@ module Steep
         end
       end
 
-      def self.fork_worker(type, name:, steepfile:, index:, delay_shutdown:, patterns:)
+      def self.fork_worker(type, name:, steepfile:, index:, delay_shutdown:, patterns:, is_primary:)
         stdin_in, stdin_out = IO.pipe
         stdout_in, stdout_out = IO.pipe
+        sock_master, sock_worker = UNIXSocket.socketpair if is_primary
 
         worker = Drivers::Worker.new(stdout: stdout_out, stdin: stdin_in, stderr: STDERR)
 
@@ -61,12 +60,14 @@ module Steep
           worker.index = this
         end
         worker.commandline_args = patterns
+        worker.io_socket = sock_worker
 
         pid = fork do
           Process.setpgid(0, 0)
           Steep.ui_logger.level = :fatal
           stdin_out.close
           stdout_in.close
+          sock_master&.close
           worker.run()
         end
 
@@ -81,6 +82,7 @@ module Steep
 
         stdin_in.close
         stdout_out.close
+        sock_worker&.close
 
         new(
           reader: reader,
@@ -88,7 +90,8 @@ module Steep
           stderr: STDERR,
           wait_thread: wait_thread,
           name: name,
-          index: index&.[](1)
+          index: index&.[](1),
+          io_socket: sock_master,
         )
       end
 
@@ -146,6 +149,10 @@ module Steep
         end
       end
 
+      def redirect_to(worker)
+        @writer = worker.writer
+      end
+
       def <<(message)
         writer.write(message)
       end
@@ -155,11 +162,11 @@ module Steep
       end
 
       def kill(force: false)
-        Steep.logger.tagged("WorkerProcess#kill@#{name}(#{wait_thread.pid})") do
+        Steep.logger.tagged("WorkerProcess#kill@#{name}(#{pid})") do
           begin
             signal = force ? :KILL : :TERM
             Steep.logger.debug("Sending signal SIG#{signal}...")
-            Process.kill(signal, wait_thread.pid)
+            Process.kill(signal, pid)
             Steep.logger.debug("Successfully sent the signal.")
           rescue Errno::ESRCH => error
             Steep.logger.debug("Failed #{error.inspect}")
@@ -171,6 +178,10 @@ module Steep
           end
         end
       end
+
+      def pid
+        wait_thread.pid
+      end
     end
   end
 end

data/lib/steep/services/completion_provider.rb

@@ -51,9 +51,17 @@ module Steep
             raise
           end
         end
+
+        def deprecated?
+          if AnnotationsHelper.deprecated_type_name?(full_name, env)
+            true
+          else
+            false
+          end
+        end
       end
 
-      SimpleMethodNameItem = _ = Struct.new(:identifier, :range, :receiver_type, :method_types, :method_member, :method_name, keyword_init: true) do
+      SimpleMethodNameItem = _ = Struct.new(:identifier, :range, :receiver_type, :method_types, :method_member, :method_name, :deprecated, keyword_init: true) do
         # @implements SimpleMethodNameItem
 
         def comment
@@ -640,13 +648,15 @@ module Steep
                   all_members.each do |member|
                     associated_decl = all_decls.find {|decl| decl.method_def.member == member } or next
                     overloads = method_entry.overloads.select {|overload| overload.method_defs.any? {|defn| defn.member == member }}
+                    annotations = associated_decl.method_def.member_annotations
                     items << SimpleMethodNameItem.new(
                       identifier: name,
                       range: range,
                       receiver_type: type,
                       method_name: associated_decl.method_name,
                       method_types: overloads.map {|overload| subtyping.factory.method_type_1(overload.method_type) },
-                      method_member: member
+                      method_member: member,
+                      deprecated: AnnotationsHelper.deprecated_annotation?(annotations) ? true : false
                     )
                   end
                 else

data/lib/steep/services/signature_service.rb

@@ -294,8 +294,8 @@ module Steep
           end
 
           unless errors.empty?
-            # Builder won't be used.
-            factory = AST::Types::Factory.new(builder: _ = nil)
+            errors.uniq! { |e| [e.class, e.message] }
+            factory = AST::Types::Factory.new(builder: RBS::DefinitionBuilder.new(env: env, ancestor_builder: builder))
             return errors.map {|error| Diagnostic::Signature.from_rbs_error(error, factory: factory) }
           end
 

data/lib/steep/services/type_check_service.rb

@@ -302,7 +302,22 @@ module Steep
       def self.type_check(source:, subtyping:, constant_resolver:, cursor:)
         annotations = source.annotations(block: source.node, factory: subtyping.factory, context: nil)
 
-        definition = subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name)
+        case annotations.self_type
+        when AST::Types::Name::Instance
+          module_name = annotations.self_type.name
+          module_type = AST::Types::Name::Singleton.new(name: module_name)
+          instance_type = annotations.self_type
+        when AST::Types::Name::Singleton
+          module_name = annotations.self_type.name
+          module_type = annotations.self_type
+          instance_type = annotations.self_type
+        else
+          module_name = AST::Builtin::Object.module_name
+          module_type = AST::Builtin::Object.module_type
+          instance_type = AST::Builtin::Object.instance_type
+        end
+
+        definition = subtyping.factory.definition_builder.build_instance(module_name)
 
         const_env = TypeInference::ConstantEnv.new(
           factory: subtyping.factory,
@@ -321,17 +336,17 @@ module Steep
         context = TypeInference::Context.new(
           block_context: nil,
           module_context: TypeInference::Context::ModuleContext.new(
-            instance_type: AST::Builtin::Object.instance_type,
-            module_type: AST::Builtin::Object.module_type,
+            instance_type: instance_type,
+            module_type: module_type,
             implement_name: nil,
             nesting: nil,
-            class_name: AST::Builtin::Object.module_name,
-            instance_definition: subtyping.factory.definition_builder.build_instance(AST::Builtin::Object.module_name),
-            module_definition: subtyping.factory.definition_builder.build_singleton(AST::Builtin::Object.module_name)
+            class_name: module_name,
+            instance_definition: subtyping.factory.definition_builder.build_instance(module_name),
+            module_definition: subtyping.factory.definition_builder.build_singleton(module_name)
           ),
           method_context: nil,
           break_context: nil,
-          self_type: AST::Builtin::Object.instance_type,
+          self_type: instance_type,
           type_env: type_env,
           call_context: TypeInference::MethodCall::TopLevelContext.new,
           variable_context: TypeInference::Context::TypeVariableContext.empty

data/lib/steep/signature/validator.rb

@@ -144,17 +144,39 @@ module Steep
             validate_type_application_constraints(name, type_params, type_args, location: type.location)
           end
         end
-
-        type.each_type do |child|
-          validate_type_application(child)
-        end
       end
 
       def validate_type(type)
         Steep.logger.debug { "#{Location.to_string type.location}: Validating #{type}..." }
 
         validator.validate_type(type, context: nil)
+        validate_type_0(type)
+      end
+
+      def validate_type_0(type)
         validate_type_application(type)
+
+        case type
+        when RBS::Types::ClassInstance, RBS::Types::Interface, RBS::Types::ClassSingleton, RBS::Types::Alias
+          type_name = type.name
+          if type.location
+            location = type.location[:name]
+          end
+        end
+
+        if type_name && location
+          validate_type_name_deprecation(type_name, location)
+        end
+
+        type.each_type do |child|
+          validate_type_0(child)
+        end
+      end
+
+      def validate_type_name_deprecation(type_name, location)
+        if (_, message = AnnotationsHelper.deprecated_type_name?(type_name, env))
+          @errors << Diagnostic::Signature::DeprecatedTypeName.new(type_name, message, location: location)
+        end
       end
 
       def ancestor_to_type(ancestor)
@@ -269,6 +291,9 @@ module Steep
           type_params.each do |type_param|
             param = checker.factory.type_param(type_param)
 
+            validate_type(type_param.upper_bound_type) if type_param.upper_bound_type
+            validate_type(type_param.default_type) if type_param.default_type
+
             default_type = param.default_type or next
             upper_bound = param.upper_bound or next
 
@@ -296,6 +321,16 @@ module Steep
             args: entry.type_params.map { AST::Types::Any.instance() }
           )
 
+          entry.decls.each do |decl|
+            ast = decl.decl
+
+            unless AnnotationsHelper.deprecated_annotation?(ast.annotations)
+              if location = ast.location
+                validate_type_name_deprecation(name, location[:name])
+              end
+            end
+          end
+
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
               upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds| #$ Hash[Symbol, AST::Types::t?]
@@ -353,6 +388,20 @@ module Steep
                     case ancestor
                     when RBS::Definition::Ancestor::Instance
                       validate_ancestor_application(name, ancestor)
+                      location =
+                        case ancestor.source
+                        when :super
+                          if (primary_decl = entry.primary.decl).is_a?(RBS::AST::Declarations::Class)
+                            primary_decl.super_class&.location
+                          end
+                        when nil
+                          # skip
+                        else
+                          ancestor.source.location
+                        end
+                      if location
+                        validate_type_name_deprecation(ancestor.name, location)
+                      end
                     end
                   end
 
@@ -632,6 +681,9 @@ module Steep
         rescue_validation_errors(name) do
           Steep.logger.debug "Validating class/module alias `#{name}`..."
           validator.validate_class_alias(entry: entry)
+          if location = entry.decl.location
+            validate_type_name_deprecation(entry.decl.old_name, location[:old_name])
+          end
         end
       end
 

data/lib/steep/source.rb

@@ -498,6 +498,8 @@ module Steep
             # Skip
           when :kwargs
             # skip
+          when :when
+            # skip
           when :pair
             key, value = node.children
             key = insert_type_node(key, comments.except(last_line))
@@ -644,7 +646,7 @@ module Steep
         receiver_node, name, _, location = deconstruct_send_node!(send_node)
 
         if receiver_node
-          if location.dot
+          if location.dot && location.selector
             location.selector.line
           end
         else

data/lib/steep/subtyping/check.rb

@@ -285,11 +285,6 @@ module Steep
             )
           end
 
-        when relation.sub_type.is_a?(AST::Types::Self) && !self_type.is_a?(AST::Types::Self)
-          Expand(relation) do
-            check_type(Relation.new(sub_type: self_type, super_type: relation.super_type))
-          end
-
         when relation.sub_type.is_a?(AST::Types::Instance) && !instance_type.is_a?(AST::Types::Instance)
           Expand(relation) do
             check_type(Relation.new(sub_type: instance_type, super_type: relation.super_type))
@@ -419,6 +414,11 @@ module Steep
             end
           end
 
+        when relation.sub_type.is_a?(AST::Types::Self) && !self_type.is_a?(AST::Types::Self)
+          Expand(relation) do
+            check_type(Relation.new(sub_type: self_type, super_type: relation.super_type))
+          end
+
         when relation.super_type.is_a?(AST::Types::Name::Interface)
           Expand(relation) do
             check_interface(
@@ -493,7 +493,7 @@ module Steep
           end
 
         when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
-          if relation.sub_type.types.size >= relation.super_type.types.size
+          if relation.sub_type.types.size == relation.super_type.types.size
             pairs = relation.sub_type.types.take(relation.super_type.types.size).zip(relation.super_type.types)
 
             All(relation) do |result|
@@ -541,21 +541,28 @@ module Steep
 
         when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
           All(relation) do |result|
+            unchecked_keys = Set.new(relation.sub_type.elements.each_key)
+
             relation.super_type.elements.each_key do |key|
-              super_element_type = relation.super_type.elements[key]
+              super_element_type = relation.super_type.elements.fetch(key) #: AST::Types::t
+              sub_element_type = relation.sub_type.elements.fetch(key, nil) #: AST::Types::t?
 
-              if relation.sub_type.elements.key?(key)
-                sub_element_type = relation.sub_type.elements[key]
+              if relation.super_type.required?(key)
+                rel = Relation.new(sub_type: sub_element_type || AST::Builtin.nil_type, super_type: super_element_type)
+                result.add(rel) { check_type(rel) }
               else
-                if relation.super_type.required?(key)
-                  sub_element_type = AST::Builtin.nil_type
+                # If the key is optional, it's okay to not have the key
+                if sub_element_type
+                  rel = Relation.new(sub_type: sub_element_type, super_type: super_element_type)
+                  result.add(rel) { check_type(rel) }
                 end
               end
 
-              if sub_element_type
-                rel = Relation.new(sub_type: sub_element_type, super_type: super_element_type)
-                result.add(rel) { check_type(rel) }
-              end
+              unchecked_keys.delete(key)
+            end
+
+            unless unchecked_keys.empty?
+              return Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
             end
           end
 
@@ -601,7 +608,6 @@ module Steep
           Expand(relation) do
             check_type(Relation.new(sub_type: relation.sub_type.back_type, super_type: relation.super_type))
           end
-
         else
           Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
         end