rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/listeners/methods_listener.rb

@@ -13,147 +13,430 @@ module RailsAiContext
         def initialize(include_initialize: false)
           super()
           @include_initialize = include_initialize
-          @visibility_stack = [ :public ]
-          @in_singleton_class = false
-          @singleton_depth = 0
-          @inline_visibility_stack = [ {} ] # stack of { method_name => visibility }
+          @results = Results.new
+          @frames = [ Frame.new(:body, :public, {}) ]
           @owner_stack = []
-          # `class_methods do` and `included do` bodies, keyed by their block
-          # node so the block's own enter/leave can open and close a scope.
-          @concern_blocks = {}.compare_by_identity
+          # Blocks that open a body of their own, keyed by their block node so
+          # the block's own enter/leave can open and close the frame.
+          @scoped_blocks = {}.compare_by_identity
           @open_blocks = []
-          @scope_stack = []
+          @def_depth = 0
+          @builders = []
+          # Each entry's parameters as written, which an alias of it takes on.
+          @param_slices = {}.compare_by_identity
         end
 
-        # Reset visibility when entering a new class/module scope
+        # The methods found, plus the span of every def walked, listed or not: a call
+        # inside a skipped `initialize` still runs only when that method does.
+        class Results < Array
+          def def_spans
+            @def_spans ||= []
+          end
+        end
+
+        # One visibility scope: a class or module body, a `class << self`
+        # body, or a block Rails evaluates as a module body. `marks` holds the
+        # inline `private :x` forms, keyed by [scope, name].
+        Frame = Struct.new(:kind, :visibility, :marks)
+
+        CLASS_SCOPE_FRAMES = %i[singleton class_methods].freeze
+        # A scope's or an association's block extends the relation, and
+        # `concern` builds a module the class does not include: a def in
+        # one is no method of the class.
+        BLOCK_FRAMES = {
+          class_methods: :class_methods, included: :included, concerning: :body,
+          scope: :extension, has_many: :extension, has_and_belongs_to_many: :extension,
+          has_one: :extension, belongs_to: :extension, concern: :extension
+        }.freeze
+
+        # Each defines a public method whatever `private` section it sits in;
+        # only Rails' `private: true` makes one private.
+        DELEGATORS = %i[delegate def_delegators def_instance_delegators def_delegator def_instance_delegator instance_delegate].freeze
+
+        # Ruby makes these instance methods private whatever section defines them.
+        ALWAYS_PRIVATE = %w[initialize initialize_copy initialize_clone initialize_dup respond_to_missing?].freeze
+
+        # Ruby's own definers: these honor the section's visibility, as `def` does.
+        ATTR_DEFINERS = { attr_reader: [ :reader ], attr_writer: [ :writer ], attr_accessor: %i[reader writer], attr: [ :reader ] }.freeze
+        # Active Support's: each defines public class and instance accessors from a string `class_eval`.
+        CLASS_ACCESSORS = {
+          class_attribute: %i[reader writer], mattr_reader: [ :reader ], cattr_reader: [ :reader ],
+          mattr_writer: [ :writer ], cattr_writer: [ :writer ], mattr_accessor: %i[reader writer], cattr_accessor: %i[reader writer]
+        }.freeze
+        # Sets, because a `when *names` allocates on every call node of every walk.
+        BLOCK_FRAME_NAMES = BLOCK_FRAMES.keys.to_set.freeze
+        DELEGATOR_NAMES = DELEGATORS.to_set.freeze
+        DEFINERS = Set[*ATTR_DEFINERS.keys, :define_method, :alias_method, *CLASS_ACCESSORS.keys].freeze
+
         def on_class_node_enter(node)
-          @visibility_stack.push(:public)
-          @inline_visibility_stack.push({})
+          open_frame(:body)
           @owner_stack.push(constant_path_string(node.constant_path))
         end
 
         def on_class_node_leave(node)
