orthoses-rails 0.8.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70f9def2ba0ccd5b1537ee8aa3ee68c2700e99d0f134d313069939cc1db3277d
-  data.tar.gz: 922e2e304b3aa7f5cd34cb215ea3656c6a4c79c34875b7fd7ed691743230ea10
+  metadata.gz: 620d49df1787f2c79e641435da0cf872d0d8604930729bc746a72ec787677b78
+  data.tar.gz: fc06f6c06c7941f5ca36bbc1aabf6730e641e7cac2ea2a4f7ee1242284ebb4de
 SHA512:
-  metadata.gz: 42f23b91ba796e225541f7da52cc74916a53ef584f1711d95457b0cc239441146678c4ebbb5a271a52710d928f55edba2d5032bec56a4fe9f9b0e47bf7e44c6a
-  data.tar.gz: 1f9c63c9d2b9b8f11d820a27ef660d61cb727d3a3b3b644afa93fb3b7bdb48dbd150ca7ab96f636d02fb330e2de27c902862e04b89a514f20d5e3d51d5172dc8
+  metadata.gz: 63e8a69d07faab3bda23d71df987b87352e245b46d14cf824576c2a66502ad95e2523bc8f11eb8030e3325707b7b9b8e2e28103c560dba01bb0234ecf23fb54c
+  data.tar.gz: 13fd887d6564a51e19a0cdea17b80b5d3cfedd5a56f4096c1ec44a27dca3ba3e6a57c34dd22aa069a808fea34ec2eab1f265f0fa7d42f1394f8c00937642eb03

data/README.md

