steep 0.33.0 → 0.38.0

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

@@ -111,7 +111,8 @@ module Steep
                 hover_provider: true,
                 completion_provider: LSP::Interface::CompletionOptions.new(
                   trigger_characters: [".", "@"]
-                )
+                ),
+                workspace_symbol_provider: true
               )
             )
           }
@@ -143,6 +144,9 @@ module Steep
         when "textDocument/open"
           # Ignores open notification
 
+        when "workspace/symbol"
+          signature_worker << message
+
         when "shutdown"
           queue << { id: id, result: nil }
           @shutdown_request_id = id

data/lib/steep/server/signature_worker.rb

@@ -24,7 +24,12 @@ module Steep
       def enqueue_target(target:, timestamp:)
         Steep.logger.debug "queueing target #{target.name}@#{timestamp}"
         last_target_validated_at[target] = timestamp
-        queue << [target, timestamp]
+        queue << [:validate, [target, timestamp]]
+      end
+
+      def enqueue_symbol(id:, query:)
+        Steep.logger.debug "queueing symbol #{query} (#{id})"
+        queue << [:symbol, [id, query]]
       end
 
       def handle_request(request)
@@ -37,6 +42,8 @@ module Steep
         when "textDocument/didChange"
           update_source(request)
           validate_signature_if_required(request)
+        when "workspace/symbol"
+          enqueue_symbol(query: request[:params][:query], id: request[:id])
         end
       end
 
@@ -138,13 +145,63 @@ module Steep
         end
       end
 
+      def handle_workspace_symbol(query:, id:)
+        provider = Index::SignatureSymbolProvider.new()
+
+        project.targets.each do |target|
+          case target.status
+          when Project::Target::TypeCheckStatus
+            index = Index::RBSIndex.new()
+
+            builder = Index::RBSIndex::Builder.new(index: index)
+            builder.env(target.status.environment)
+
+            provider.indexes << index
+          end
+        end
+
+        symbols = provider.query_symbol(query)
+
+        result = symbols.map do |symbol|
+          {
+            name: symbol.name.to_s,
+            kind: symbol.kind,
+            deprecated: false,
+            containerName: symbol.container_name.to_s,
+            location: {
+              uri: URI.parse(project.absolute_path(symbol.location.buffer.name).to_s),
+              range: {
+                start: LSP::Interface::Position.new(
+                  line: symbol.location.start_line - 1,
+                  character: symbol.location.start_column,
+                  ),
+                end: LSP::Interface::Position.new(
+                  line: symbol.location.end_line - 1,
+                  character: symbol.location.end_column
+                )
+              }
+            }
+          }
+        end
+
+        writer.write(id: id, result: result)
+      end
+
       def handle_job(job)
-        target, timestamp = job
+        action, data = job
+
+        case action
+        when :validate
+          target, timestamp = data
 
-        if active_job?(target, timestamp)
-          validate_signature(target, timestamp: timestamp)
-        else
-          Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
+          if active_job?(target, timestamp)
+            validate_signature(target, timestamp: timestamp)
+          else
+            Steep.logger.info "Skipping signature validation: #{target.name}, queued timestamp=#{timestamp}, latest timestamp=#{last_target_validated_at[target]}"
+          end
+        when :symbol
+          id, query = data
+          handle_workspace_symbol(query: query, id: id)
         end
       end
     end

data/lib/steep/subtyping/check.rb

@@ -127,6 +127,24 @@ module Steep
         Result::Failure.new(error: error, trace: trace)
       end
 
+      def true_type?(type)
+        case type
+        when AST::Types::Literal
+          type.value == true
+        else
+          AST::Builtin::TrueClass.instance_type?(type)
+        end
+      end
+
+      def false_type?(type)
+        case type
+        when AST::Types::Literal
+          type.value == false
+        else
+          AST::Builtin::FalseClass.instance_type?(type)
+        end
+      end
+
       def check0(relation, self_type:, assumption:, trace:, constraints:)
         # puts relation
         trace.type(relation.sub_type, relation.super_type) do
@@ -146,9 +164,28 @@ module Steep
           when relation.sub_type.is_a?(AST::Types::Bot)
             success(constraints: constraints)
 
-          when relation.super_type.is_a?(AST::Types::Boolean)
+          when relation.sub_type.is_a?(AST::Types::Logic::Base) && (true_type?(relation.super_type) || false_type?(relation.super_type))
             success(constraints: constraints)
 
