steep 0.31.0 → 0.35.0

data/lib/steep/drivers/vendor.rb

@@ -18,26 +18,7 @@ module Steep
       end
 
       def run
-        stdout.puts "Vendoring into #{vendor_dir}..."
-
-        vendorer = RBS::Vendorer.new(vendor_dir: vendor_dir)
-
-        if clean_before
-          stdout.puts "  Cleaning directory..."
-          vendorer.clean!
-        end
-
-        stdout.puts "  Vendoring standard libraries..."
-        vendorer.stdlib!
-
-        if defined?(Bundler)
-          Bundler.locked_gems.specs.each do |spec|
-            if RBS::EnvironmentLoader.gem_sig_path(spec.name, spec.version.to_s).directory?
-              stdout.puts "  Vendoring rubygem: #{spec.full_name}..."
-              vendorer.gem! spec.name, spec.version.to_s
-            end
-          end
-        end
+        stdout.puts "`steep vendor` is deprecated. Use `rbs vendor` command directly"
 
         0
       end

data/lib/steep/errors.rb

@@ -101,20 +101,6 @@ module Steep
       end
     end
 
-    class IncompatibleBlockParameters < Base
-      attr_reader :node
-      attr_reader :method_type
-
-      def initialize(node:, method_type:)
-        super(node: node)
-        @method_type = method_type
-      end
-
-      def to_s
-        "#{location_to_str}: IncompatibleBlockParameters: method_type=#{method_type}"
-      end
-    end
-
     class BlockParameterTypeMismatch < Base
       attr_reader :expected
       attr_reader :actual
@@ -186,7 +172,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: RequiredBlockMissing: method_type=#{method_type.location&.source}"
+        "#{location_to_str}: RequiredBlockMissing: method_type=#{method_type.to_s}"
       end
     end
 
@@ -557,5 +543,23 @@ module Steep
         "#{location_to_str}: UnsupportedSyntax: #{msg}"
       end
     end
+
+    class UnexpectedError < Base
+      attr_reader :message
+      attr_reader :error
+
+      def initialize(node:, error:)
+        super(node: node)
+        @error = error
+        @message = error.message
+      end
+
+      def to_s
+        <<-MESSAGE
+#{location_to_str}: UnexpectedError: #{error.class}
+>> #{message}
+        MESSAGE
+      end
+    end
   end
 end

data/lib/steep/interface/method_type.rb

@@ -774,16 +774,14 @@ module Steep
       attr_reader :params
       attr_reader :block
       attr_reader :return_type
-      attr_reader :location
-      attr_reader :method_def
+      attr_reader :method_decls
 
-      def initialize(type_params:, params:, block:, return_type:, location:, method_def:)
+      def initialize(type_params:, params:, block:, return_type:, method_decls:)
         @type_params = type_params
         @params = params
         @block = block
         @return_type = return_type
-        @location = location
-        @method_def = method_def
+        @method_decls = method_decls
       end
 
       def ==(other)
@@ -791,9 +789,7 @@ module Steep
           other.type_params == type_params &&
           other.params == params &&
           other.block == block &&
-          other.return_type == return_type &&
-          (!other.method_def || !method_def || other.method_def == method_def) &&
-          (!other.location || !location || other.location == location)
+          other.return_type == return_type
       end
 
       alias eql? ==
@@ -824,8 +820,7 @@ module Steep
           params: params.subst(s_),
           block: block&.subst(s_),
           return_type: return_type.subst(s_),
-          method_def: method_def,
-          location: location
+          method_decls: method_decls
         )
       end
 
@@ -847,17 +842,15 @@ module Steep
                        params: params.subst(s),
                        block: block&.subst(s),
                        return_type: return_type.subst(s),
-                       location: location,
-                       method_def: method_def)
+                       method_decls: method_decls)
       end
 
-      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, location: self.location,  method_def: self.method_def)
+      def with(type_params: self.type_params, params: self.params, block: self.block, return_type: self.return_type, method_decls: self.method_decls)
         self.class.new(type_params: type_params,
                        params: params,
                        block: block,
                        return_type: return_type,
-                       method_def: method_def,
-                       location: location)
+                       method_decls: method_decls)
       end
 
       def to_s
@@ -873,8 +866,7 @@ module Steep
                        params: params.map_type(&block),
                        block: self.block&.yield_self {|blk| blk.map_type(&block) },
                        return_type: yield(return_type),
-                       location: location,
-                       method_def: method_def)
+                       method_decls: method_decls)
       end
 
       # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
@@ -902,8 +894,7 @@ module Steep
           return_type: AST::Types::Union.build(
             types: [return_type.subst(s1),other.return_type.subst(s2)]
           ),
-          method_def: method_def,
-          location: nil
+          method_decls: method_decls + other.method_decls
         )
       end
 
@@ -958,8 +949,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
-          method_def: nil,
-          location: nil
+          method_decls: method_decls + other.method_decls
         )
       end
 
@@ -1006,8 +996,7 @@ module Steep
           block: block,
           return_type: return_type,
           type_params: type_params,
-          method_def: nil,
-          location: nil
+          method_decls: method_decls + other.method_decls
         )
       end
     end

