steep 0.33.0 → 0.38.0

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

@@ -18,7 +18,7 @@ module Steep
           end
 
           def ==(other)
-            other.class ==self.class
+            other.class == self.class
           end
 
           alias eql? ==
@@ -57,6 +57,25 @@ module Steep
             @location = location
           end
         end
+
+        class Env < Base
+          attr_reader :truthy, :falsy
+
+          def initialize(truthy:, falsy:, location: nil)
+            @truthy = truthy
+            @falsy = falsy
+          end
+
+          def ==(other)
+            other.is_a?(Env) && other.truthy == truthy && other.falsy == falsy
+          end
+
+          alias eql? ==
+
+          def hash
+            self.class.hash ^ truthy.hash ^ falsy.hash
+          end
+        end
       end
     end
   end

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

@@ -3,68 +3,76 @@ module Steep
     module Types
       class Proc
         attr_reader :location
-        attr_reader :params
-        attr_reader :return_type
+        attr_reader :type
+        attr_reader :block
 
-        def initialize(params:, return_type:, location: nil)
+        def initialize(type:, block:, location: type.location)
+          @type = type
+          @block = block
           @location = location
-          @params = params
-          @return_type = return_type
         end
 
         def ==(other)
-          other.is_a?(self.class) &&
-            other.params == params &&
-            other.return_type == return_type
+          other.is_a?(self.class) && other.type == type && other.block == block
         end
 
         def hash
-          self.class.hash && params.hash && return_type.hash
+          self.class.hash ^ type.hash ^ block.hash
         end
 
         alias eql? ==
 
         def subst(s)
           self.class.new(
-            params: params.subst(s),
-            return_type: return_type.subst(s),
+            type: type.subst(s),
+            block: block&.subst(s),
             location: location
           )
         end
 
         def to_s
-          "^#{params} -> #{return_type}"
+          if block
+            "^#{type.params} #{block} -> #{type.return_type}"
+          else
+            "^#{type.params} -> #{type.return_type}"
+          end
         end
 
         def free_variables()
-          @fvs ||= Set.new.tap do |set|
-            set.merge(params.free_variables)
-            set.merge(return_type.free_variables)
+          @fvs ||= Set[].tap do |fvs|
+            fvs.merge(type.free_variables)
+            fvs.merge(block.free_variables) if block
           end
         end
 
         def level
-          children = params.each_type.to_a + [return_type]
+          children = type.params.each_type.to_a + [type.return_type]
+          if block
+            children.push(*block.type.params.each_type.to_a)
+            children.push(block.type.return_type)
+          end
           [0] + level_of_children(children)
         end
 
         def closed?
-          params.closed? && return_type.closed?
+          type.closed? && (block.nil? || block.closed?)
         end
 
         def with_location(new_location)
-          self.class.new(location: new_location, params: params, return_type: return_type)
+          self.class.new(location: new_location, block: block, type: type)
         end
 
         def map_type(&block)
           self.class.new(
-            params: params.map_type(&block),
-            return_type: yield(return_type),
+            type: type.map_type(&block),
+            block: self.block&.map_type(&block),
             location: location
           )
         end
 
         def one_arg?
+          params = type.params
+
           params.required.size == 1 &&
             params.optional.empty? &&
             !params.rest &&
@@ -78,6 +86,10 @@ module Steep
                              args: [],
                              location: location)
         end
+
+        def block_required?
+          block && !block.optional?
+        end
       end
     end
   end

data/lib/steep/cli.rb

@@ -16,7 +16,7 @@ module Steep
     end
 
     def self.available_commands
-      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :vendor]
+      [:init, :check, :validate, :annotations, :version, :project, :watch, :langserver, :stats]
     end
 
     def process_global_options
@@ -34,7 +34,7 @@ module Steep
 
     def setup_command
       @command = argv.shift&.to_sym