+          when relation.super_type.is_a?(AST::Types::Boolean)
+            check(
+              Relation.new(sub_type: relation.sub_type, super_type: AST::Types::Union.build(types: [AST::Builtin.true_type, AST::Builtin.false_type])),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
+
+          when relation.sub_type.is_a?(AST::Types::Boolean)
+            check(
+              Relation.new(sub_type: AST::Types::Union.build(types: [AST::Builtin.true_type, AST::Builtin.false_type]),
+                           super_type: relation.super_type),
+              self_type: self_type,
+              assumption: assumption,
+              trace: trace,
+              constraints: constraints
+            )
+
           when relation.sub_type.is_a?(AST::Types::Self) && !self_type.is_a?(AST::Types::Self)
             check(
               Relation.new(sub_type: self_type, super_type: relation.super_type),
@@ -282,17 +319,20 @@ module Steep
             end
 
           when relation.sub_type.is_a?(AST::Types::Proc) && relation.super_type.is_a?(AST::Types::Proc)
-            check_method_params(:__proc__,
-                                relation.sub_type.params, relation.super_type.params,
-                                self_type: self_type,
-                                assumption: assumption,
-                                trace: trace,
-                                constraints: constraints).then do
-              check(Relation.new(sub_type: relation.sub_type.return_type, super_type: relation.super_type.return_type),
-                     self_type: self_type,
-                     assumption: assumption,
-                     trace: trace,
-                     constraints: constraints)
+            name = :__proc__
+
+            sub_type = relation.sub_type
+            super_type = relation.super_type
+
+            check_method_params(name, sub_type.type.params, super_type.type.params, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
+              check_block_given(name, sub_type.block, super_type.block, trace: trace, constraints: constraints).then do
+                check_block_params(name, sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
+                  check_block_return(sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints:constraints).then do
+                    relation = Relation.new(super_type: super_type.type.return_type, sub_type: sub_type.type.return_type)
+                    check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+                  end
+                end
+              end
             end
 
           when relation.sub_type.is_a?(AST::Types::Tuple) && relation.super_type.is_a?(AST::Types::Tuple)
@@ -326,23 +366,21 @@ module Steep
                   constraints: constraints)
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Record)
-            if Set.new(relation.sub_type.elements.keys).superset?(Set.new(relation.super_type.elements.keys))
-              keys = relation.super_type.elements.keys
-              type_pairs = keys.map {|key| [relation.sub_type.elements[key], relation.super_type.elements[key]] }
-              results = type_pairs.flat_map do |t1, t2|
-                relation = Relation.new(sub_type: t1, super_type: t2)
-                [check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints),
-                 check(relation.flip, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)]
-              end
+            keys = relation.super_type.elements.keys
+            relations = keys.map {|key|
+              Relation.new(
+                sub_type: relation.sub_type.elements[key] || AST::Builtin.nil_type,
+                super_type: relation.super_type.elements[key]
+              )
+            }
+            results = relations.map do |relation|
+              check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
+            end
 
-              if results.all?(&:success?)
-                success(constraints: constraints)
-              else
-                results.find(&:failure?)
-              end
+            if results.all?(&:success?)
+              success(constraints: constraints)
             else
-              failure(error: Result::Failure::UnknownPairError.new(relation: relation),
-                      trace: trace)
+              results.find(&:failure?)
             end
 
           when relation.sub_type.is_a?(AST::Types::Record) && relation.super_type.is_a?(AST::Types::Name::Base)
@@ -665,12 +703,12 @@ module Steep
 
       def check_method_type(name, sub_type, super_type, self_type:, assumption:, trace:, constraints:)
         Steep.logger.tagged("#{name}: #{sub_type} <: #{super_type}") do
-          check_method_params(name, sub_type.params, super_type.params, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
+          check_method_params(name, sub_type.type.params, super_type.type.params, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
             check_block_given(name, sub_type.block, super_type.block, trace: trace, constraints: constraints).then do
               check_block_params(name, sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints).then do
                 check_block_return(sub_type.block, super_type.block, self_type: self_type, assumption: assumption, trace: trace, constraints:constraints).then do
-                  relation = Relation.new(super_type: super_type.return_type,
-                                          sub_type: sub_type.return_type)
+                  relation = Relation.new(super_type: super_type.type.return_type,
+                                          sub_type: sub_type.type.return_type)
                   check(relation, self_type: self_type, assumption: assumption, trace: trace, constraints: constraints)
                 end
               end
@@ -715,10 +753,10 @@ module Steep
 
       def match_method_type(name, sub_type, super_type, trace:)
         [].tap do |pairs|
-          match_params(name, sub_type.params, super_type.params, trace: trace).yield_self do |result|
+          match_params(name, sub_type.type.params, super_type.type.params, trace: trace).yield_self do |result|
             return result unless result.is_a?(Array)
             pairs.push(*result)
-            pairs.push [sub_type.return_type, super_type.return_type]
+            pairs.push [sub_type.type.return_type, super_type.type.return_type]
 
             case
             when !super_type.block && !sub_type.block