data/lib/steep/method_name.rb

@@ -0,0 +1,28 @@
+module Steep
+  InstanceMethodName = Struct.new(:type_name, :method_name, keyword_init: true) do
+    def to_s
+      "#{type_name}##{method_name}"
+    end
+  end
+
+  SingletonMethodName = Struct.new(:type_name, :method_name, keyword_init: true) do
+    def to_s
+      "#{type_name}.#{method_name}"
+    end
+  end
+
+  module ::Kernel
+    def MethodName(string)
+      case string
+      when /#/
+        type_name, method_name = string.split(/#/, 2)
+        InstanceMethodName.new(type_name: TypeName(type_name), method_name: method_name.to_sym)
+      when /\./
+        type_name, method_name = string.split(/\./, 2)
+        SingletonMethodName.new(type_name: TypeName(type_name), method_name: method_name.to_sym)
+      else
+        raise "Unexpected method name: #{string}"
+      end
+    end
+  end
+end

data/lib/steep/project/completion_provider.rb

@@ -10,9 +10,27 @@ module Steep
 
       InstanceVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
       LocalVariableItem = Struct.new(:identifier, :range, :type, keyword_init: true)
-      MethodNameItem = Struct.new(:identifier, :range, :method_def, :method_type, :inherited_method, keyword_init: true) do
+      MethodNameItem = Struct.new(:identifier, :range, :receiver_type, :method_type, :method_decls, keyword_init: true) do
         def comment
-          method_def&.comment
+          case method_decls.size
+          when 0
+            nil
+          when 1
+            method_decls.to_a.first.method_def&.comment
+          else
+            nil
+          end
+        end
+
+        def inherited?
+          case receiver_type
+          when AST::Types::Name::Instance, AST::Types::Name::Singleton, AST::Types::Name::Interface
+            method_decls.any? do |decl|
+              decl.method_name.type_name != receiver_type.name
+            end
+          else
+            false
+          end
         end
       end
 
@@ -245,15 +263,15 @@ module Steep
                 items << MethodNameItem.new(
                   identifier: name,
                   range: range,
-                  method_def: method_type.method_def,
-                  method_type: method_type.method_def&.type || subtyping.factory.method_type_1(method_type, self_type: type),
-                  inherited_method: inherited_method?(method_type.method_def, type)
+                  receiver_type: type,
+                  method_type: subtyping.factory.method_type_1(method_type, self_type: type),
+                  method_decls: method_type.method_decls
                 )
               end
             end
           end
         end
-      rescue
+      rescue RuntimeError => exn
         # nop
       end
 
@@ -298,15 +316,6 @@ module Steep
         index
       end
 
-      def inherited_method?(method_def, type)
-        case type
-        when AST::Types::Name::Instance, AST::Types::Name::Singleton, AST::Types::Name::Interface
-          method_def.implemented_in != type.name
-        else
-          false
-        end
-      end
-
       def disallowed_method?(name)
         # initialize isn't invoked by developers when creating
         # instances of new classes, so don't show it as

data/lib/steep/project/dsl.rb

@@ -7,12 +7,12 @@ module Steep
         attr_reader :libraries
         attr_reader :signatures
         attr_reader :ignored_sources
-        attr_reader :no_builtin
         attr_reader :vendor_dir
         attr_reader :strictness_level
         attr_reader :typing_option_hash
+        attr_reader :repo_paths
 
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [])
+        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [])
           @name = name
           @sources = sources
           @libraries = libraries
@@ -21,6 +21,7 @@ module Steep
           @vendor_dir = nil
           @strictness_level = :default
           @typing_option_hash = {}
+          @repo_paths = []
         end
 
         def initialize_copy(other)
@@ -32,6 +33,7 @@ module Steep
           @vendor_dir = other.vendor_dir
           @strictness_level = other.strictness_level
           @typing_option_hash = other.typing_option_hash
+          @repo_paths = other.repo_paths.dup
         end
 
         def check(*args)
@@ -71,13 +73,14 @@ module Steep
 
         def vendor(dir = "vendor/sigs", stdlib: nil, gems: nil)
           if stdlib || gems
-            @vendor_dir = [
-              stdlib&.yield_self {|x| Pathname(x) },
-              gems&.yield_self {|x| Pathname(x) }
-            ]
-          else
-            @vendor_dir = Pathname(dir)
+            Steep.logger.warn { "#vendor with stdlib: or gems: keyword is deprecated." }
           end
+
+          @vendor_dir = Pathname(dir)
+        end
+
+        def repo_path(*paths)
+          @repo_paths.push(*paths.map {|s| Pathname(s) })
         end
       end
 
@@ -124,6 +127,8 @@ module Steep
           signature_patterns: target.signatures,
           options: Options.new.tap do |options|
             options.libraries.push(*target.libraries)
+            options.repository_paths.push(*target.repo_paths)
+            options.vendor_path = target.vendor_dir
 
             case target.strictness_level
             when :strict
@@ -133,15 +138,6 @@ module Steep
             end
 
             options.merge!(target.typing_option_hash)
