steep 0.46.0 → 0.48.0

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
 

data/lib/steep/diagnostic/signature.rb

@@ -38,25 +38,16 @@ module Steep
         end
 
         def self.parser_syntax_error_message(exception)
-          value = if exception.error_value.is_a?(RBS::Parser::LocatedValue)
-                    exception.error_value.value
-                  else
-                    exception.error_value
-                  end
-          string = value.to_s
+          string = exception.location.source.to_s
           unless string.empty?
             string = " (#{string})"
           end
 
-          "Syntax error caused by token `#{exception.token_str}`#{string}"
+          "Syntax error caused by token `#{exception.token_type}`#{string}"
         end
 
         def header_line
-          if exception.is_a?(RBS::Parser::SyntaxError)
-            SyntaxError.parser_syntax_error_message(exception)
-          else
-            exception.message
-          end
+          exception.message
         end
       end
 
@@ -110,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
@@ -316,12 +324,38 @@ 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::Parser::SemanticsError, RBS::Parser::LexerError
+        when RBS::ParsingError
           Diagnostic::Signature::SyntaxError.new(error, location: error.location)
-        when RBS::Parser::SyntaxError
-          Diagnostic::Signature::SyntaxError.new(error, location: error.error_value.location)
         when RBS::DuplicatedDeclarationError
           Diagnostic::Signature::DuplicatedDeclaration.new(
             type_name: error.name,
@@ -399,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/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/project/dsl.rb

@@ -11,8 +11,12 @@ module Steep
         attr_reader :core_root
         attr_reader :repo_paths
         attr_reader :code_diagnostics_config
+        attr_reader :project
+        attr_reader :collection_config_path
 
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {})
+        NONE = Object.new.freeze
+
+        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: NONE)
           @name = name
           @sources = sources
           @libraries = libraries
@@ -22,6 +26,15 @@ module Steep
           @stdlib_root = nil
           @repo_paths = []
           @code_diagnostics_config = code_diagnostics_config
+          @project = project
+          @collection_config_path =
+            case collection_config_path
+            when NONE
+              path = project&.absolute_path(RBS::Collection::Config::PATH)
+              path&.exist? ? path : nil
+            else
+              collection_config_path
+            end
         end
 
         def initialize_copy(other)
@@ -34,6 +47,8 @@ module Steep
           @core_root = other.core_root
           @stdlib_root = other.stdlib_root
           @code_diagnostics_config = other.code_diagnostics_config.dup
+          @project = other.project
+          @collection_config_path = other.collection_config_path
         end
 
         def check(*args)
@@ -100,13 +115,14 @@ module Steep
           signatures.push(*args)
         end
 
-        def update(name: self.name, sources: self.sources, libraries: self.libraries, ignored_sources: self.ignored_sources, signatures: self.signatures)
+        def update(name: self.name, sources: self.sources, libraries: self.libraries, ignored_sources: self.ignored_sources, signatures: self.signatures, project: self.project)
           self.class.new(
             name,
             sources: sources,
             libraries: libraries,
             signatures: signatures,
-            ignored_sources: ignored_sources
+            ignored_sources: ignored_sources,
+            project: project,
           )
         end
 
@@ -155,6 +171,14 @@ module Steep
 
           yield code_diagnostics_config if block_given?
         end
+
+        def collection_config(path)
+          @collection_config_path = project.absolute_path(path)
+        end
+
+        def disable_collection
+          @collection_config_path = nil
+        end
       end
 
       attr_reader :project
@@ -187,10 +211,10 @@ module Steep
 
       def target(name, template: nil, &block)
         target = if template
-                   self.class.templates[template]&.dup&.update(name: name) or
+                   self.class.templates[template]&.dup&.update(name: name, project: project) or
                      raise "Unknown template: #{template}, available templates: #{@@templates.keys.join(", ")}"
                  else
-                   TargetDSL.new(name, code_diagnostics_config: Diagnostic::Ruby.default.dup)
+                   TargetDSL.new(name, code_diagnostics_config: Diagnostic::Ruby.default.dup, project: project)
                  end
 
         Steep.logger.tagged "target=#{name}" do
@@ -200,6 +224,8 @@ module Steep
         source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
         signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
 
+        collection_lock = target.collection_config_path&.then { |p| RBS::Collection::Config.lockfile_of(p) }
+
         Project::Target.new(
           name: target.name,
           source_pattern: source_pattern,
@@ -211,6 +237,7 @@ module Steep
               stdlib_root: target.stdlib_root,
               repo_paths: target.repo_paths
             )
+            options.collection_lock = collection_lock
           end,
           code_diagnostics_config: target.code_diagnostics_config
         ).tap do |target|

data/lib/steep/project/options.rb

@@ -13,6 +13,7 @@ module Steep
 
       attr_reader :libraries
       attr_accessor :paths
+      attr_accessor :collection_lock
 
       def initialize
         @paths = PathOptions.new(repo_paths: [])

data/lib/steep/project/target.rb

@@ -57,6 +57,7 @@ module Steep
           name, version = lib.split(/:/, 2)
           loader.add(library: name, version: version)
         end
+        loader.add_collection(options.collection_lock) if options.collection_lock
 
         loader
       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
@@ -383,7 +383,7 @@ HOVER
         when RBS::AST::Declarations::Interface
           "interface #{name_and_params(decl.name, decl.type_params)}"
         end
-    end
+      end
 
       def format_completion_item(item)
         range = LanguageServer::Protocol::Interface::Range.new(
@@ -402,18 +402,18 @@ HOVER
           LanguageServer::Protocol::Interface::CompletionItem.new(
             label: item.identifier,
             kind: LanguageServer::Protocol::Constant::CompletionItemKind::VARIABLE,
-            detail: "#{item.identifier}: #{item.type}",
+            detail: item.type.to_s,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
               range: range,
-              new_text: "#{item.identifier}"
+              new_text: item.identifier
             )
           )
         when Services::CompletionProvider::MethodNameItem
-          label = "def #{item.identifier}: #{item.method_type}"
           method_type_snippet = method_type_to_snippet(item.method_type)
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: label,
+            label: item.identifier,
             kind: LanguageServer::Protocol::Constant::CompletionItemKind::METHOD,
+            detail: item.method_type.to_s,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
               new_text: "#{item.identifier}#{method_type_snippet}",
               range: range
@@ -423,14 +423,14 @@ HOVER
             sort_text: item.inherited? ? 'z' : 'a' # Ensure language server puts non-inherited methods before inherited methods
           )
         when Services::CompletionProvider::InstanceVariableItem
-          label = "#{item.identifier}: #{item.type}"
           LanguageServer::Protocol::Interface::CompletionItem.new(
-            label: label,
+            label: item.identifier,
             kind: LanguageServer::Protocol::Constant::CompletionItemKind::FIELD,
+            detail: item.type.to_s,
             text_edit: LanguageServer::Protocol::Interface::TextEdit.new(
               range: range,
               new_text: item.identifier,
-              ),
+            ),
             insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET
           )
         end

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/hover_content.rb

@@ -74,6 +74,9 @@ module Steep
           locator = RBS::Locator.new(decls: decls)
           hd, tail = locator.find2(line: line, column: column)
 
+          # Maybe hover on comment
+          return if tail.nil?
+
           case type = tail[0]
           when RBS::Types::Alias
             alias_decl = service.latest_env.alias_decls[type.name]&.decl or raise

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

@@ -366,7 +366,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)