steep 0.47.1 → 0.49.1

data/lib/steep/ast/types/self.rb

@@ -22,6 +22,8 @@ module Steep
           "self"
         end
 
+        include Helper::NoChild
+
         def subst(s)
           s.self_type or raise "Unexpected substitution: #{inspect}"
         end

data/lib/steep/ast/types/top.rb

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [2]
         end

data/lib/steep/ast/types/tuple.rb

@@ -40,6 +40,10 @@ module Steep
 
         include Helper::ChildrenLevel
 
+        def each_child(&block)
+          types.each(&block)
+        end
+
         def level
           [0] + level_of_children(types)
         end

data/lib/steep/ast/types/union.rb

@@ -70,6 +70,10 @@ module Steep
           end
         end
 
+        def each_child(&block)
+          types.each(&block)
+        end
+
         include Helper::ChildrenLevel
 
         def level

data/lib/steep/ast/types/var.rb

@@ -21,17 +21,21 @@ module Steep
 
         alias eql? ==
 
-        def self.fresh(name)
+        def self.fresh_name(name)
           @mutex ||= Mutex.new
 
           @mutex.synchronize do
             @max ||= 0
             @max += 1
 
-            new(name: :"#{name}(#{@max})")
+            :"#{name}(#{@max})"
           end
         end
 
+        def self.fresh(name, location: nil)
+          new(name: fresh_name(name), location: location)
+        end
+
         def to_s
           name.to_s
         end
@@ -48,12 +52,21 @@ module Steep
           @fvs ||= Set.new([name])
         end
 
+        include Helper::NoChild
+
         def level
           [0]
         end
 
+        def update(name: self.name, location: self.location)
+          self.class.new(
+            name: name,
+            location: location
+          )
+        end
+
         def with_location(new_location)
-          self.class.new(name: name, location: new_location)
+          update(location: new_location)
         end
       end
     end

data/lib/steep/ast/types/void.rb

@@ -28,6 +28,8 @@ module Steep
 
         include Helper::NoFreeVariables
 
+        include Helper::NoChild
+
         def level
           [0]
         end

data/lib/steep/diagnostic/ruby.rb

@@ -26,20 +26,32 @@ module Steep
       end
 
       module ResultPrinter
-        def print_result_to(io, level: 1)
-          printer = Drivers::TracePrinter.new(io)
-          printer.print result.trace, level: level
-        end
-
-        def trace_lines
-          StringIO.new.tap do |io|
-            print_result_to(io)
-          end.string.chomp
+        def relation_message(relation)
+          case
+          when relation.type?
+            relation.to_s
+          when relation.method?
+            if relation.super_type.is_a?(Interface::MethodType) && relation.sub_type.is_a?(Interface::MethodType)
+              relation.to_s
+            end
+          when relation.interface?
+            nil
+          when relation.block?
+            nil
+          when relation.function?
+            nil
+          when relation.params?
+            nil
+          end
         end
 
         def detail_lines
           StringIO.new.tap do |io|
-            print_result_to(io)
+            result.failure_path&.reverse_each.map do |result|
+              relation_message(result.relation)
+            end.compact.each.with_index(1) do |message, index|
+              io.puts "#{"  " * (index)}#{message}"
+            end
           end.string.chomp
         end
       end
@@ -440,7 +452,7 @@ module Steep
           super(node: node)
           @interface_method = interface_method
           @annotation_method = annotation_method
-          @result = result
+          @result = relation
         end
       end
 
@@ -657,6 +669,19 @@ module Steep
         end
       end
 
+      class ProcTypeExpected < Base
+        attr_reader :type
+
+        def initialize(node:, type:)
+          super(node: node)
+          @type = type
+        end
+
+        def header_line
+          "Proc type is expected but `#{type.to_s}` is specified"
+        end
+      end
+
       class UnsupportedSyntax < Base
         attr_reader :message
 

data/lib/steep/diagnostic/signature.rb

@@ -101,6 +101,23 @@ module Steep
         end
       end
 
+      class UnsatisfiableTypeApplication < Base
+        attr_reader :type_name
+        attr_reader :type_arg
+        attr_reader :type_param
+
+        def initialize(type_name:, type_arg:, type_param:, location:)
+          super(location: location)
+          @type_name = type_name
+          @type_arg = type_arg
+          @type_param = type_param
+        end
+
+        def header_line
+          "Type application of `#{type_name}` doesn't satisfy the constraints: #{type_arg} <: #{type_param.upper_bound}"
+        end
+      end
+
       class InvalidMethodOverload < Base
         attr_reader :class_name
         attr_reader :method_name
@@ -307,6 +324,34 @@ module Steep
         end
       end
 
+      class RecursiveTypeAlias < Base
+        attr_reader :alias_names
+
+        def initialize(alias_names:, location:)
+          @alias_names = alias_names
+          super(location: location)
+        end
+
+        def header_line
+          "Type aliases cannot be *directly recursive*: #{alias_names.join(", ")}"
+        end
+      end
+
+      class NonregularTypeAlias < Base
+        attr_reader :type_name
+        attr_reader :nonregular_type
+
+        def initialize(type_name:, nonregular_type:, location:)
+          @type_name = type_name
+          @nonregular_type = nonregular_type
+          @location = location
+        end
+
+        def header_line
+          "Type alias #{type_name} is defined *non-regular*: #{nonregular_type}"
+        end
+      end
+
       def self.from_rbs_error(error, factory:)
         case error
         when RBS::ParsingError