-          @visibility_stack.pop
-          @inline_visibility_stack.pop
+          @frames.pop
           @owner_stack.pop
         end
 
         def on_module_node_enter(node)
-          @visibility_stack.push(:public)
-          @inline_visibility_stack.push({})
+          open_frame(:body)
           @owner_stack.push(constant_path_string(node.constant_path))
         end
 
         def on_module_node_leave(node)
-          @visibility_stack.pop
-          @inline_visibility_stack.pop
+          @frames.pop
           @owner_stack.pop
         end
 
-        # Track `class << self` blocks
+        # A singleton class body starts public, and a `private` in it stays in it.
         def on_singleton_class_node_enter(node)
-          @in_singleton_class = true
-          @singleton_depth += 1
+          open_frame(:singleton)
         end
 
         def on_singleton_class_node_leave(node)
-          @singleton_depth -= 1
-          @in_singleton_class = false if @singleton_depth == 0
+          @frames.pop
         end
 
-        # Track visibility modifiers: private, protected, public
-        # Handles both bare form (`private`) and inline form (`private :method_name`)
+        # Bare `private` affects every later def in this frame; `private :x`
+        # and `private def x` mark the one name, retroactively for :x.
         def on_call_node_enter(node)
+          @scoped_blocks[node.block] = :extension if new_class_body?(node) && !@scoped_blocks.key?(node.block)
           return unless node.receiver.nil?
 
           case node.name
           when :private, :protected, :public
             if node.arguments.nil?
-              # Bare modifier: affects all subsequent defs in this scope
-              @visibility_stack[-1] = node.name
+              @frames.last.visibility = node.name
+            else
+              mark(node.arguments.arguments, node.name, frame_scope)
+            end
+          when :private_class_method, :public_class_method
+            mark(Array(node.arguments&.arguments), node.name == :private_class_method ? :private : :public, :class)
+          when :module_function
+            if node.arguments.nil?
+              @frames.last.visibility = :module_function
             else
-              # Inline form: `private :method_name` - retroactively update
-              # already-recorded methods and mark for future defs. The def in
-              # `private def x` is visited after this call, so marking its
-              # name here is enough.
-              args = node.arguments.arguments
-              args.each do |arg|
-                case arg
-                when Prism::DefNode
-                  @inline_visibility_stack.last[arg.name.to_s] = node.name
-                when Prism::SymbolNode
-                  method_name = arg.unescaped
-                  @inline_visibility_stack.last[method_name] = node.name
-                  existing = @results.find { |r| r[:name] == method_name && r[:owner] == @owner_stack }
-                  existing[:visibility] = node.name if existing
-                end
-              end
+              mark(node.arguments.arguments, :module_function, :instance)
             end
-          when :class_methods, :included
-            @concern_blocks[node.block] = node.name if node.block.is_a?(Prism::BlockNode)
+          when BLOCK_FRAME_NAMES
+            @scoped_blocks[node.block] = BLOCK_FRAMES[node.name] if node.block.is_a?(Prism::BlockNode)
+          when DELEGATOR_NAMES
+            record_delegated(node) if @def_depth.zero?
+          when DEFINERS
+            record_defined(node) if @def_depth.zero? && @frames.last.kind != :extension
           end
         end
 
-        # A concern block is a visibility scope of its own: a `private` inside
-        # `class_methods do` does not reach the module's instance methods.
+        # `Name = Struct.new do ... end` is Name's body.
+        def on_constant_write_node_enter(node)
+          open_builder(node, node.name.to_s)
+        end
+
+        def on_constant_write_node_leave(node)
+          close_builder(node)
+        end
+
+        def on_constant_path_write_node_enter(node)
+          open_builder(node, constant_path_string(node.target))
+        end
+
+        def on_constant_path_write_node_leave(node)
+          close_builder(node)
+        end
+
+        # ponytail: a Module.new held in a local is read as the enclosing class's, which is where it is
+        # nearly always included; follow the local to its `include` if another use turns up.
+        def on_local_variable_write_node_enter(node)
+          value = node.value
+          @scoped_blocks[value.block] = :body if value.is_a?(Prism::CallNode) && new_class_body?(value) && value.name == :new &&
+                                                 value.receiver.name == :Module
+        end
+
+        def on_alias_method_node_enter(node)
+          return unless @def_depth.zero? && @frames.last.kind != :extension
+
+          new_name = literal_string(node.new_name)
+          old_name = literal_string(node.old_name)
+          record_alias(node, new_name, old_name) if new_name && old_name
+        end
+
         def on_block_node_enter(node)
