steep 0.34.0 → 0.39.0

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

@@ -23,7 +23,7 @@ module Steep
         end
 
         def to_s
-          "⟙"
+          "top"
         end
 
         include Helper::NoFreeVariables

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, :stats]
+      [: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}"

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/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

@@ -8,7 +8,18 @@ module Steep
       end
 
       def location_to_str
-        Rainbow("#{node.loc.expression.source_buffer.name}:#{node.loc.first_line}:#{node.loc.column}").red
+        file = Rainbow(node.loc.expression.source_buffer.name).cyan
+        line = Rainbow(node.loc.first_line).bright
+        column = Rainbow(node.loc.column).bright
+        "#{file}:#{line}:#{column}"
+      end
+
+      def format_message(message, class_name: self.class.name.split("::").last)
+        if message.empty?
+          "#{location_to_str}: #{Rainbow(class_name).red}"
+        else
+          "#{location_to_str}: #{Rainbow(class_name).red}: #{message}"
+        end
       end
 
       def print_to(io)
@@ -45,7 +56,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleAssignment: lhs_type=#{lhs_type}, rhs_type=#{rhs_type}"
+        format_message "lhs_type=#{lhs_type}, rhs_type=#{rhs_type}"
       end
     end
 
@@ -61,7 +72,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleArguments: receiver=#{receiver_type}, method_type=#{method_type}"
+        format_message "receiver=#{receiver_type}, method_type=#{method_type}"
       end
     end
 
@@ -79,7 +90,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnresolvedOverloading: receiver=#{receiver_type}, method_name=#{method_name}, method_types=#{method_types.join(" | ")}"
+        format_message "receiver=#{receiver_type}, method_name=#{method_name}, method_types=#{method_types.join(" | ")}"
       end
     end
 
@@ -97,7 +108,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: ArgumentTypeMismatch: receiver=#{receiver_type}, expected=#{expected}, actual=#{actual}"
+        format_message "receiver=#{receiver_type}, expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -112,7 +123,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BlockParameterTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -127,7 +138,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: NoMethodError: type=#{type}, method=#{method}"
+        format_message "type=#{type}, method=#{method}", class_name: "NoMethodError"
       end
     end
 
@@ -146,7 +157,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: ReturnTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -159,7 +170,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedBlockGiven: method_type=#{method_type}"
+        format_message "method_type=#{method_type}"
       end
     end
 
@@ -172,7 +183,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: RequiredBlockMissing: method_type=#{method_type.to_s}"
+        format_message "method_type=#{method_type}"
       end
     end
 
@@ -191,7 +202,26 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BlockTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
+      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
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
@@ -210,25 +240,25 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: BreakTypeMismatch: expected=#{expected}, actual=#{actual}"
+        format_message "expected=#{expected}, actual=#{actual}"
       end
     end
 
     class UnexpectedJump < Base
       def to_s
-        "#{location_to_str}: UnexpectedJump"
+        format_message ""
       end
     end
 
     class UnexpectedJumpValue < Base
       def to_s
-        "#{location_to_str}: UnexpectedJumpValue"
+        format_message ""
       end
     end
 
     class MethodArityMismatch < Base
       def to_s
-        "#{location_to_str}: MethodArityMismatch: method=#{node.children[0]}"
+        format_message "method=#{node.children[0]}"
       end
     end
 
@@ -247,7 +277,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleMethodTypeAnnotation: interface_method=#{interface_method.type_name}.#{interface_method.name}, annotation_method=#{annotation_method.name}"
+        format_message "interface_method=#{interface_method.type_name}.#{interface_method.name}, annotation_method=#{annotation_method.name}"
       end
     end
 
@@ -260,7 +290,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MethodDefinitionWithOverloading: method=#{method.name}, types=#{method.types.join(" | ")}"
+        format_message "method=#{method.name}, types=#{method.types.join(" | ")}"
       end
     end
 
@@ -279,7 +309,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MethodReturnTypeAnnotationMismatch: method_type=#{method_type.return_type}, annotation_type=#{annotation_type}"
+        format_message "method_type=#{method_type.return_type}, annotation_type=#{annotation_type}"
       end
     end
 