@@ -3,38 +3,19 @@
 [Orthoses](https://github.com/ksss/orthoses) extension for Ruby on Rails.
 Orthoses::Rails automatically generates RBS for methods added by Rails.
 
-## Features
-
-### Orthoses::ActiveModel
-
-- `HasSecurePassword`
-  - Add signatures that generated form `has_secure_password`.
-
-### Orthoses::ActiveRecord
-
-- `BelongsTo`
-  - Add signatures that generated form `belongs_to`.
-- `DelegatedType`
-  - Add signatures that generated from `delegated_type`
-- `Enum`
-  - Add signatures that generated from `enum`
-- `HasMany`
-  - Add signatures that generated form `has_many`.
-- `HasOne`
-  - Add signatures that generated form `has_one`.
-- `Scope`
-  - Add signatures that generated form `scope`.
-
-### Orthoses::ActiveSupport
-
-- `ClassAttribute`
-  - Add signatures that generated form `class_attribute`.
-- `Configurable`
-  - Add signatures that generated from `config_accessor`
-- `Delegation`
-  - Add signatures that generated from `delegate`. The type definition of the method or instance variable specified by `to` is required.
-- `MattrAccessor`
-  - Add signatures that generated form `mattr_accessor`, `cattr_accessor`, `mattr_reader`, `cattr_reader`, `mattr_writer` and `cattr_writer`.
+## Usage
+
+Build your Rake task for RBS generation.
+
+```rb
+$ bin/rails generate orthoses:rails:install
+```
+
+Then run the rake task.
+
+```
+$ bin/rails orthoses:rails
+```
 
 ## Installation
 
@@ -46,39 +27,6 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install orthoses-rails
 
-## Usage
-
-Build your Rake task for RBS generation.
-
-```rb
-task :rbs_generate => :environment do
-  Orthoses::Builder.new do
-    use Orthoses::CreateFileByName
-      base_dir: Rails.root.join("sig/out"),
-      header: "# !!! GENERATED CODE !!!"
-    use Orthoses::Filter do |name, _content|
-      path, _lineno = Object.const_source_location(name)
-      return false unless path
-      %r{app/models}.match?(path)
-    end
-    use YourCustom::Middleware
-    use Orthoses::ActiveModel::HasSecurePassword
-    use Orthoses::ActiveRecord::BelongsTo
-    use Orthoses::ActiveRecord::HasMany
-    use Orthoses::ActiveRecord::HasOne
-    use Orthoses::ActiveSupport::ClassAttribute
-    use Orthoses::ActiveSupport::MattrAccessor
-    use Orthoses::Mixin
-    use Orthoses::Constant, strict: false
-    use Orthoses::ObjectSpaceAll
-    use Orthoses::Autoload
-    run -> {
-      Rails.application.eager_load!
-    }
-  end.call
-end
-```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/generators/orthoses/rails/install_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+require 'orthoses/rails'
+
+module Orthoses
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+
+        def copy_rake_task_file
+          copy_file "rails.rake", "lib/tasks/orthoses/rails.rake"
+        end
+      end
+    end
+  end
+end

data/lib/orthoses/active_record/belongs_to.rb

@@ -15,7 +15,19 @@ module Orthoses
 
             lines = base.reflect_on_all_associations(:belongs_to).flat_map do |ref|
               # FIXME: Can I get list of class for polymorphic?
-              type = ref.polymorphic? ? 'untyped' : ref.klass.to_s
+              type = if ref.polymorphic?
+                'untyped'
+              else
+                begin
+                  Utils.module_name(ref.klass) or next
+                rescue NameError => e
+                  while e
+                    Orthoses.logger.warn(e.message)
+                    e = e.cause
+                  end
+                  next
+                end
+              end
               opt = "#{type}?"
 
               [
@@ -38,9 +50,8 @@ module Orthoses
               content.concat(lines)
             end
 
-            store[base_name].tap do |content|
-              store[base_name] << "include #{generated_association_methods}"
-            end
+            sig = "include #{generated_association_methods}"
+            store[base_name] << sig if !store[base_name].body.include?(sig)
           end
         end
       end

data/lib/orthoses/active_record/enum.rb

@@ -20,6 +20,11 @@ module Orthoses
         enum.captures.each do |capture|
           base_name = Utils.module_name(capture.method.receiver) or next
 
+          sig = "include #{base_name}::ActiveRecord_Enum_EnumMethods"
+          if !store[base_name].body.include?(sig)
+            store[base_name] << sig
+          end
+
           if capture.argument[:definitions]
             # on rails 6
             definitions = capture.argument[:definitions].slice!(:_prefix, :_suffix, :_scopes, :_default)

data/lib/orthoses/active_record/generated_attribute_methods.rb

@@ -3,6 +3,30 @@
 module Orthoses
   module ActiveRecord
     class GeneratedAttributeMethods
+      TARGET_TYPE_MAP = {
+        "attribute" => "() -> %<type>s",
+        "attribute=" => "(%<type>s) -> %<type>s",
+        "attribute?" => "() -> bool",
+        "attribute_before_last_save" => "() -> %<opt>s",
+        "attribute_before_type_cast" => "() -> %<type>s",
+        "attribute_came_from_user?" => "() -> bool",
+        "attribute_change" => "() -> [%<opt>s, %<opt>s]",
+        "attribute_change_to_be_saved" => "() -> Array[%<opt>s]?",
+        "attribute_changed?" => "() -> bool",
+        "attribute_for_database" => "() -> %<type>s",
+        "attribute_in_database" => "() -> %<opt>s",
+        "attribute_previous_change" => "() -> Array[%<opt>s]?",
+        "attribute_previously_changed?" => "() -> bool",
+        "attribute_previously_was" => "() -> %<opt>s",
+        "attribute_was" => "() -> %<opt>s",
+        "attribute_will_change!" => "() -> void",
+        "clear_attribute_change" => "() -> void",
+        "restore_attribute!" => "() -> void",
+        "saved_change_to_attribute" => "() -> Array[%<opt>s]?",
+        "saved_change_to_attribute?" => "() -> bool",
+        "will_save_change_to_attribute?" => "() -> bool",
+      }
+
       def initialize(loader)
         @loader = loader
       end
@@ -12,71 +36,39 @@ module Orthoses
           ::ActiveRecord::Base.descendants.each do |klass|
             next if klass.abstract_class?
 
-            name = Utils.module_name(klass) || next
-            lines = klass.columns.flat_map do |col|
-              req = sql_type_to_rbs(col.type)
+            base_klass_name = Utils.module_name(klass) || next
+            begin
+              klass.columns
+            rescue ::ActiveRecord::StatementInvalid => e
+              Orthoses.logger.warn(e.to_s)
+              next
+            end
+
+            lines = []
+            klass.columns_hash.each do |name, col|
+              req = ActiveRecord.sql_type_to_rbs(col.type)
               opt = "#{req}?"
               type = col.null ? opt : req
 
-              [
-                "def #{col.name}: () -> #{type}",
-                "def #{col.name}=: (#{type}) -> #{type}",
-                "def #{col.name}?: () -> bool",
-                "def #{col.name}_changed?: () -> bool",
-                "def #{col.name}_change: () -> [#{opt}, #{opt}]",
-                "def #{col.name}_will_change!: () -> void",
-                "def #{col.name}_was: () -> #{opt}",
-                "def #{col.name}_previously_changed?: () -> bool",
-                "def #{col.name}_previous_change: () -> Array[#{opt}]?",
-                "def #{col.name}_previously_was: () -> #{opt}",
-                "def #{col.name}_before_last_save: () -> #{opt}",
-                "def #{col.name}_change_to_be_saved: () -> Array[#{opt}]?",
-                "def #{col.name}_in_database: () -> #{opt}",
-                "def saved_change_to_#{col.name}: () -> Array[#{opt}]?",
-                "def saved_change_to_#{col.name}?: () -> bool",
-                "def will_save_change_to_#{col.name}?: () -> bool",
-                "def restore_#{col.name}!: () -> void",
-                "def clear_#{col.name}_change: () -> void",
-              ]
+              ::ActiveRecord::Base.attribute_method_matchers.each do |matcher|
+                tmpl = TARGET_TYPE_MAP[matcher.target]
+                lines << "def #{matcher.method_name(name)}: #{tmpl % {type: type, opt: opt}}"
+              end
+            end
+            klass.attribute_aliases.each do |alias_name, column_name|
+              ::ActiveRecord::Base.attribute_method_matchers.each do |matcher|
+                lines << "alias #{matcher.method_name(alias_name)} #{matcher.method_name(column_name)}"
+              end
             end
-            generated_attribute_methods = "#{name}::AttributeMethods::GeneratedAttributeMethods"
-            store[name] << "include #{generated_attribute_methods}"
 
-            store["#{name}::AttributeMethods"].header = "module #{name}::AttributeMethods"
+            generated_attribute_methods = "#{base_klass_name}::GeneratedAttributeMethods"
+            store[base_klass_name] << "include #{generated_attribute_methods}"
+
             store[generated_attribute_methods].header = "module #{generated_attribute_methods}"
             store[generated_attribute_methods].concat(lines)
           end
         end
       end
-
-      # Thanks https://github.com/pocke/rbs_rails/blob/8a128a8d29f0861aa2c25aa4110ff7c2ea674865/lib/rbs_rails/active_record.rb#L525-L551
-      def sql_type_to_rbs(t)
-        case t
-        when :integer
-          'Integer'
-        when :float
-          'Float'
-        when :decimal
-          'BigDecimal'
-        when :string, :text, :citext, :uuid, :binary
-          'String'
-        when :datetime
-          'ActiveSupport::TimeWithZone'
-        when :boolean
-          "bool"
-        when :jsonb, :json
-          "untyped"
-        when :date
-          'Date'
-        when :time
-          'Time'
-        when :inet
-          "IPAddr"
-        else
-          # Unknown column type, give up
-          'untyped'
-        end
-      end
     end
   end
 end

data/lib/orthoses/active_record/has_many.rb

@@ -13,14 +13,23 @@ module Orthoses
             next if base.abstract_class?
             base_name = Utils.module_name(base) || next
 
-            collection_proxy = "#{base_name}::ActiveRecord_Associations_CollectionProxy"
-
             lines = base.reflect_on_all_associations(:has_many).flat_map do |ref|
               singular_name = ref.name.to_s.singularize
+              type =
+                begin
+                  Utils.module_name(ref.klass)
+                rescue NameError => e
+                  while e
+                    Orthoses.logger.warn(e.message)
+                    e = e.cause
+                  end
+                  next
+                end
 
+              collection_proxy = "::#{type}::ActiveRecord_Associations_CollectionProxy"
               [
                 "def #{ref.name}: () -> #{collection_proxy}",
-                "def #{ref.name}=: (#{collection_proxy} | Array[#{ref.klass}]) -> (#{collection_proxy} | Array[#{ref.klass}])",
+                "def #{ref.name}=: (#{collection_proxy} | Array[#{type}]) -> (#{collection_proxy} | Array[#{type}])",
                 "def #{singular_name}_ids: () -> Array[Integer]",
                 "def #{singular_name}_ids=: (Array[Integer]) -> Array[Integer]",
               ]
@@ -29,7 +38,9 @@ module Orthoses
             generated_association_methods = "#{base_name}::GeneratedAssociationMethods"
             store[generated_association_methods].header = "module #{generated_association_methods}"
             store[generated_association_methods].concat(lines)
-            store[base_name] << "include #{generated_association_methods}"
+
+            sig = "include #{generated_association_methods}"
+            store[base_name] << sig if !store[base_name].body.include?(sig)
           end
         end
       end

data/lib/orthoses/active_record/has_one.rb

@@ -14,7 +14,16 @@ module Orthoses
             base_name = Utils.module_name(base) || next
 
             lines = base.reflect_on_all_associations(:has_one).flat_map do |ref|
-              type = ref.klass.to_s
+              type =
+                begin
+                  Utils.module_name(ref.klass) or next
+                rescue NameError => e
+                  while e
+                    Orthoses.logger.warn(e.message)
+                    e = e.cause
+                  end
+                  next
+                end
               opt = "#{type}?"
 
               [
@@ -31,7 +40,8 @@ module Orthoses
             store[generated_association_methods].header = "module #{generated_association_methods}"
             store[generated_association_methods].concat(lines)
 
-            store[base_name] << "include #{generated_association_methods}"
+            sig = "include #{generated_association_methods}"
+            store[base_name] << sig if !store[base_name].body.include?(sig)
           end
         end
       end

data/lib/orthoses/active_record/relation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Orthoses
+  module ActiveRecord
+    class Relation
+      def initialize(loader)
+        @loader = loader
+      end
+
+      def call
+        @loader.call.tap do |store|
+          ::ActiveRecord::Base.descendants.each do |klass|
+            next if klass.abstract_class?
+
+            primary_key = fetch_primary_key(klass)
+
+            model_name = Utils.module_name(klass) or next
+            class_specific_relation = "#{model_name}::ActiveRecord_Relation"
+            class_specific_proxy = "#{model_name}::ActiveRecord_Associations_CollectionProxy"
+            class_specific_generated_relation_methods = "#{model_name}::GeneratedRelationMethods"
+
+            store[class_specific_generated_relation_methods].tap do |c|
+            end
+
+            store[class_specific_relation].tap do |c|
+              c.header = "class #{class_specific_relation} < ::ActiveRecord::Relation"
+              c << "include #{class_specific_generated_relation_methods}"
+              c << "include _ActiveRecord_Relation[#{model_name}, #{primary_key}]"
+              c << "include Enumerable[#{model_name}]"
+            end
+
+            store[class_specific_proxy].tap do |c|
+              c.header = "class #{class_specific_proxy} < ::ActiveRecord::Associations::CollectionProxy"
+              c << "include _ActiveRecord_Relation[#{model_name}, #{primary_key}]"
+            end
+
+            store[model_name].tap do |c|
+              c << "extend _ActiveRecord_Relation_ClassMethods[#{model_name}, #{class_specific_relation}, #{primary_key}]"
+            end
+          end
+        end
+      end
+
+      private
+
+      def fetch_primary_key(klass)
+        type = klass.type_for_attribute(klass.primary_key).type
+        ActiveRecord.sql_type_to_rbs(type)
+      rescue ::ActiveRecord::StatementInvalid => e
+        Orthoses.logger.warn(e.to_s)
+        "untyped"
+      end
+    end
+  end
+end
+

data/lib/orthoses/active_record.rb

@@ -7,4 +7,40 @@ require_relative 'active_record/generated_attribute_methods'
 require_relative 'active_record/has_many'
 require_relative 'active_record/has_one'
 require_relative 'active_record/query_methods'
+require_relative 'active_record/relation'
 require_relative 'active_record/scope'
+
+module Orthoses
+  module ActiveRecord
+    # Thanks https://github.com/pocke/rbs_rails/blob/8a128a8d29f0861aa2c25aa4110ff7c2ea674865/lib/rbs_rails/active_record.rb#L525-L551
+    def self.sql_type_to_rbs(t)
+      case t
+      when :integer, :big_integer
+        '::Integer'
+      when :float
+        '::Float'
+      when :decimal
+        '::BigDecimal'
+      when :string, :text, :citext, :uuid, :binary, :immutable_string
+        '::String'
+      when :datetime
+        '::ActiveSupport::TimeWithZone'
+      when :boolean
+        "bool"
+      when :date
+        '::Date'
+      when :time
+        '::Time'
+      when :cidr, :inet
+        "::IPAddr"
+      when :bit, :bit_varying, :enum, :hstore,
+           :interval, :jsonb, :json, :legacy_point, :money, :point, :vector, :xml
+        # FIXME
+        'untyped'
+      else
+        # Unknown column type, give up
+        'untyped'
+      end
+    end
+  end
+end

data/lib/orthoses/active_support/delegation.rb

@@ -20,14 +20,16 @@ module Orthoses
         delegate.captures.each do |capture|
           receiver_name = Utils.module_name(capture.method.receiver) or next
           receiver_content = store[receiver_name]
+          prefix = capture.argument[:private] ? "private " : ""
 
           case capture.argument[:to]
+          # delegate :foo, to: Foo
           when Module
             to_module_name = Utils.module_name(capture.argument[:to]) or next
             capture.argument[:methods].each do |arg|
               if sig = resource.build_signature(to_module_name, arg, :singleton, false)
                 receiver_content << "# defined by `delegate` to: #{to_module_name}"
-                receiver_content << sig
+                receiver_content << "#{prefix}#{sig}"
               else
                 Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore since missing type for #{to_module_name}.#{arg.inspect} in #{capture.argument.inspect}")
               end
@@ -35,20 +37,28 @@ module Orthoses
           else
             to_name = capture.argument[:to].to_s.to_sym
             tag, to_return_type = resource.find(receiver_name, to_name, :instance, false)
-            raise "bug" if tag == :multi
+            if tag == :multi
+              to_return_type = if to_return_type.length == 1
+                to_return_type.first.type.return_type
+              else
+                nil
+              end
+            end
 
             case to_return_type
             when nil, RBS::Types::Bases::Any
+              # no type found
               capture.argument[:methods].each do |method|
                 receiver_content << "# defined by `delegate` to: #{to_return_type}##{to_name}"
-                receiver_content << "def #{method}: (*untyped, **untyped) -> untyped"
+                receiver_content << "#{prefix}def #{method}: (*untyped, **untyped) -> untyped"
               end
             else
+              # found return type in store or env
               to_typename = to_return_type.name.relative!.to_s
               capture.argument[:methods].each do |method|
                 if sig = resource.build_signature(to_typename, method, :instance, true)
                   receiver_content << "# defined by `delegate` to #{to_return_type}##{to_name}"
-                  receiver_content << sig
+                  receiver_content << "#{prefix}#{sig}"
                 else
                   Orthoses.logger.warn("[ActiveSupport::Delegation] Ignore since missing type for #{to_typename}##{method.inspect} in #{capture.argument.inspect}")
                 end
@@ -73,6 +83,7 @@ module Orthoses
           typename = TypeName(mod_name).absolute!
 
           if definition_method = build_definition(typename, kind)&.methods&.[](name)
+            # found in env
             return [:multi, definition_method.defs.map(&:type)]
           end
           resolve_type_by_name(@store[mod_name].to_decl.members, name, kind, argument)
@@ -85,7 +96,7 @@ module Orthoses
           when :singleton
             @definition_builder.build_singleton(typename)
           else
-            raise "big"
+            raise "bug"
           end
         rescue RuntimeError => e
           if e.message.match?(/\AUnknown name for/)
@@ -115,13 +126,13 @@ module Orthoses
             when RBS::AST::Members::MethodDefinition
               next unless member.name == name && member.kind == kind
               if argument
-                return [:multi, member.types]
+                return [:multi, member.overloads.map { |o| o.method_type }]
               else
-                type = member.types.find do |method_type|
+                method_type = member.overloads.map(&:method_type).find do |method_type|
                   method_type.type.required_positionals.empty? && method_type.type.required_keywords.empty?
                 end
-                next unless type
-                return [:single, type.type.return_type]
+                next unless method_type
+                return [:single, method_type.type.return_type]
               end
             when RBS::AST::Members::Var
               next unless member.name == name

data/lib/orthoses/active_support/time_with_zone.rb

@@ -13,6 +13,7 @@ module Orthoses
         store = @loader.call
 
         time_with_zone_store = store["ActiveSupport::TimeWithZone"]
+        time_with_zone_store.body.replace(filter_decl(time_with_zone_store))
         each_line_from_core_time_definition(store) do |line|
           time_with_zone_store << line
         end
@@ -22,63 +23,69 @@ module Orthoses
 
       private
 
-      NOT_DELEGATE_METHODS = Set.new(%i[
-        utc
-        getgm
-        getutc
-        gmtime
-        localtime
-      ])
-
       TYPE_MERGE_METHODS = Set.new(%i[
         +
         -
       ])
 
+      def filter_decl(time_with_zone_store)
+        writer = RBS::Writer.new(out: StringIO.new)
+        time_with_zone_store.to_decl.members.each do |member|
+          # ActiveSupport::TimeWithZone.name has been deprecated
+          next if member.instance_of?(RBS::AST::Members::MethodDefinition) && member.kind == :singleton && member.name == :name
+          writer.write_member(member)
+        end
+        writer.out.string.each_line.to_a
+      end
+
+      def add_signature(env, content)
+        buffer, directives, decls = RBS::Parser.parse_signature(content.to_rbs)
+        env.add_signature(buffer: buffer, directives: directives, decls: decls)
+      end
+
       def each_line_from_core_time_definition(store)
         type_name_time = TypeName("::Time")
         type_name_time_with_zone = TypeName("::ActiveSupport::TimeWithZone")
         env = Utils.rbs_environment(collection: true, cache: false)
-        env << store["Time"].to_decl
-        env << store["DateAndTime"].to_decl
-        env << store["DateAndTime::Zones"].to_decl
-        env << store["DateAndTime::Calculations"].to_decl
-        env << store["DateAndTime::Compatibility"].to_decl
-        env << store["ActiveSupport"].to_decl
-        env << store["ActiveSupport::TimeZone"].to_decl
-        env << store["ActiveSupport::Duration"].to_decl
-        env << store["ActiveSupport::TimeWithZone"].to_decl
+
+        add_signature(env, store["Time"])
+        add_signature(env, store["DateAndTime"])
+        add_signature(env, store["DateAndTime::Zones"])
+        add_signature(env, store["DateAndTime::Calculations"])
+        add_signature(env, store["DateAndTime::Compatibility"])
+        add_signature(env, store["ActiveSupport"])
+        add_signature(env, store["ActiveSupport::TimeZone"])
+        add_signature(env, store["ActiveSupport::Duration"])
+        add_signature(env, store["ActiveSupport::TimeWithZone"])
 
         builder = RBS::DefinitionBuilder.new(env: env.resolve_type_names)
-        one_ancestors = builder.ancestor_builder.one_instance_ancestors(type_name_time)
-        one_ancestors.included_modules.each do |included_module|
-          yield "include #{included_module.source.name}"
-        end
         twz_methods = builder.build_instance(type_name_time_with_zone).methods
         builder.build_instance(type_name_time).methods.each do |sym, definition_method|
+          next if twz_methods.has_key?(sym) && !TYPE_MERGE_METHODS.include?(sym)
           next if !definition_method.public?
+
           definition_method.defs.reject! do |type_def|
             type_def.implemented_in != type_name_time
           end
           next if definition_method.defs.empty?
 
-          if !NOT_DELEGATE_METHODS.include?(sym)
-            definition_method.method_types.each do |method_type|
-              rt = method_type.type.return_type
-              if rt.instance_of?(RBS::Types::ClassInstance) && rt.name.to_s == "::Time"
-                rt.instance_variable_set(:@name, RBS::Types::Bases::Self.new(location: nil))
-              end
+          definition_method.method_types.each do |method_type|
+            rt = method_type.type.return_type
+            if rt.instance_of?(RBS::Types::ClassInstance) && rt.name.to_s == "::Time"
+              rt.instance_variable_set(:@name, RBS::Types::Bases::Self.new(location: nil))
             end
           end
 
           if definition_method.alias_of.nil?
             method_types = definition_method.method_types
 
+            # merge method types (e.g. :+, :-
+            # TimeWithZone -delegate-> Time(core_ext) -delegate-> Time(core)
             if TYPE_MERGE_METHODS.include?(sym)
               if twz_definition_method = twz_methods[sym]
                 twz_definition_method.defs.each do |type_def|
                   if type_def.implemented_in == type_name_time_with_zone
-                    method_types << type_def.type
+                    method_types.unshift(type_def.type)
                   end
                 end
               end