@@ -388,6 +433,17 @@ module Steep
             type_name: error.type_name,
             member: error.member,
           )
+        when RBS::RecursiveTypeAliasError
+          Diagnostic::Signature::RecursiveTypeAlias.new(
+            alias_names: error.alias_names,
+            location: error.location
+          )
+        when RBS::NonregularTypeAliasError
+          Diagnostic::Signature::NonregularTypeAlias.new(
+            type_name: error.diagnostic.type_name,
+            nonregular_type: factory.type(error.diagnostic.nonregular_type),
+            location: error.location
+          )
         else
           raise error
         end

data/lib/steep/drivers/check.rb

@@ -214,8 +214,8 @@ module Steep
           total = errors.sum {|notification| notification[:diagnostics].size }
 
           errors.each do |notification|
-            path = project.relative_path(Pathname(URI.parse(notification[:uri]).path))
-            buffer = RBS::Buffer.new(name: path, content: path.read)
+            path = Pathname(URI.parse(notification[:uri]).path)
+            buffer = RBS::Buffer.new(name: project.relative_path(path), content: path.read)
             printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout)
 
             notification[:diagnostics].each do |diag|

data/lib/steep/interface/function.rb

@@ -952,6 +952,10 @@ module Steep
         )
       end
 
+      def each_child(&block)
+        each_type(&block)
+      end
+
       def each_type(&block)
         if block_given?
           params.each_type(&block)

data/lib/steep/interface/method_type.rb

@@ -77,7 +77,7 @@ module Steep
       end
 
       def to_s
-        type_params = !self.type_params.empty? ? "[#{self.type_params.map{|x| "#{x}" }.join(", ")}] " : ""
+        type_params = !self.type_params.empty? ? "[#{self.type_params.join(", ")}] " : ""
         params = type.params.to_s
         return_type = type.return_type
         block = self.block ? " #{self.block}" : ""
@@ -95,11 +95,9 @@ module Steep
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
       #
       def unify_overload(other)
-        type_params = []
-        s1 = Substitution.build(self.type_params)
-        type_params.push(*s1.dictionary.values.map(&:name))
-        s2 = Substitution.build(other.type_params)
-        type_params.push(*s2.dictionary.values.map(&:name))
+        type_params_1, s1 = TypeParam.rename(self.type_params)
+        type_params_2, s2 = TypeParam.rename(other.type_params)
+        type_params = type_params_1 + type_params_2
 
         block = case
                 when self.block && other.block
@@ -134,17 +132,12 @@ module Steep
       # Returns nil if self and other are incompatible.
       #
       def |(other)
-        self_type_params = Set.new(self.type_params)
-        other_type_params = Set.new(other.type_params)
-
-        unless (common_type_params = (self_type_params & other_type_params).to_a).empty?
-          fresh_types = common_type_params.map {|name| AST::Types::Var.fresh(name) }
-          fresh_names = fresh_types.map(&:name)
-          subst = Substitution.build(common_type_params, fresh_types)
-          other = other.instantiate(subst)
-          type_params = (self_type_params + (other_type_params - common_type_params + Set.new(fresh_names))).to_a
+        if other.type_params.empty?
+          type_params = self.type_params
         else
-          type_params = (self_type_params + other_type_params).to_a
+          other_params, s2 = TypeParam.rename(other.type_params)
+          other = other.instantiate(s2)
+          type_params = self.type_params + other_params
         end
 
         params = self.type.params & other.type.params or return
@@ -182,17 +175,12 @@ module Steep
       # Returns nil if self and other are incompatible.
       #
       def &(other)
-        self_type_params = Set.new(self.type_params)
-        other_type_params = Set.new(other.type_params)
-
-        unless (common_type_params = (self_type_params & other_type_params).to_a).empty?
-          fresh_types = common_type_params.map {|name| AST::Types::Var.fresh(name) }
-          fresh_names = fresh_types.map(&:name)
-          subst = Substitution.build(common_type_params, fresh_types)
-          other = other.subst(subst)
-          type_params = (self_type_params + (other_type_params - common_type_params + Set.new(fresh_names))).to_a
+        if other.type_params.empty?
+          type_params = self.type_params
         else
-          type_params = (self_type_params + other_type_params).to_a
+          other_params, s2 = TypeParam.rename(other.type_params)
+          other = other.instantiate(s2)
+          type_params = self.type_params + other_params
         end
 
         params = self.type.params | other.type.params

data/lib/steep/interface/type_param.rb