-          kind = @concern_blocks.delete(node)
+          kind = @scoped_blocks.delete(node)
           return unless kind
 
           @open_blocks.push(node)
-          @scope_stack.push(kind)
-          @visibility_stack.push(:public)
-          @inline_visibility_stack.push({})
+          open_frame(kind)
         end
 
         def on_block_node_leave(node)
           return unless @open_blocks.last.equal?(node)
 
           @open_blocks.pop
-          @scope_stack.pop
-          @visibility_stack.pop
-          @inline_visibility_stack.pop
+          @frames.pop
+        end
+
+        def on_def_node_leave(node)
+          @def_depth -= 1
         end
 
         def on_def_node_enter(node)
-          is_class_method = @in_singleton_class || node.receiver&.is_a?(Prism::SelfNode) || @scope_stack.last == :class_methods
+          @def_depth += 1
+          @results.def_spans << (node.location.start_offset...node.location.end_offset)
+          scope = def_scope(node)
           method_name = node.name.to_s
+          return unless scope
+          return if @frames.last.kind == :extension || class_methods_module_own?(node.receiver)
+          return if method_name == "initialize" && scope == :instance && !@include_initialize
+
+          # A bare `private` reaches only defs written without a receiver.
+          visibility = ruby_visibility(scope, method_name, node.receiver ? :public : @frames.last.visibility)
+          if visibility == :module_function
+            record(node, method_name, :instance, :private, prefixed: false)
+            @results.last[:module_function] = true
+            record(node, method_name, :class, :public, prefixed: true)
+          else
+            record(node, method_name, scope, visibility, prefixed: !node.receiver.nil?)
+          end
+        end
+
+        private
+
+        # These evaluate their block as a new class or module body.
+        CLASS_BUILDERS = { Struct: :new, Class: :new, Module: :new, Data: :define }.freeze
+
+        def new_class_body?(node)
+          receiver = node.receiver
+          return false unless node.block.is_a?(Prism::BlockNode)
+          return false unless receiver.is_a?(Prism::ConstantReadNode) || (receiver.is_a?(Prism::ConstantPathNode) && receiver.parent.nil?)
+
+          CLASS_BUILDERS[receiver.name] == node.name
+        end
+
+        def open_builder(node, name)
+          value = node.value
+          return unless value.is_a?(Prism::CallNode) && new_class_body?(value)
+
+          @scoped_blocks[value.block] = :body
+          @owner_stack.push(name)
+          @builders.push(node)
+        end
+
+        def close_builder(node)
+          return unless @builders.last.equal?(node)
+
+          @builders.pop
+          @owner_stack.pop
+        end
+
+        # What an includer gains: a `class_methods` def, or a class method written in `included do`.
+        def includer_gains?(scope)
+          frame = @frames.last
+          return true if frame.kind == :class_methods
+
+          frame = @frames[-2] if frame.kind == :singleton
+          frame&.kind == :included && scope == :class
+        end
+
+        # `def self.x` in `class_methods do`, or anything in its `class << self`, is ClassMethods' own:
+        # neither the includer nor the concern responds to it.
+        def class_methods_module_own?(receiver)
+          kinds = @frames.last(2).map(&:kind)
+          (kinds.last == :class_methods && !receiver.nil?) || kinds == %i[class_methods singleton]
+        end
 