-      if CLI.available_commands.include?(@command) || @command == :worker
+      if CLI.available_commands.include?(@command) || @command == :worker || @command == :vendor
         true
       else
         stderr.puts "Unknown command: #{command}"
@@ -91,6 +91,19 @@ module Steep
       end.run
     end
 
+    def process_stats
+      Drivers::Stats.new(stdout: stdout, stderr: stderr).tap do |check|
+        OptionParser.new do |opts|
+          opts.banner = "Usage: steep stats [options] [sources]"
+
+          opts.on("--steepfile=PATH") {|path| check.steepfile = Pathname(path) }
+          handle_logging_options opts
+        end.parse!(argv)
+
+        check.command_line_patterns.push *argv
+      end.run
+    end
+
     def process_validate
       Drivers::Validate.new(stdout: stdout, stderr: stderr).tap do |command|
         OptionParser.new do |opts|

data/lib/steep/drivers/print_project.rb

@@ -47,6 +47,17 @@ module Steep
           target.options.libraries.each do |lib|
             stdout.puts "      - #{lib}"
           end
+          stdout.puts "    library dirs:"
+          Project::Target.construct_env_loader(options: target.options).tap do |loader|
+            loader.each_dir do |lib, path|
+              case lib
+              when :core
+                stdout.puts "      - core: #{path}"
+              else
+                stdout.puts "      - #{lib.name}: #{path}"
+              end
+            end
+          end
         end
 
         0

data/lib/steep/drivers/stats.rb

@@ -0,0 +1,85 @@
+require "csv"
+
+module Steep
+  module Drivers
+    class Stats
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :command_line_patterns
+
+      include Utils::DriverHelper
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+        @command_line_patterns = []
+      end
+
+      def run
+        project = load_config()
+
+        loader = Project::FileLoader.new(project: project)
+        loader.load_sources(command_line_patterns)
+        loader.load_signatures()
+
+        type_check(project)
+
+        stdout.puts(
+          CSV.generate do |csv|
+            csv << ["Target", "File", "Status", "Typed calls", "Untyped calls", "All calls", "Typed %"]
+
+            project.targets.each do |target|
+              case (status = target.status)
+              when Project::Target::TypeCheckStatus
+                status.type_check_sources.each do |source_file|
+                  case source_file.status
+                  when Project::SourceFile::TypeCheckStatus
+                    typing = source_file.status.typing
+
+                    typed = 0
+                    untyped = 0
+                    total = 0
+                    typing.method_calls.each_value do |call|
+                      case call
+                      when TypeInference::MethodCall::Typed
+                        typed += 1
+                      when TypeInference::MethodCall::Untyped
+                        untyped += 1
+                      end
+
+                      total += 1
+                    end
+
+                    csv << format_stats(target, source_file.path, "success", typed, untyped, total)
+                  when Project::SourceFile::TypeCheckErrorStatus
+                    csv << format_stats(target, source_file.path, "error", 0, 0, 0)
+                  else
+                    csv << format_stats(target, source_file.path, "unknown (#{source_file.status.class.to_s.split(/::/).last})", 0, 0, 0)
+                  end
+                end
+              end
+            end
+          end
+        )
+
+        0
+      end
+
+      def format_stats(target, path, status, typed, untyped, total)
+        [
+          target.name,
+          path.to_s,
+          status,
+          typed,
+          untyped,
+          total,
+          if total.nonzero?
+            format("%.2f", (typed.to_f/total)*100)
+          else
+            0
+          end
+        ]
+      end
+    end
+  end
+end

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
 
@@ -209,6 +195,25 @@ module Steep
       end
     end
 
+    class BlockBodyTypeMismatch < Base
+      attr_reader :expected
+      attr_reader :actual
+      attr_reader :result
+
+      include ResultPrinter
+
+      def initialize(node:, expected:, actual:, result:)
+        super(node: node)
+        @expected = expected
+        @actual = actual
+        @result = result
+      end
+
+      def to_s
+        "#{location_to_str}: BlockBodyTypeMismatch: expected=#{expected}, actual=#{actual}"
+      end
+    end
+
     class BreakTypeMismatch < Base
       attr_reader :expected
       attr_reader :actual
