steep 1.10.0.pre.3 → 2.0.0

data/lib/steep/drivers/start_server.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Steep
+  module Drivers
+    class StartServer
+      attr_reader :stdout
+      attr_reader :stderr
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run
+        Daemon.start(stderr: stderr) ? 0 : 1
+      end
+    end
+  end
+end

data/lib/steep/drivers/stop_server.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Steep
+  module Drivers
+    class StopServer
+      attr_reader :stdout
+      attr_reader :stderr
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run
+        Daemon.stop(stderr: stderr)
+        0
+      end
+    end
+  end
+end

data/lib/steep/drivers/watch.rb

@@ -112,7 +112,7 @@ module Steep
             end
           end
 
-          params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+          params = { library_paths: [], inline_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
 
           (modified + added).each do |path|
             path = Pathname(path)
@@ -132,7 +132,7 @@ module Steep
         begin
           stdout.puts Rainbow("👀 Watching directories, Ctrl-C to stop.").bold
 
-          params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+          params = { library_paths: [], inline_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
           file_loader = Services::FileLoader.new(base_dir: project.base_dir)
           project.targets.each do |target|
             file_loader.each_path_in_patterns(target.source_pattern, dirs.map(&:to_s)) do |path|

data/lib/steep/index/rbs_index.rb

@@ -22,6 +22,12 @@ module Steep
             declarations << decl
           when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
             declarations << decl
+          when RBS::AST::Ruby::Declarations::ClassDecl
+            declarations << decl
+          when RBS::AST::Ruby::Declarations::ModuleDecl
+            declarations << decl
+          when RBS::AST::Ruby::Declarations::ClassModuleAliasDecl
+            declarations << decl
           else
             raise "Unexpected type declaration: #{decl}"
           end
@@ -47,6 +53,8 @@ module Steep
             references << ref
           when RBS::AST::Declarations::ClassAlias, RBS::AST::Declarations::ModuleAlias
             references << ref
+          when RBS::AST::Ruby::Declarations::ClassModuleAliasDecl
+            references << ref
           else
             raise "Unexpected type reference: #{ref}"
           end
@@ -74,6 +82,8 @@ module Steep
             RBS::AST::Members::AttrReader,
             RBS::AST::Members::AttrAccessor
             declarations << decl
+          when RBS::AST::Ruby::Members::DefMember
+            declarations << decl
           else
             raise "Unexpected method declaration: #{decl}"
           end
@@ -93,7 +103,7 @@ module Steep
 
         def add_declaration(decl)
           case decl
-          when RBS::AST::Declarations::Constant
+          when RBS::AST::Declarations::Constant, RBS::AST::Ruby::Declarations::ConstantDecl
             declarations << decl
           else
             raise
@@ -228,6 +238,10 @@ module Steep
               index.add_method_declaration(method_name, member)
             end
 
+          when RBS::AST::Ruby::Members::DefMember
+            method_name = InstanceMethodName.new(type_name: type_name, method_name: member.name)
+            index.add_method_declaration(method_name, member)
+
           when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
             type_reference member.type, from: member
 
@@ -290,28 +304,37 @@ module Steep
 
         def env(env)
           env.class_decls.each do |name, decl|
-            decl.decls.each do |d|
-              index.add_type_declaration(name, d.decl)
+            decl.each_decl do |decl|
+              index.add_type_declaration(name, decl)
 
-              case d.decl
+              case decl
               when RBS::AST::Declarations::Class
-                if super_class = d.decl.super_class
-                  index.add_type_reference(super_class.name, d.decl)
+                if super_class = decl.super_class
+                  index.add_type_reference(super_class.name, decl)
                   super_class.args.each do |type|
-                    type_reference(type, from: d.decl)
+                    type_reference(type, from: 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)
+                decl.self_types.each do |self_type|
+                  index.add_type_reference(self_type.name, decl)
                   self_type.args.each do |type|
-                    type_reference(type, from: d.decl)
+                    type_reference(type, from: decl)
                   end
                 end
               end
 
-              d.decl.members.each do |member|
-                member(name, member)
+              case decl
+              when RBS::AST::Declarations::Base
+                decl.members.each do |member|
+                  member(name, member)
+                end
+              when RBS::AST::Ruby::Declarations::Base
+                decl.members.each do |member|
+                  if member.is_a?(RBS::AST::Ruby::Members::Base)
+                    member(name, member)
+                  end
+                end
               end
             end
           end
@@ -336,7 +359,9 @@ module Steep
 
           env.constant_decls.each do |name, decl|
             index.add_constant_declaration(name, decl.decl)
-            type_reference decl.decl.type, from: decl.decl
+            if decl.decl.is_a?(RBS::AST::Declarations::Constant)
+              type_reference decl.decl.type, from: decl.decl
+            end
           end
 
           env.global_decls.each do |name, decl|

data/lib/steep/index/signature_symbol_provider.rb

@@ -73,6 +73,13 @@ module Steep
                     kind: LSP::Constant::SymbolKind::CLASS,
                     container_name: container_name
                   )
+                when RBS::AST::Ruby::Declarations::ClassDecl
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::CLASS,
+                    container_name: container_name
+                  )
                 when RBS::AST::Declarations::Module
                   symbols << SymbolInformation.new(
                     name: name,
@@ -80,6 +87,13 @@ module Steep
                     kind: LSP::Constant::SymbolKind::MODULE,
                     container_name: container_name
                   )