-
-            case target.vendor_dir
-            when Array
-              options.vendored_stdlib_path = target.vendor_dir[0]
-              options.vendored_gems_path = target.vendor_dir[1]
-            when Pathname
-              options.vendored_stdlib_path = target.vendor_dir + "stdlib"
-              options.vendored_gems_path = target.vendor_dir + "gems"
-            end
           end
         ).tap do |target|
           project.targets << target

data/lib/steep/project/options.rb

@@ -5,16 +5,16 @@ module Steep
       attr_accessor :allow_missing_definitions
       attr_accessor :allow_unknown_constant_assignment
       attr_accessor :allow_unknown_method_calls
-      attr_accessor :vendored_stdlib_path
-      attr_accessor :vendored_gems_path
+      attr_accessor :vendor_path
       attr_reader :libraries
+      attr_reader :repository_paths
 
       def initialize
         apply_default_typing_options!
-        self.vendored_gems_path = nil
-        self.vendored_stdlib_path = nil
+        self.vendor_path = nil
 
         @libraries = []
+        @repository_paths = []
       end
 
       def apply_default_typing_options!

data/lib/steep/project/source_file.rb

@@ -66,7 +66,8 @@ module Steep
           break_context: nil,
           self_type: AST::Builtin::Object.instance_type,
           type_env: type_env,
-          lvar_env: lvar_env
+          lvar_env: lvar_env,
+          call_context: TypeInference::MethodCall::TopLevelContext.new
         )
 
         typing = Typing.new(source: source, root_context: context)

data/lib/steep/project/target.rb

@@ -114,18 +114,27 @@ module Steep
         end
       end
 
-      def environment
-        @environment ||= RBS::Environment.new().yield_self do |env|
-          stdlib_root = options.vendored_stdlib_path || RBS::EnvironmentLoader::STDLIB_ROOT
-          gem_vendor_path = options.vendored_gems_path
-          loader = RBS::EnvironmentLoader.new(stdlib_root: stdlib_root, gem_vendor_path: gem_vendor_path)
-          options.libraries.each do |lib|
-            loader.add(library: lib)
-          end
-          loader.load(env: env)
+      def self.construct_env_loader(options:)
+        repo = RBS::Repository.new(no_stdlib: options.vendor_path)
+        options.repository_paths.each do |path|
+          repo.add(path)
+        end
 
-          env.resolve_type_names
+        loader = RBS::EnvironmentLoader.new(
+          core_root: options.vendor_path ? nil : RBS::EnvironmentLoader::DEFAULT_CORE_ROOT,
+          repository: repo
+        )
+        loader.add(path: options.vendor_path) if options.vendor_path
+        options.libraries.each do |lib|
+          name, version = lib.split(/:/, 2)
+          loader.add(library: name, version: version)
         end
+
+        loader
+      end
+
+      def environment
+        @environment ||= RBS::Environment.from_loader(Target.construct_env_loader(options: options))
       end
 
       def load_signatures(validate:)

data/lib/steep/server/interaction_worker.rb

@@ -196,7 +196,7 @@ HOVER
             ),
             documentation: item.comment&.string,
             insert_text_format: LanguageServer::Protocol::Constant::InsertTextFormat::SNIPPET,
-            sort_text: item.inherited_method ? 'z' : 'a' # Ensure language server puts non-inherited methods before inherited methods
+            sort_text: item.inherited? ? 'z' : 'a' # Ensure language server puts non-inherited methods before inherited methods
           )
         when Project::CompletionProvider::InstanceVariableItem
           label = "#{item.identifier}: #{item.type}"

data/lib/steep/server/utils.rb

@@ -13,7 +13,7 @@ module Steep
         if range
           text = text.dup
 
-          buf = AST::Buffer.new(name: :_, content: text)
+          buf = RBS::Buffer.new(name: :_, content: text)
 
           start_pos = buf.loc_to_pos(range[:start].yield_self {|pos| [pos[:line]+1, pos[:character]] })
           end_pos = buf.loc_to_pos(range[:end].yield_self {|pos| [pos[:line]+1, pos[:character]] })

data/lib/steep/source.rb

@@ -65,11 +65,11 @@ module Steep
         parser.tokenize(buffer)
       end
 
-      buffer = AST::Buffer.new(name: path, content: source_code)
+      buffer = RBS::Buffer.new(name: path, content: source_code)
 
       comments.each do |comment|
         src = comment.text.gsub(/\A#\s*/, '')
-        location = AST::Location.new(buffer: buffer,
+        location = RBS::Location.new(buffer: buffer,
                                      start_pos: comment.location.expression.begin_pos + 1,
                                      end_pos: comment.location.expression.end_pos)
         annotation = AnnotationParser.new(factory: factory).parse(src, location: location)
@@ -107,7 +107,7 @@ module Steep
 
             if node.children[1]
               if node.loc.keyword.source == "if" || node.loc.keyword.source == "elsif"
-                then_start = node.loc.begin&.loc&.last_line || node.children[0].loc.last_line
+                then_start = node.loc.begin&.last_line || node.children[0].loc.last_line
                 then_end = node.children[2] ? node.loc.else.line : node.loc.last_line
               else
                 then_start = node.loc.else.last_line