-          return if method_name == "initialize" && !is_class_method && !@include_initialize
+        def open_frame(kind)
+          @frames.push(Frame.new(kind, :public, {}))
+        end
+
+        def ruby_visibility(scope, name, visibility)
+          @frames.last.marks.fetch([ scope, name ]) { scope == :instance && ALWAYS_PRIVATE.include?(name) ? :private : visibility }
+        end
+
+        def frame_scope
+          CLASS_SCOPE_FRAMES.include?(@frames.last.kind) ? :class : :instance
+        end
+
+        # nil for a singleton def on anything but this class (`def other.x`):
+        # it is no method of the class.
+        def def_scope(node)
+          receiver = node.receiver
+          return frame_scope if receiver.nil?
+          return :class if receiver.is_a?(Prism::SelfNode)
+          return unless receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)
+
+          owner = @owner_stack.join("::")
+          name = constant_path_string(receiver).delete_prefix("::")
+          :class if owner == name || owner.end_with?("::#{name}")
+        end
+
+        def mark(args, visibility, scope)
+          marks = @frames.last.marks
+          args.each do |arg|
+            case arg
+            when Prism::DefNode
+              marks[[ def_scope(arg), arg.name.to_s ]] = visibility
+            when Prism::SymbolNode
+              name = arg.unescaped
+              marks[[ scope, name ]] = visibility
+              existing = @results.reverse_each.find { |r| r[:name] == name && r[:scope] == scope && r[:owner] == @owner_stack }
+              apply_visibility(existing, visibility) if existing
+            when Prism::CallNode
+              # Since Ruby 3.0 these return the names they define, so `private attr_reader :x` works.
+              defined_names(arg).each { |name| marks[[ scope, name ]] = visibility } unless visibility == :module_function
+            end
+          end
+        end
 
-          # Inline visibility (`private :foo`) takes precedence over positional
-          visibility = @inline_visibility_stack.last[method_name] || @visibility_stack.last
+        def defined_names(call)
+          return [] unless call.receiver.nil?
 
-          params = extract_params(node)
+          names = Array(call.arguments&.arguments).filter_map { |a| literal_string(a) }
+          case call.name
+          when :define_method, :alias_method then names.first(1)
+          when *ATTR_DEFINERS.keys
+            kinds = ATTR_DEFINERS[call.name]
+            names.flat_map { |name| [ (name if kinds.include?(:reader)), ("#{name}=" if kinds.include?(:writer)) ].compact }
+          else []
+          end
+        end
+
+        def apply_visibility(entry, visibility)
+          return entry[:visibility] = visibility unless visibility == :module_function
 