+                when RBS::AST::Ruby::Declarations::ModuleDecl
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::MODULE,
+                    container_name: container_name
+                  )
                 when RBS::AST::Declarations::Interface
                   symbols << SymbolInformation.new(
                     name: name,
@@ -144,18 +158,25 @@ module Steep
                       container_name: container_name
                     )
                   end
+                when RBS::AST::Ruby::Members::DefMember
+                  symbols << SymbolInformation.new(
+                    name: name,
+                    location: location,
+                    kind: LSP::Constant::SymbolKind::METHOD,
+                    container_name: container_name
+                  )
                 end
               end
             when RBSIndex::ConstantEntry
               next unless SignatureSymbolProvider.test_const_name(query, entry.const_name)
 
               entry.declarations.each do |decl|
-                next unless decl.location
-                next unless assigned?(target, Pathname(decl.location.buffer.name))
+                loc = decl.location or next
+                next unless assigned?(target, Pathname(loc.buffer.name))
 
                 symbols << SymbolInformation.new(
                   name: entry.const_name.name.to_s,
-                  location: decl.location,
+                  location: loc,
                   kind: LSP::Constant::SymbolKind::CONSTANT,
                   container_name: entry.const_name.namespace.relative!.to_s.delete_suffix("::")
                 )

data/lib/steep/interface/builder.rb

@@ -82,7 +82,7 @@ module Steep
       end
 
       def fetch_cache(cache, key)
-        if cache.key?(key)
+        if cache.key?(key) # steep:ignore ArgumentTypeMismatch
           return cache.fetch(key)
         end
 
@@ -239,8 +239,8 @@ module Steep
         vars =
           case type
           when AST::Types::Name::Instance
-            entry = factory.env.normalized_module_class_entry(type.name) or raise
-            entry.primary.decl.type_params.map { _1.name }
+            entry = factory.env.module_class_entry(type.name, normalized: true) or raise
+            entry.primary_decl.type_params.map { _1.name }
           when AST::Types::Name::Interface
             entry = factory.env.interface_decls.fetch(type.name)
             entry.decl.type_params.map { _1.name }
@@ -408,20 +408,34 @@ module Steep
       def method_name_for(type_def, name)
         type_name = type_def.implemented_in || type_def.defined_in
 
-        if name == :new && type_def.member.is_a?(RBS::AST::Members::MethodDefinition) && type_def.member.name == :initialize
-          return SingletonMethodName.new(type_name: type_name, method_name: name)
+        if name == :new
+          case type_def.member
+          when RBS::AST::Members::MethodDefinition
+            if type_def.member.name == :initialize
+              return SingletonMethodName.new(type_name: type_name, method_name: name)
+            end
+          when RBS::AST::Ruby::Members::DefMember
+            if type_def.member.name == :initialize
+              return SingletonMethodName.new(type_name: type_name, method_name: name)
+            end
+          end
         end
 
