steep 0.34.0 → 0.39.0

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/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:)
@@ -183,8 +192,8 @@ module Steep
             rescue RBS::DuplicatedDeclarationError => exn
               @status = SignatureValidationErrorStatus.new(
                 errors: [
-                  Signature::Errors::DuplicatedDefinitionError.new(
-                    name: exn.name,
+                  Signature::Errors::DuplicatedDeclarationError.new(
+                    type_name: exn.name,
                     location: exn.decls[0].location
                   )
                 ],

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/signature/errors.rb

@@ -19,16 +19,16 @@ module Steep
         end
       end
 
-      class DuplicatedDefinitionError < Base
-        attr_reader :name
+      class DuplicatedDeclarationError < Base
+        attr_reader :type_name
 
-        def initialize(name:, location:)
-          @name = name
+        def initialize(type_name:, location:)
+          @type_name = type_name
           @location = location
         end
 
         def puts(io)
-          io.puts "#{loc_to_s}\sDuplicatedDefinitionError: name=#{name}"
+          io.puts "#{loc_to_s}\sDuplicatedDeclarationError: name=#{type_name}"
         end
       end
 
@@ -76,6 +76,52 @@ module Steep
           io.puts "#{loc_to_s}\tInvalidMethodOverloadError: class_name=#{class_name}, method_name=#{method_name}"
         end
       end
+
+      class UnknownMethodAliasError < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          @class_name = class_name
+          @method_name = method_name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tUnknownMethodAliasError: class_name=#{class_name}, method_name=#{method_name}"
+        end
+      end
+
+      class DuplicatedMethodDefinitionError < Base
+        attr_reader :class_name
+        attr_reader :method_name
+
+        def initialize(class_name:, method_name:, location:)
+          @class_name = class_name
+          @method_name = method_name
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tDuplicatedMethodDefinitionError: class_name=#{class_name}, method_name=#{method_name}"
+        end
+      end
+
+      class RecursiveAliasError < Base
+        attr_reader :class_name
+        attr_reader :names
+        attr_reader :location
+
+        def initialize(class_name:, names:, location:)
+          @class_name = class_name
+          @names = names
+          @location = location
+        end
+
+        def puts(io)
+          io.puts "#{loc_to_s}\tRecursiveAliasError: class_name=#{class_name}, names=#{names.join(", ")}"
+        end
+      end
     end
   end
 end

data/lib/steep/signature/validator.rb

@@ -62,7 +62,7 @@ module Steep
       end
 
       def validate_one_class(name)
-        rescue_validation_errors do
+        rescue_validation_errors(name) do
           Steep.logger.debug "Validating class definition `#{name}`..."
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).each_type do |type|
@@ -76,7 +76,7 @@ module Steep
       end
 
       def validate_one_interface(name)
-        rescue_validation_errors do
+        rescue_validation_errors(name) do
           Steep.logger.debug "Validating interface `#{name}`..."
           Steep.logger.tagged "#{name}" do
             builder.build_interface(name).each_type do |type|
@@ -117,7 +117,7 @@ module Steep
 
       def validate_alias
         env.alias_decls.each do |name, entry|
-          rescue_validation_errors do
+          rescue_validation_errors(name) do
             Steep.logger.debug "Validating alias `#{name}`..."
             builder.expand_alias(name).tap do |type|
               validate_type(type)
@@ -126,7 +126,7 @@ module Steep
         end
       end
 
-      def rescue_validation_errors
+      def rescue_validation_errors(type_name = nil)
         yield
       rescue RBS::InvalidTypeApplicationError => exn
         @errors << Errors::InvalidTypeApplicationError.new(
@@ -146,6 +146,30 @@ module Steep
           method_name: exn.method_name,
           location: exn.members[0].location
         )
+      rescue RBS::DuplicatedMethodDefinitionError => exn
+        @errors << Errors::DuplicatedMethodDefinitionError.new(
+          class_name: type_name,
+          method_name: exn.method_name,
+          location: exn.location
+        )
+      rescue RBS::DuplicatedInterfaceMethodDefinitionError => exn
+        @errors << Errors::DuplicatedMethodDefinitionError.new(
+          class_name: type_name,
+          method_name: exn.method_name,
+          location: exn.member.location
+        )
+      rescue RBS::UnknownMethodAliasError => exn
+        @errors << Errors::UnknownMethodAliasError.new(
+          class_name: type_name,
+          method_name: exn.aliased_name,
+          location: exn.location
+        )
+      rescue RBS::RecursiveAliasDefinitionError => exn
+        @errors << Errors::RecursiveAliasError.new(
+          class_name: exn.type.name,
+          names: exn.defs.map(&:name),
+          location: exn.defs[0].original.location
+        )
       end
     end
   end

data/lib/steep/subtyping/check.rb

@@ -10,7 +10,7 @@ module Steep
       end
 
       def instance_super_types(type_name, args:)
-        ancestors = factory.definition_builder.one_instance_ancestors(type_name)
+        ancestors = factory.definition_builder.ancestor_builder.one_instance_ancestors(type_name)
 
         subst = unless args.empty?
                   args_ = args.map {|type| factory.type_1(type) }
@@ -50,7 +50,7 @@ module Steep
       end
 
       def singleton_super_types(type_name)
-        ancestors = factory.definition_builder.one_singleton_ancestors(type_name)
+        ancestors = factory.definition_builder.ancestor_builder.one_singleton_ancestors(type_name)
 
         ancestors.each_ancestor.map do |ancestor|
           name = ancestor.name
@@ -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