-          @results << {
+          entry[:visibility] = :private
+          entry[:module_function] = true
+          @results << entry.merge(scope: :class, visibility: :public, signature: "self.#{entry[:signature]}").except(:module_function)
+        end
+
+        def record(node, method_name, scope, visibility, prefixed:)
+          slices = parameter_slices(node.parameters)
+          entry = {
             name:         method_name,
-            scope:        is_class_method ? :class : :instance,
+            scope:        scope,
             visibility:   visibility,
-            params:       params,
+            params:       extract_params(node),
             # Enclosing class/module names, outermost first. A caller that
             # wants one class's own methods needs this: a helper class nested
             # inside a service is a separate owner, not part of its interface.
             owner:        @owner_stack.dup,
             # Sliced off the node so defaults read as written (`options = {}`);
             # `params` records names only.
-            signature:    signature_source(node, is_class_method),
+            signature:    signature_text("#{'self.' if prefixed}#{node.name}", slices),
             location:     node.location.start_line,
             end_location: node.location.end_line,
+            # Offsets, unlike lines, tell a call that shares a line with a def from one inside it.
+            offset:       node.location.start_offset,
+            end_offset:   node.location.end_offset,
             confidence:   RailsAiContext::Confidence::VERIFIED
           }
+          # Outside `included do`, a `def self.x` or `class << self` method stays on the module.
+          entry[:class_methods_block] = true if includer_gains?(scope)
+          @param_slices[entry] = slices
+          @results << entry
         end
 
-        private
+        def record_defined(node)
+          names = Array(node.arguments&.arguments).filter_map { |a| literal_string(a) }
+          case node.name
+          when :define_method
+            record_name(node, names.first, frame_scope, @frames.last.visibility) if names.first
+          when :alias_method
+            record_alias(node, *names.first(2)) if names.size >= 2
+          when *ATTR_DEFINERS.keys
+            names.each { |name| record_accessors(node, name, ATTR_DEFINERS[node.name], frame_scope, @frames.last.visibility) }
+          else
+            record_class_accessors(node, names)
+          end
+        end
+
+        def record_class_accessors(node, names)
+          kinds = CLASS_ACCESSORS[node.name]
+          options = extract_keyword_options(node)
+          off = ->(key) { options[key] == false || options[:instance_accessor] == false }
+          instance = kinds.reject { |kind| off.call(kind == :reader ? :instance_reader : :instance_writer) }
+          predicate = node.name == :class_attribute && options[:instance_predicate] != false
+          names.each do |name|
+            record_accessors(node, name, kinds, :class, :public)
+            record_name(node, "#{name}?", :class, :public) if predicate
+            record_accessors(node, name, instance, :instance, :public)
+            record_name(node, "#{name}?", :instance, :public) if predicate && instance.include?(:reader)
+          end
+        end
+
+        def record_accessors(node, name, kinds, scope, visibility)
+          record_name(node, name, scope, visibility) if kinds.include?(:reader)
+          record_name(node, "#{name}=", scope, visibility, signature: "#{name}=(value)") if kinds.include?(:writer)
+        end
+
+        # An alias carries its original's visibility and parameters, whatever section it sits in.
+        def record_alias(node, new_name, old_name)
+          scope = frame_scope
+          original = @results.reverse_each.find { |r| r[:name] == old_name && r[:scope] == scope && r[:owner] == @owner_stack }
+          slices = original ? @param_slices.fetch(original, []) : []
+          record_name(node, new_name, scope, original ? original[:visibility] : :public,
+                      signature: signature_text(new_name, slices), params: original ? original[:params].dup : [], slices: slices)
+        end
+
+        def record_name(node, name, scope, visibility, signature: name, params: [], slices: [])
+          return if class_methods_module_own?(nil)
+
+          visibility = :public if visibility == :module_function
+          entry = {
+            name:         name,
+            scope:        scope,
+            visibility:   ruby_visibility(scope, name, visibility),
+            params:       params,
+            owner:        @owner_stack.dup,
+            signature:    signature,
+            # No end: these have no body for a call to sit inside.
+            location:     node.location.start_line,
+            confidence:   node.is_a?(Prism::CallNode) ? confidence_for(node) : RailsAiContext::Confidence::VERIFIED
+          }
+          entry[:class_methods_block] = true if includer_gains?(scope)
+          @param_slices[entry] = slices
+          @results << entry
+        end
+
+        def record_delegated(node)
+          return if @frames.last.kind == :extension
+
+          args = node.arguments&.arguments || []
+          positional = args.reject { |a| a.is_a?(Prism::KeywordHashNode) }
+          options = extract_keyword_options(node)
+          visibility = :public
+          names = case node.name
+          when :def_delegators, :def_instance_delegators
+            positional.drop(1).filter_map { |a| literal_string(a) } - %w[__send__ __id__]
+          when :def_delegator, :def_instance_delegator
+            Array(literal_string(positional[2] || positional[1]))
+          else
+            if options.key?(:to)
+              visibility = :private if options[:private] == true
+              prefix = delegation_prefix(options)
+              return unless prefix
+
+              positional.filter_map { |a| literal_string(a) }.map { |name| "#{prefix}#{name}" }
+            else
+              # Forwardable's `delegate [:a, :b] => :@x`.
+              args.grep(Prism::KeywordHashNode).flat_map(&:elements).grep(Prism::AssocNode).flat_map { |assoc| literal_strings(assoc.key) }
+            end
+          end
+          names.each { |name| record_name(node, name, frame_scope, visibility) }
+        end
+
+        def delegation_prefix(options)
+          case options[:prefix]
+          # Rails raises on `prefix: true` with an ivar target, so nothing is defined.
+          when true then options[:to].to_s.start_with?("@") ? nil : "#{options[:to]}_"
+          when Symbol, String then "#{options[:prefix]}_"
+          else ""
+          end
+        end
 
         # `class << self` members carry no receiver of their own, so they read
         # as the bare name, which is how they are written.
-        def signature_source(node, is_class_method)
-          prefix = (is_class_method && node.receiver) ? "self." : ""
-          params = parameter_slices(node.parameters)
-          return "#{prefix}#{node.name}" if params.empty?
-
-          "#{prefix}#{node.name}(#{params.join(', ')})"
+        def signature_text(name, slices)
+          slices.empty? ? name : "#{name}(#{slices.join(', ')})"
         end
 
         # Each parameter is sliced on its own rather than taking the whole list

data/lib/rails_ai_context/introspectors/listeners/migration_dsl_listener.rb

@@ -91,7 +91,7 @@ module RailsAiContext
           }
 
           case node.name