-        case type_def.member.kind
-        when :instance
-          InstanceMethodName.new(type_name: type_name, method_name: name)
-        when :singleton
-          SingletonMethodName.new(type_name: type_name, method_name: name)
-        when :singleton_instance
-          # Assume it a instance method, because `module_function` methods are typically defined with `def`
+        case type_def.member
+        when RBS::AST::Members::Base
+          case type_def.member.kind
+          when :instance
+            InstanceMethodName.new(type_name: type_name, method_name: name)
+          when :singleton
+            SingletonMethodName.new(type_name: type_name, method_name: name)
+          when :singleton_instance
+            # Assume it a instance method, because `module_function` methods are typically defined with `def`
+            InstanceMethodName.new(type_name: type_name, method_name: name)
+          else
+            raise
+          end
+        when RBS::AST::Ruby::Members::DefMember, RBS::AST::Ruby::Members::AttributeMember
           InstanceMethodName.new(type_name: type_name, method_name: name)
-        else
-          raise
         end
       end
 
@@ -779,7 +793,8 @@ module Steep
                   return_type: AST::Types::Logic::ArgIsReceiver.instance()
                 )
               )
-            when RBS::BuiltinNames::Object.name,
+            when RBS::BuiltinNames::BasicObject.name,
+              RBS::BuiltinNames::Object.name,
               RBS::BuiltinNames::Kernel.name,
               RBS::BuiltinNames::String.name,
               RBS::BuiltinNames::Integer.name,
@@ -794,6 +809,24 @@ module Steep
                 )
               )
             end
+          when :==
+            case defined_in
+            when RBS::BuiltinNames::BasicObject.name,
+              RBS::BuiltinNames::Object.name,
+              RBS::BuiltinNames::Kernel.name,
+              RBS::BuiltinNames::String.name,
+              RBS::BuiltinNames::Integer.name,
+              RBS::BuiltinNames::Symbol.name,
+              RBS::BuiltinNames::TrueClass.name,
+              RBS::BuiltinNames::FalseClass.name,
+              RBS::TypeName.parse("::NilClass")
+              # For ==, we use ReceiverIsArg to narrow the receiver based on the argument
+              return method_type.with(
+                type: method_type.type.with(
+                  return_type: AST::Types::Logic::ReceiverIsArg.instance()
+                )
+              )
+            end
           when :<, :<=
             case defined_in
             when RBS::BuiltinNames::Module.name

data/lib/steep/interface/shape.rb

@@ -32,14 +32,22 @@ module Steep
           method_defs.map do |defn|
             type_name = defn.implemented_in || defn.defined_in
 
-            if name == :new && defn.member.is_a?(RBS::AST::Members::MethodDefinition) && defn.member.name == :initialize
+            case
+            when name == :new && defn.member.is_a?(RBS::AST::Members::MethodDefinition) && defn.member.name == :initialize
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: name)
+            when name == :new && defn.member.is_a?(RBS::AST::Ruby::Members::DefMember) && defn.member.name == :initialize
               method_name = SingletonMethodName.new(type_name: type_name, method_name: name)
             else
               method_name =
-                if defn.member.kind == :singleton
-                  SingletonMethodName.new(type_name: defn.defined_in, method_name: name)
-                else
-                  # Call the `self?` method an instance method, because the definition is done with instance method definition, not with singleton method
+                case defn.member
+                when RBS::AST::Members::Base
+                  if defn.member.kind == :singleton
+                    SingletonMethodName.new(type_name: defn.defined_in, method_name: name)
+                  else
+                    # Call the `self?` method an instance method, because the definition is done with instance method definition, not with singleton method
+                    InstanceMethodName.new(type_name: defn.defined_in, method_name: name)
+                  end
+                when RBS::AST::Ruby::Members::DefMember, RBS::AST::Ruby::Members::AttributeMember
                   InstanceMethodName.new(type_name: defn.defined_in, method_name: name)
                 end
             end