@@ -305,13 +335,13 @@ module Steep
                    prefix = node.children[0].type == :self ? "self" : "*"
                    "#{prefix}.#{node.children[1]}"
                  end
-        "#{location_to_str}: MethodBodyTypeMismatch: method=#{method}, expected=#{expected}, actual=#{actual}"
+        format_message "method=#{method}, expected=#{expected}, actual=#{actual}"
       end
     end
 
     class UnexpectedYield < Base
       def to_s
-        "#{location_to_str}: UnexpectedYield"
+        format_message ""
       end
     end
 
@@ -324,7 +354,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedSuper: method=#{method}"
+        format_message "method=#{method}"
       end
     end
 
@@ -337,7 +367,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleZuper: method=#{method}"
+        format_message "method=#{method}"
       end
     end
 
@@ -360,7 +390,7 @@ module Steep
                  when :module
                    "self.#{missing_method}"
                  end
-        "#{location_to_str}: MethodDefinitionMissing: module=#{module_name}, method=#{method}"
+        format_message "module=#{module_name}, method=#{method}"
       end
     end
 
@@ -375,7 +405,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedDynamicMethod: module=#{module_name}, method=#{method_name}"
+        format_message "module=#{module_name}, method=#{method_name}"
       end
     end
 
@@ -388,7 +418,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnknownConstantAssigned: type=#{type}"
+        format_message "type=#{type}"
       end
     end
 
@@ -398,7 +428,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: FallbackAny"
+        format_message ""
       end
     end
 
@@ -421,7 +451,7 @@ module Steep
       include ResultPrinter
 
       def to_s
-        "#{location_to_str}: UnsatisfiableConstraint: method_type=#{method_type}, constraint=#{sub_type} <: '#{var} <: #{super_type}"
+        format_message "method_type=#{method_type}, constraint=#{sub_type} <: '#{var} <: #{super_type}"
       end
     end
 
@@ -440,7 +470,7 @@ module Steep
       include ResultPrinter
 
       def to_s
-        "#{location_to_str}: IncompatibleAnnotation: var_name=#{var_name}, #{relation}"
+        format_message "var_name=#{var_name}, #{relation}"
       end
     end
 
@@ -459,7 +489,7 @@ module Steep
       include ResultPrinter
 
       def to_s
-        "#{location_to_str}: IncompatibleTypeCase: var_name=#{var_name}, #{relation}"
+        format_message "var_name=#{var_name}, #{relation}"
       end
     end
 
@@ -472,7 +502,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: ElseOnExhaustiveCase: type=#{type}"
+        format_message "type=#{type}"
       end
     end
 
@@ -485,7 +515,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedSplat: type=#{type}"
+        format_message "type=#{type}"
       end
     end
 
@@ -500,7 +530,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: IncompatibleTuple: expected_tuple=#{expected_tuple}"
+        format_message "expected_tuple=#{expected_tuple}"
       end
     end
 
@@ -513,7 +543,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: UnexpectedKeyword: #{unexpected_keywords.to_a.join(", ")}"
+        format_message unexpected_keywords.to_a.join(", ")
       end
     end
 
@@ -526,7 +556,7 @@ module Steep
       end
 
       def to_s
-        "#{location_to_str}: MissingKeyword: #{missing_keywords.to_a.join(", ")}"
+        format_message missing_keywords.to_a.join(", ")
       end
     end
 
@@ -539,8 +569,7 @@ module Steep
       end
 
       def to_s
-        msg = message || "#{node.type} is not supported"
-        "#{location_to_str}: UnsupportedSyntax: #{msg}"
+        format_message(message || "#{node.type} is not supported")
       end
     end
 
@@ -555,8 +584,8 @@ module Steep
       end
 
       def to_s
-        <<-MESSAGE
-#{location_to_str}: UnexpectedError: #{error.class}
+        format_message <<-MESSAGE
+#{error.class}
 >> #{message}
         MESSAGE
       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