-          when :add_column
+          when :add_column, :remove_column
             result[:column_type] = literal_string(args[2])
           when :rename_column
             result[:new_name] = literal_string(args[2])

data/lib/rails_ai_context/introspectors/listeners/migration_replay_listener.rb

@@ -3,8 +3,8 @@
 module RailsAiContext
   module Introspectors
     module Listeners
-      # What a replay needs beyond the DSL listeners: down-only ranges (a revert
-      # block is one), a block's `t.` statements, and four top-level statements.
+      # What a replay needs beyond the DSL listeners: down-only and revert ranges,
+      # a block's `t.` statements, and the top-level statements the DSL listeners leave out.
       class MigrationReplayListener < BaseListener
         include SchemaDslListener::TableBlock
 
@@ -19,16 +19,17 @@ module RailsAiContext
           remove: :remove_columns, remove_references: :remove_reference, remove_belongs_to: :remove_reference,
           remove_index: :remove_index, rename: :rename_column, remove_timestamps: :remove_columns,
           change: :change_column, change_default: :change_column_default, change_null: :change_column_null,
-          timestamps: :add_timestamps
+          timestamps: :add_timestamps, check_constraint: :add_check_constraint, remove_check_constraint: :remove_check_constraint
         }.freeze
 
         def on_call_node_enter(node)
           note_block(node)
           args = node.arguments&.arguments || []
           if %i[down revert].include?(node.name) && node.block
-            @results << { kind: :down, range: node.location.start_line..node.location.end_line }
-          elsif node.name == :column && block_column?(node.receiver)
-            @results << column_definition(node, args)
+            @results << { kind: node.name, range: node.location.start_line..node.location.end_line }
+          elsif node.name == :revert && node.receiver.nil? && args.any?
+            # `revert SomeMigration` runs another file's statements inverted, which this file does not hold.
+            @results << { kind: :not_replayed, location: node.location.start_line }
           elsif TABLE_OPS[node.name] == :remove_reference && block_column?(node.receiver)
             # Table#remove_references drops each name it is given.
             args.reject { |arg| arg.is_a?(Prism::KeywordHashNode) }.each do |arg|
@@ -40,29 +41,43 @@ module RailsAiContext
             tables = args.reject { |arg| arg.is_a?(Prism::KeywordHashNode) }.first(2).map { |arg| literal_string(arg) }
             @results << { action: :create_join_table, tables: tables, options: extract_keyword_options(node),
                           location: node.location.start_line }
-          elsif %i[remove_columns add_timestamps].include?(node.name) && node.receiver.nil?
+          elsif %i[remove_columns add_timestamps rename_index add_check_constraint remove_check_constraint].include?(node.name) && node.receiver.nil?
             @results << top_level(node, args)
           elsif node.name == :execute && node.receiver.nil?