@@ -0,0 +1,103 @@
+module Steep
+  module Interface
+    class TypeParam
+      attr_reader :name
+      attr_reader :upper_bound
+      attr_reader :variance
+      attr_reader :unchecked
+      attr_reader :location
+
+      def initialize(name:, upper_bound:, variance:, unchecked:, location: nil)
+        @name = name
+        @upper_bound = upper_bound
+        @variance = variance
+        @unchecked = unchecked
+        @location = location
+      end
+
+      def ==(other)
+        other.is_a?(TypeParam) &&
+          other.name == name &&
+          other.upper_bound == upper_bound &&
+          other.variance == variance &&
+          other.unchecked == unchecked
+      end
+
+      alias eql? ==
+
+      def hash
+        name.hash ^ upper_bound.hash ^ variance.hash ^ unchecked.hash
+      end
+
+      def self.rename(params, conflicting_names = params.map(&:name))
+        unless conflicting_names.empty?
+          new_names = conflicting_names.map {|n| AST::Types::Var.fresh_name(n) }
+          hash = conflicting_names.zip(new_names).to_h
+          new_types = new_names.map {|n| AST::Types::Var.new(name: n) }
+
+          subst = Substitution.build(conflicting_names, new_types)
+
+          [
+            params.map do |param|
+              if hash.key?(param.name) || param.upper_bound
+                TypeParam.new(
+                  name: hash[param.name] || param.name,
+                  upper_bound: param.upper_bound&.subst(subst),
+                  variance: param.variance,
+                  unchecked: param.unchecked,
+                  location: param.location
+                )
+              else
+                param
+              end
+            end,
+            subst
+          ]
+        else
+          [params, Substitution.empty]
+        end
+      end
+
+      def to_s
+        buf = ""
+
+        if unchecked
+          buf << "unchecked "
+        end
+
+        case variance
+        when :covariant
+          buf << "out "
+        when :contravariant
+          buf << "in "
+        end
+
+        buf << name.to_s
+
+        if upper_bound
+          buf << " < #{upper_bound}"
+        end
+
+        buf
+      end
+
+      def update(name: self.name, upper_bound: self.upper_bound, variance: self.variance, unchecked: self.unchecked, location: self.location)
+        TypeParam.new(
+          name: name,
+          upper_bound: upper_bound,
+          variance: variance,
+          unchecked: unchecked,
+          location: location
+        )
+      end
+
+      def subst(s)
+        if u = upper_bound
+          update(upper_bound: u.subst(s))
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/steep/server/base_worker.rb

@@ -14,6 +14,7 @@ module Steep
         @writer = writer
         @skip_job = false
         @shutdown = false
+        @skip_jobs_after_shutdown = nil
       end
 
       def skip_jobs_after_shutdown!(flag = true)

data/lib/steep/server/interaction_worker.rb

@@ -338,7 +338,7 @@ HOVER
         else
           ps = params.each.map do |param|
             s = ""
-            if param.skip_validation
+            if param.unchecked?
               s << "unchecked "
             end
             case param.variance

data/lib/steep/server/type_check_worker.rb

@@ -144,7 +144,7 @@ module Steep
           if job.guid == current_type_check_guid
             Steep.logger.info { "Processing ValidateAppSignature for guid=#{job.guid}, path=#{job.path}" }
             service.validate_signature(path: project.relative_path(job.path)) do |path, diagnostics|
-              formatter = Diagnostic::LSPFormatter.new({})
+              formatter = Diagnostic::LSPFormatter.new({}, **{})
 
               writer.write(
                 method: :"textDocument/publishDiagnostics",
@@ -162,7 +162,7 @@ module Steep
           if job.guid == current_type_check_guid
             Steep.logger.info { "Processing ValidateLibrarySignature for guid=#{job.guid}, path=#{job.path}" }
             service.validate_signature(path: job.path) do |path, diagnostics|
-              formatter = Diagnostic::LSPFormatter.new({})
+              formatter = Diagnostic::LSPFormatter.new({}, **{})
 
               writer.write(
                 method: :"textDocument/publishDiagnostics",

data/lib/steep/services/signature_service.rb

@@ -224,7 +224,7 @@ module Steep
           Steep.measure "Loading new decls" do
             updated_files.each_value do |content|
               case decls = content.decls
-              when RBS::ErrorBase
+              when RBS::BaseError
                 errors << content.decls
               else
                 begin
@@ -283,7 +283,7 @@ module Steep
       def rescue_rbs_error(errors)
         begin
           yield
-        rescue RBS::ErrorBase => exn
+        rescue RBS::BaseError => exn
           errors << exn
         end
       end

data/lib/steep/services/type_check_service.rb

@@ -269,6 +269,8 @@ module Steep
       end
 
       def typecheck_source(path:, target: project.target_for_source_path(path), &block)
+        return unless target
+
         Steep.logger.tagged "#typecheck_source(path=#{path})" do
           Steep.measure "typecheck" do
             signature_service = signature_services[target.name]
@@ -366,7 +368,8 @@ module Steep
           self_type: AST::Builtin::Object.instance_type,
           type_env: type_env,
           lvar_env: lvar_env,
-          call_context: TypeInference::MethodCall::TopLevelContext.new
+          call_context: TypeInference::MethodCall::TopLevelContext.new,
+          variable_context: TypeInference::Context::TypeVariableContext.empty
         )
 
         typing = Typing.new(source: source, root_context: context)