@@ -557,5 +562,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/index/rbs_index.rb

@@ -0,0 +1,334 @@
+module Steep
+  module Index
+    class RBSIndex
+      class TypeEntry
+        attr_reader :type_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(type_name:)
+          @type_name = type_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
+            declarations << decl
+          when RBS::AST::Declarations::Interface
+            declarations << decl
+          when RBS::AST::Declarations::Alias
+            declarations << decl
+          else
+            raise "Unexpected type declaration: #{decl}"
+          end
+
+          self
+        end
+
+        def add_reference(ref)
+          case ref
+          when RBS::AST::Members::MethodDefinition
+            references << ref
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            references << ref
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassInstanceVariable, RBS::AST::Members::ClassVariable
+            references << ref
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            references << ref
+          when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
+            references << ref
+          when RBS::AST::Declarations::Constant, RBS::AST::Declarations::Global
+            references << ref
+          when RBS::AST::Declarations::Alias
+            references << ref
+          else
+            raise "Unexpected type reference: #{ref}"
+          end
+
+          self
+        end
+      end
+
+      class MethodEntry
+        attr_reader :method_name
+        attr_reader :declarations
+        attr_reader :references
+
+        def initialize(method_name:)
+          @method_name = method_name
+          @declarations = Set[]
+          @references = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Members::MethodDefinition,
+            RBS::AST::Members::Alias,
+            RBS::AST::Members::AttrWriter,
+            RBS::AST::Members::AttrReader,
+            RBS::AST::Members::AttrAccessor
+            declarations << decl
+          else
+            raise "Unexpected method declaration: #{decl}"
+          end
+
+          self
+        end
+      end
+
+      class ConstantEntry
+        attr_reader :const_name
+        attr_reader :declarations
+
+        def initialize(const_name:)
+          @const_name = const_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Constant
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      class GlobalEntry
+        attr_reader :global_name
+        attr_reader :declarations
+
+        def initialize(global_name:)
+          @global_name = global_name
+          @declarations = Set[]
+        end
+
+        def add_declaration(decl)
+          case decl
+          when RBS::AST::Declarations::Global
+            declarations << decl
+          else
+            raise
+          end
+
+          self
+        end
+      end
+
+      attr_reader :type_index
+      attr_reader :method_index
+      attr_reader :const_index
+      attr_reader :global_index
+
+      def initialize()
+        @type_index = {}
+        @method_index = {}
+        @const_index = {}
+        @global_index = {}
+      end
+
+      def entry(type_name: nil, method_name: nil, const_name: nil, global_name: nil)
+        case
+        when type_name
+          type_index[type_name] ||= TypeEntry.new(type_name: type_name)
+        when method_name
+          method_index[method_name] ||= MethodEntry.new(method_name: method_name)
+        when const_name
+          const_index[const_name] ||= ConstantEntry.new(const_name: const_name)
+        when global_name
+          global_index[global_name] ||= GlobalEntry.new(global_name: global_name)
+        else
+          raise
+        end
+      end
+
+      def each_entry(&block)
+        if block_given?
+          type_index.each_value(&block)
+          method_index.each_value(&block)
+          const_index.each_value(&block)
+          global_index.each_value(&block)
+        else
+          enum_for(:each_entry)
+        end
+      end
+
+      def add_type_declaration(type_name, declaration)
+        entry(type_name: type_name).add_declaration(declaration)
+      end
+
+      def add_method_declaration(method_name, member)
+        entry(method_name: method_name).add_declaration(member)
+      end
+
+      def add_constant_declaration(const_name, decl)
+        entry(const_name: const_name).add_declaration(decl)
+      end
+
+      def add_global_declaration(global_name, decl)
+        entry(global_name: global_name).add_declaration(decl)
+      end
+
+      def each_declaration(type_name: nil, method_name: nil, const_name: nil, global_name: nil, &block)
+        if block
+          entry = entry(type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+          entry.declarations.each(&block)
+        else
+          enum_for(:each_declaration, type_name: type_name, method_name: method_name, const_name: const_name, global_name: global_name)
+        end
+      end
+
+      def add_type_reference(type_name, ref)
+        entry(type_name: type_name).add_reference(ref)
+      end
+
+      def each_reference(type_name: nil, &block)
+        if block
+          entry(type_name: type_name).references.each(&block)
+        else
+          enum_for(:each_reference, type_name: type_name)
+        end
+      end
+
+      class Builder
+        attr_reader :index
+
+        def initialize(index:)
+          @index = index
+        end
+
+        def member(type_name, member)
+          case member
+          when RBS::AST::Members::MethodDefinition
+            member.types.each do |method_type|
+              method_type.each_type do |type|
+                type_reference type, from: member
+              end
+            end
+
+            if member.instance?
+              method_name = InstanceMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.singleton?
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: member.name)
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
+            type_reference member.type, from: member
+
+            if member.is_a?(RBS::AST::Members::AttrReader) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: member.name)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: member.name)
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+            if member.is_a?(RBS::AST::Members::AttrWriter) || member.is_a?(RBS::AST::Members::AttrAccessor)
+              method_name = case member.kind
+                            when :instance
+                              InstanceMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            when :singleton
+                              SingletonMethodName.new(type_name: type_name, method_name: "#{member.name}=".to_sym)
+                            end
+              index.add_method_declaration(method_name, member)
+            end
+
+          when RBS::AST::Members::InstanceVariable, RBS::AST::Members::ClassVariable, RBS::AST::Members::ClassInstanceVariable
+            type_reference member.type, from: member
+
+          when RBS::AST::Members::Include, RBS::AST::Members::Extend
+            index.add_type_reference member.name, member
+            member.args.each do |type|
+              type_reference type, from: member
+            end
+
+          when RBS::AST::Members::Alias
+            if member.instance?
+              new_name = InstanceMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+
+            if member.singleton?
+              new_name = SingletonMethodName.new(type_name: type_name, method_name: member.new_name)
+              index.add_method_declaration(new_name, member)
+            end
+          end
+        end
+
+        def type_reference(type, from:)
+          case type
+          when RBS::Types::ClassInstance, RBS::Types::ClassSingleton, RBS::Types::Alias, RBS::Types::Interface
+            index.add_type_reference(type.name, from)
+          end
+
+          type.each_type do |ty|
+            type_reference ty, from: from
+          end
+        end
+
+        def env(env)
+          env.class_decls.each do |name, decl|
+            decl.decls.each do |d|
+              index.add_type_declaration(name, d.decl)
+
+              case d.decl
+              when RBS::AST::Declarations::Class
+                if super_class = d.decl.super_class
+                  index.add_type_reference(super_class.name, d.decl)
+                  super_class.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              when RBS::AST::Declarations::Module
+                d.decl.self_types.each do |self_type|
+                  index.add_type_reference(self_type.name, d.decl)
+                  self_type.args.each do |type|
+                    type_reference(type, from: d.decl)
+                  end
+                end
+              end
+
+              d.decl.members.each do |member|
+                member(name, member)
+              end
+            end
+          end
+
+          env.interface_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+
+            decl.decl.members.each do |member|
+              member(name, member)
+            end
+          end
+
+          env.alias_decls.each do |name, decl|
+            index.add_type_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.constant_decls.each do |name, decl|
+            index.add_constant_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+
+          env.global_decls.each do |name, decl|
+            index.add_global_declaration(name, decl.decl)
+            type_reference decl.decl.type, from: decl.decl
+          end
+        end
+      end
+    end
+  end
+end