-            dropped_tables(args.first).each do |table|
-              @results << { action: :drop_table, table: table, options: {}, location: node.location.start_line }
+            sql_node = args.first
+            sql_node = sql_node.receiver if sql_node.is_a?(Prism::CallNode) && sql_node.name == :squish && sql_node.arguments.nil?
+            statements = sql_statements(sql_node)
+            # SQL built at run time that creates or drops a table is counted as not replayed.
+            if statements.nil?
+              literal = sql_node.respond_to?(:parts) ? sql_node.parts.grep(Prism::StringNode).map(&:unescaped).join : ""
+              @results << { kind: :not_replayed, location: node.location.start_line } if literal.match?(/\b(?:CREATE|DROP)\s+TABLE\b/i)
+              return
+            end
+            statements.each do |sql|
+              if (match = DROP_TABLE.match(sql))
+                match[1].split(",").each do |name|
+                  @results << { action: :drop_table, table: name.strip.delete('"`').split(".").last, options: {}, location: node.location.start_line }
+                end
+              elsif sql.match?(CREATE_TABLE)
+                @results << { action: :create_table_sql, sql: sql, location: node.location.start_line }
+              end
             end
           end
         end
 
         DROP_TABLE = /\A\s*DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?((?:[\w."`]+\s*,\s*)*[\w."`]+)(?:\s+(?:CASCADE|RESTRICT))?\s*\z/i
+        CREATE_TABLE = /\A\s*CREATE\s+TABLE\s/i
 
         private
 
-        # The tables a literal SQL string drops, one statement at a time; any
-        # other SQL, or a string built at run time, drops nothing here.
-        def dropped_tables(node)
-          node = node.receiver if node.is_a?(Prism::CallNode) && node.name == :squish && node.arguments.nil?
-          return [] unless node.is_a?(Prism::StringNode)
-
-          node.unescaped.split(";").flat_map do |sql|
-            match = DROP_TABLE.match(sql) or next []
-            match[1].split(",").map { |name| name.strip.delete('"`').split(".").last }
+        # A literal SQL string's statements, which drop or create tables here; nil for a string built at run time.
+        def sql_statements(node)
+          sql = case node
+          when Prism::StringNode then node.unescaped
+          # A squiggly heredoc over several lines parses as one string per line.
+          when Prism::InterpolatedStringNode then adjacent_literals(node)
           end
+          sql.split(";") unless sql.nil? || sql == RailsAiContext::Confidence::INFERRED
         end
 
         # A statement naming a table it cannot read is counted, never given another table.
@@ -83,24 +98,18 @@ module RailsAiContext
           # remove_index takes one column or an array of them.
           when :remove_index then result[:columns] = literal_strings(positional.first)
           when :rename_column then result.merge!(column: names[0], new_name: names[1])
+          when :rename_index then result.merge!(old_name: names[0], new_name: names[1])
           when :change_column then result.merge!(column: names[0], column_type: names[1])
           when :change_column_null then result.merge!(column: names[0], null: boolean_value(positional[1]))
           when :change_column_default
             result[:column] = names[0]
             result[:new_default] = extract_value(positional[1]) if positional[1]
           when :add_timestamps then result.merge!(default_source: default_source(node), default_proc: proc_default?(node))
+          when :add_check_constraint, :remove_check_constraint then result[:expression] = names[0]
           end
           result
         end
 
-        # t.column is TableDefinition#column: a column definition like t.string.
-        def column_definition(node, args)
-          positional = args.reject { |arg| arg.is_a?(Prism::KeywordHashNode) }
-          { type: :column, name: literal_string(positional[0]), column_type: literal_string(positional[1]),
-            options: extract_keyword_options(node), default_source: default_source(node), default_proc: proc_default?(node),
-            location: node.location.start_line }
-        end
-
         # The block parameter a create_table body names `t`, whether it reads
         # as a local variable or as a bare call.
         def block_column?(receiver)