sorbet-rails 0.7.0 → 0.7.1

data/lib/sorbet-rails/model_column_utils.rb

@@ -0,0 +1,129 @@
+# typed: strict
+module SorbetRails::ModelColumnUtils
+  extend T::Sig
+  extend T::Helpers
+
+  abstract!
+
+  class ColumnType < T::Struct
+    extend T::Sig
+
+    const :base_type, T.any(Class, String)
+    const :nilable, T.nilable(T::Boolean)
+    const :array_type,  T.nilable(T::Boolean)
+
+    sig { returns(String) }
+    def to_s
+      type = base_type.to_s
+      # A nullable array column should be T.nilable(T::Array[column_type]) not T::Array[T.nilable(column_type)]
+      type = "T::Array[#{type}]" if array_type
+      type = "T.nilable(#{type})" if nilable
+      type
+    end
+  end
+
+  # if we're a HABTM class then model_class is an anonymous class (see the rails link below) and
+  # i'm not sure how to explain that to sorbet other than T.class_of(Class).
+  sig { abstract.returns(T.any(T.class_of(ActiveRecord::Base), T.class_of(Class))) }
+  def model_class; end
+
+  sig { params(column_def: T.untyped).returns(ColumnType) }
+  def type_for_column_def(column_def)
+    cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?
+      ActiveRecord::Base.connection.lookup_cast_type_from_column(column_def) :
+      column_def.cast_type
+
+    array_type = false
+    if column_def.try(:array?)
+      cast_type = cast_type.subtype if cast_type.try(:subtype)
+      array_type = true
+    end
+    strict_type =
+      active_record_type_to_sorbet_type(
+        cast_type,
+        time_zone_aware: time_zone_aware_column?(column_def, cast_type),
+      )
+
+    ColumnType.new(
+      base_type: strict_type,
+      nilable: nilable_column?(column_def),
+      array_type: array_type,
+    )
+  end
+
+  # True if this column is "time zone aware", which means it'll be converted on
+  # access from its original class (e.g. `DateTime`) to something with better
+  # support for time zones (usually `ActiveSupport::TimeWithZone`)
+  sig do
+    params(column_def: T.untyped, cast_type: T.untyped).returns(T::Boolean)
+  end
+  def time_zone_aware_column?(column_def, cast_type)
+    # this private class method returns true if the attribute should be "time
+    # zone aware"; it takes into account various global and model-specific
+    # configuration options as described here:
+    # https://api.rubyonrails.org/classes/ActiveRecord/Timestamp.html
+    #
+    # although it's private, it's better this than trying to reimplement the "is
+    # this attribute tz aware?" logic ourselves
+    model_class.send(
+      :create_time_zone_conversion_attribute?,
+      column_def.name,
+      cast_type
+    )
+  end
+
+  sig { params(column_def: T.untyped).returns(T::Boolean) }
+  def nilable_column?(column_def)
+    !!(column_def.null && !attribute_has_unconditional_presence_validation?(column_def.name))
+  end
+
+  sig do
+    params(
+      klass: Object,
+      time_zone_aware: T::Boolean,
+    ).returns(T.any(String, Class))
+  end
+  def active_record_type_to_sorbet_type(klass, time_zone_aware: false)
+    case klass
+    when ActiveRecord::Type::Boolean
+      "T::Boolean"
+    when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
+      time_zone_aware ? ActiveSupport::TimeWithZone : Time
+    when ActiveRecord::Type::Date
+      Date
+    when ActiveRecord::Type::Decimal
+      BigDecimal
+    when ActiveRecord::Type::Float
+      Float
+    when ActiveRecord::Type::BigInteger, ActiveRecord::Type::Integer, ActiveRecord::Type::DecimalWithoutScale, ActiveRecord::Type::UnsignedInteger
+      Integer
+    when ActiveRecord::Type::Binary, ActiveRecord::Type::String, ActiveRecord::Type::Text
+      String
+    else
+      # Json type is only supported in Rails 5.2 and above
+      case
+      when Object.const_defined?('ActiveRecord::Type::Json') && klass.is_a?(ActiveRecord::Type::Json)
+        "T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)"
+      when Object.const_defined?('ActiveRecord::Enum::EnumType') && klass.is_a?(ActiveRecord::Enum::EnumType)
+        String
+      # For Postgres UUIDs, they're represented as Strings
+      when Object.const_defined?('ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid') && klass.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid)
+        String
+      else
+        "T.untyped"
+      end
+    end
+  end
+
+  sig { params(attribute: T.any(String, Symbol)).returns(T::Boolean) }
+  def attribute_has_unconditional_presence_validation?(attribute)
+    model_class_srb = model_class
+    model_class_srb < ActiveRecord::Base &&
+    model_class_srb.validators_on(attribute).any? do |validator|
+      validator.is_a?(ActiveModel::Validations::PresenceValidator) &&
+        !validator.options.key?(:if) &&
+        !validator.options.key?(:unless) &&
+        !validator.options.key?(:on)
+    end
+  end
+end

data/lib/sorbet-rails/model_plugins/active_record_assoc.rb

@@ -36,10 +36,30 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
     assoc_class = assoc_should_be_untyped?(reflection) ? "T.untyped" : "::#{reflection.klass.name}"
     assoc_type = (belongs_to_and_required?(reflection) || has_one_and_required?(reflection)) ? assoc_class : "T.nilable(#{assoc_class})"
 
+    params = [
+      Parameter.new("*args", type: "T.untyped"),
+      Parameter.new("&block", type: "T.nilable(T.proc.params(object: #{assoc_class}).void)")
+    ]
+
     assoc_module_rbi.create_method(
       assoc_name.to_s,
       return_type: assoc_type,
     )
+    assoc_module_rbi.create_method(
+      "build_#{assoc_name}",
+      parameters: params,
+      return_type: assoc_class,
+    )
+    assoc_module_rbi.create_method(
+      "create_#{assoc_name}",
+      parameters: params,
+      return_type: assoc_class,
+    )
+    assoc_module_rbi.create_method(
+      "create_#{assoc_name}!",
+      parameters: params,
+      return_type: assoc_class,
+    )
     assoc_module_rbi.create_method(
       "#{assoc_name}=",
       parameters: [
@@ -114,9 +134,16 @@ class SorbetRails::ModelPlugins::ActiveRecordAssoc < SorbetRails::ModelPlugins::
       return_type: relation_class,
     )
     unless assoc_should_be_untyped?(reflection)
+      if reflection.klass.table_exists?
+        # Normally the id_type is an Integer, but it could be a String if using
+        # UUIDs.
+        id_type = type_for_column_def(reflection.klass.columns_hash["id"]).to_s
+      else
+        id_type = "T.untyped"
+      end
       assoc_module_rbi.create_method(
         "#{assoc_name.singularize}_ids",
-        return_type: "T::Array[Integer]",
+        return_type: "T::Array[#{id_type}]",
       )
     end
     assoc_module_rbi.create_method(

data/lib/sorbet-rails/model_plugins/active_record_attribute.rb

@@ -2,23 +2,6 @@
 require ('sorbet-rails/model_plugins/base')
 class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugins::Base
 
-  class ColumnType < T::Struct
-    extend T::Sig
-
-    const :base_type, T.any(Class, String)
-    const :nilable, T.nilable(T::Boolean)
-    const :array_type,  T.nilable(T::Boolean)
-
-    sig { returns(String) }
-    def to_s
-      type = base_type.to_s
-      # A nullable array column should be T.nilable(T::Array[column_type]) not T::Array[T.nilable(column_type)]
-      type = "T::Array[#{type}]" if array_type
-      type = "T.nilable(#{type})" if nilable
-      type
-    end
-  end
-
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
     columns_hash = @model_class.table_exists? ? @model_class.columns_hash : {}
@@ -140,91 +123,6 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     end
   end
 
-  sig { params(column_def: T.untyped).returns(ColumnType) }
-  def type_for_column_def(column_def)
-    cast_type = ActiveRecord::Base.connection.respond_to?(:lookup_cast_type_from_column) ?
-      ActiveRecord::Base.connection.lookup_cast_type_from_column(column_def) :
-      column_def.cast_type
-
-    array_type = false
-    if column_def.try(:array?)
-      cast_type = cast_type.subtype if cast_type.try(:subtype)
-      array_type = true
-    end
-    strict_type =
-      active_record_type_to_sorbet_type(
-        cast_type,
-        time_zone_aware: time_zone_aware_column?(column_def, cast_type),
-      )
-
-    ColumnType.new(
-      base_type: strict_type,
-      nilable: nilable_column?(column_def),
-      array_type: array_type,
-    )
-  end
-
-  sig do
-    params(
-      klass: Object,
-      time_zone_aware: T::Boolean,
-    ).returns(T.any(String, Class))
-  end
-  def active_record_type_to_sorbet_type(klass, time_zone_aware: false)
-    case klass
-    when ActiveRecord::Type::Boolean
-      "T::Boolean"
-    when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-      time_zone_aware ? ActiveSupport::TimeWithZone : Time
-    when ActiveRecord::Type::Date
-      Date
-    when ActiveRecord::Type::Decimal
-      BigDecimal
-    when ActiveRecord::Type::Float
-      Float
-    when ActiveRecord::Type::BigInteger, ActiveRecord::Type::Integer, ActiveRecord::Type::DecimalWithoutScale, ActiveRecord::Type::UnsignedInteger
-      Integer
-    when ActiveRecord::Type::Binary, ActiveRecord::Type::String, ActiveRecord::Type::Text
-      String
-    else
-      # Json type is only supported in Rails 5.2 and above
-      case
-      when Object.const_defined?('ActiveRecord::Type::Json') && klass.is_a?(ActiveRecord::Type::Json)
-        "T.any(T::Array[T.untyped], T::Boolean, Float, T::Hash[T.untyped, T.untyped], Integer, String)"
-      when Object.const_defined?('ActiveRecord::Enum::EnumType') && klass.is_a?(ActiveRecord::Enum::EnumType)
-        String
-      else
-        "T.untyped"
-      end
-    end
-  end
-
-  # True if this column is "time zone aware", which means it'll be converted on
-  # access from its original class (e.g. `DateTime`) to something with better
-  # support for time zones (usually `ActiveSupport::TimeWithZone`)
-  sig do
-    params(column_def: T.untyped, cast_type: T.untyped).returns(T::Boolean)
-  end
-  def time_zone_aware_column?(column_def, cast_type)
-    # this private class method returns true if the attribute should be "time
-    # zone aware"; it takes into account various global and model-specific
-    # configuration options as described here:
-    # https://api.rubyonrails.org/classes/ActiveRecord/Timestamp.html
-    #
-    # although it's private, it's better this than trying to reimplement the "is
-    # this attribute tz aware?" logic ourselves
-    @model_class.send(
-      :create_time_zone_conversion_attribute?,
-      column_def.name,
-      cast_type
-    )
-  end
-
-  sig { params(column_def: T.untyped).returns(T::Boolean) }
-  def nilable_column?(column_def)
-    !!(column_def.null && !attribute_has_unconditional_presence_validation?(column_def.name))
-  end
-
   sig { params(column_type: ColumnType).returns(String) }
   def value_type_for_attr_writer(column_type)
     # it's safe - and convenient - to assign any "time like" object to a time zone

data/lib/sorbet-rails/model_plugins/base.rb

@@ -29,15 +29,5 @@ module SorbetRails::ModelPlugins
       @model_class = T.let(model_class, T.class_of(ActiveRecord::Base))
       @available_classes = T.let(available_classes, T::Set[String])
     end
-
-    sig { params(attribute: T.any(String, Symbol)).returns(T::Boolean) }
-    def attribute_has_unconditional_presence_validation?(attribute)
-      model_class.validators_on(attribute).any? do |validator|
-        validator.is_a?(ActiveModel::Validations::PresenceValidator) &&
-          !validator.options.key?(:if) &&
-          !validator.options.key?(:unless) &&
-          !validator.options.key?(:on)
-      end
-    end
   end
 end

data/lib/sorbet-rails/model_utils.rb

@@ -1,14 +1,17 @@
 # typed: strict
+require('sorbet-rails/model_column_utils')
 module SorbetRails::ModelUtils
   extend T::Sig
   extend T::Helpers
+  include SorbetRails::ModelColumnUtils
 
   abstract!
 
   # if we're a HABTM class then model_class is an anonymous class (see the rails link below) and
   # i'm not sure how to explain that to sorbet other than T.class_of(Class).
-  sig { abstract.returns(T.any(T.class_of(ActiveRecord::Base), T.class_of(Class))) }
-  def model_class; end
+  # This is also defined in ModelColumnUtils
+  # sig { abstract.returns(T.any(T.class_of(ActiveRecord::Base), T.class_of(Class))) }
+  # def model_class; end
 
   sig { returns(T::Boolean) }
   def habtm_class?

data/lib/sorbet-rails/rails_mixins/pluck_to_tstruct.rb

@@ -7,27 +7,37 @@ module SorbetRails::PluckToTStruct
     type_parameters(:U).
     params(
       ta_struct: ITypeAssert[T.type_parameter(:U)],
+      associations: T::Hash[Symbol, String],
     ).
     returns(T::Array[T.type_parameter(:U)])
   }
-  def pluck_to_tstruct(ta_struct)
+  def pluck_to_tstruct(ta_struct, associations: {})
     tstruct = ta_struct.get_type
-  
+
     if !(tstruct < T::Struct)
       raise UnexpectedType.new("pluck_to_tstruct expects a tstruct subclass, given #{tstruct}")
     end
 
-    keys = tstruct.props.keys
+    tstruct_keys = tstruct.props.keys
+    associations_keys = associations.keys
+    invalid_keys = associations_keys - tstruct_keys
+
+    if invalid_keys.any?
+      raise UnexpectedAssociations.new("Argument 'associations' contains keys that don't exist in #{tstruct}: #{invalid_keys.join(", ")}")
+    end
+
+    pluck_keys = (tstruct_keys - associations_keys) + associations.values
 
     # loosely based on pluck_to_hash gem
     # https://github.com/girishso/pluck_to_hash/blob/master/lib/pluck_to_hash.rb
-    keys_one = keys.size == 1
-    pluck(*keys).map do |row|
+    keys_one = pluck_keys.size == 1
+    pluck(*pluck_keys).map do |row|
       row = [row] if keys_one
-      value = Hash[keys.zip(row)]
+      value = Hash[tstruct_keys.zip(row)]
       tstruct.new(value)
     end
   end
-  
+
   class UnexpectedType < StandardError; end
+  class UnexpectedAssociations < StandardError; end
 end

data/lib/sorbet-rails/sorbet_utils.rb

@@ -5,168 +5,170 @@ require('sorbet-runtime')
 require('method_source')
 require('parser/current')
 
-module SorbetRails::SorbetUtils
-  extend T::Sig
-  include Kernel
-
-  class ParsedParamDef < T::Struct
-    const :name, Symbol
-    const :kind, Symbol
-    const :type_str, String
-    prop :default, T.nilable(String), default: nil
-    prop :prefix, T.nilable(String)
-    prop :suffix, T.nilable(String)
-  end
-
-  sig { params(method_def: UnboundMethod).returns(T::Array[Parlour::RbiGenerator::Parameter]) }
-  def self.parameters_from_method_def(method_def)
-    signature = T::Private::Methods.signature_for_method(method_def)
-    method_def = signature.nil? ? method_def : signature.method
-
-    parameters_with_type = signature.nil? ?
-      method_def.parameters.map { |p|
-        ParsedParamDef.new(
-          name: p.size == 1 ? :_ : p[1],  # give param without name default name _
-          kind: p[0], # append untyped as type of each param
-          type_str: 'T.untyped',
-        )
-      } :
-      get_ordered_parameters_with_type(signature)
-
-    # add prefix & suffix
-    parameters_with_type.each do |param_def|
-      param_def.prefix =
-        case param_def.kind
-        when :rest; '*'
-        when :keyrest; '**'
-        when :block; '&'
-        # being comprehensive
-        when :req, :opt; ''
-        when :key, :keyreq; ''
-        else nil
-        end
-
-      param_def.suffix =
-        case param_def.kind
-        when :key, :keyreq; ':'
-        else nil
-        end
+module SorbetRails
+  module SorbetUtils
+    extend T::Sig
+    include Kernel
+
+    class ParsedParamDef < T::Struct
+      const :name, Symbol
+      const :kind, Symbol
+      const :type_str, String
+      prop :default, T.nilable(String), default: nil
+      prop :prefix, T.nilable(String)
+      prop :suffix, T.nilable(String)
     end
 
-    extract_default_value_for_params!(
-      parameters_with_type,
-      method_def,
-    )
-
-    parameters_with_type.map do |param_def|
-      ::Parlour::RbiGenerator::Parameter.new(
-        "#{param_def.prefix}#{param_def.name}#{param_def.suffix}",
-        type: param_def.type_str,
-        default: param_def.default,
+    sig { params(method_def: UnboundMethod).returns(T::Array[Parlour::RbiGenerator::Parameter]) }
+    def self.parameters_from_method_def(method_def)
+      signature = T::Private::Methods.signature_for_method(method_def)
+      method_def = signature.nil? ? method_def : signature.method
+
+      parameters_with_type = signature.nil? ?
+        method_def.parameters.map { |p|
+          ParsedParamDef.new(
+            name: p.size == 1 ? :_ : p[1],  # give param without name default name _
+            kind: p[0], # append untyped as type of each param
+            type_str: 'T.untyped',
+          )
+        } :
+        get_ordered_parameters_with_type(signature)
+
+      # add prefix & suffix
+      parameters_with_type.each do |param_def|
+        param_def.prefix =
+          case param_def.kind
+          when :rest; '*'
+          when :keyrest; '**'
+          when :block; '&'
+          # being comprehensive
+          when :req, :opt; ''
+          when :key, :keyreq; ''
+          else nil
+          end
+
+        param_def.suffix =
+          case param_def.kind
+          when :key, :keyreq; ':'
+          else nil
+          end
+      end
+
+      extract_default_value_for_params!(
+        parameters_with_type,
+        method_def,
       )
-    end
-  end
 
-  sig {
-    params(signature: T::Private::Methods::Signature).
-    returns(T::Array[ParsedParamDef])
-  }
-  def self.get_ordered_parameters_with_type(signature)
-    # extract original method param from signature
-    # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/methods/signature.rb#L5-L8
-    params = T.let([], T::Array[ParsedParamDef])
-    signature.arg_types.each do |arg_type|
-      # could be :opt, but doesn't matter
-      params << ParsedParamDef.new(
-        name: arg_type[0],
-        kind: :req,
-        type_str: arg_type[1].to_s,
-      )
-    end
-    signature.kwarg_types.each do |kwarg_name, kwarg_type|
-      # could be :key, but doesn't matter
-      params << ParsedParamDef.new(
-        name: kwarg_name,
-        kind: :keyreq,
-        type_str: kwarg_type.to_s,
-      )
-    end
-    if signature.has_rest
-      params << ParsedParamDef.new(
-        name: signature.rest_name,
-        kind: :rest,
-        type_str: signature.rest_type.to_s,
-      )
-    end
-    if signature.has_keyrest
-      params << ParsedParamDef.new(
-        name: signature.keyrest_name,
-        kind: :keyrest,
-        type_str: signature.keyrest_type.to_s,
-      )
-    end
-    if !signature.block_name.nil?
-      # special case `.void` in a proc
-      # see https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/types/proc.rb#L10
-      block_param_type = signature.block_type.to_s
-      block_param_type = block_param_type.gsub('returns(<VOID>)', 'void')
-      params << ParsedParamDef.new(
-        name: signature.block_name,
-        kind: :block,
-        type_str: block_param_type,
-      )
+      parameters_with_type.map do |param_def|
+        ::Parlour::RbiGenerator::Parameter.new(
+          "#{param_def.prefix}#{param_def.name}#{param_def.suffix}",
+          type: param_def.type_str,
+          default: param_def.default,
+        )
+      end
     end
-    params
-  end
 
-  sig {
-    params(
-      parsed_params: T::Array[ParsedParamDef],
-      method_def: UnboundMethod,
-    ).void
-  }
-  def self.extract_default_value_for_params!(parsed_params, method_def)
-    source = method_def.source
-    parsed_ast = Parser::CurrentRuby.parse(source)
-    if parsed_ast.type != :def
-      # could be a method added at runtime? ignore it
-      puts "Warning: unable to parse the source of #{method_def.name}"
-      return
+    sig {
+      params(signature: T::Private::Methods::Signature).
+      returns(T::Array[ParsedParamDef])
+    }
+    def self.get_ordered_parameters_with_type(signature)
+      # extract original method param from signature
+      # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/methods/signature.rb#L5-L8
+      params = T.let([], T::Array[ParsedParamDef])
+      signature.arg_types.each do |arg_type|
+        # could be :opt, but doesn't matter
+        params << ParsedParamDef.new(
+          name: arg_type[0],
+          kind: :req,
+          type_str: arg_type[1].to_s,
+        )
+      end
+      signature.kwarg_types.each do |kwarg_name, kwarg_type|
+        # could be :key, but doesn't matter
+        params << ParsedParamDef.new(
+          name: kwarg_name,
+          kind: :keyreq,
+          type_str: kwarg_type.to_s,
+        )
+      end
+      if signature.has_rest
+        params << ParsedParamDef.new(
+          name: signature.rest_name,
+          kind: :rest,
+          type_str: signature.rest_type.to_s,
+        )
+      end
+      if signature.has_keyrest
+        params << ParsedParamDef.new(
+          name: signature.keyrest_name,
+          kind: :keyrest,
+          type_str: signature.keyrest_type.to_s,
+        )
+      end
+      if !signature.block_name.nil?
+        # special case `.void` in a proc
+        # see https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/types/proc.rb#L10
+        block_param_type = signature.block_type.to_s
+        block_param_type = block_param_type.gsub('returns(<VOID>)', 'void')
+        params << ParsedParamDef.new(
+          name: signature.block_name,
+          kind: :block,
+          type_str: block_param_type,
+        )
+      end
+      params
     end
 
-    args = parsed_ast.children[1]
-    if args.type != :args
-      puts "Warning: unable to parse the source of #{method_def.name}"
-      return
+    sig {
+      params(
+        parsed_params: T::Array[ParsedParamDef],
+        method_def: UnboundMethod,
+      ).void
+    }
+    def self.extract_default_value_for_params!(parsed_params, method_def)
+      source = method_def.source
+      parsed_ast = Parser::CurrentRuby.parse(source)
+      if parsed_ast.type != :def
+        # could be a method added at runtime? ignore it
+        puts "Warning: unable to parse the source of #{method_def.name}"
+        return
+      end
+
+      args = parsed_ast.children[1]
+      if args.type != :args
+        puts "Warning: unable to parse the source of #{method_def.name}"
+        return
+      end
+
+      parsed_params_map = Hash[parsed_params.map {|p| [p.name, p]}]
+      args.children.each do |arg|
+        arg_name = arg.children[0]
+        default = arg.children[1] ? node_to_s(arg.children[1]) : nil
+
+        next if arg_name.blank?
+
+        param_def = parsed_params_map[arg_name]
+
+        raise UnexpectedParam.new(
+          "Unexpected param #{arg_name} when parsing #{method_def.name}"
+        ) unless param_def.present?
+
+        param_def.default = default
+      end
     end
 
-    parsed_params_map = Hash[parsed_params.map {|p| [p.name, p]}]
-    args.children.each do |arg|
-      arg_name = arg.children[0]
-      default = arg.children[1] ? node_to_s(arg.children[1]) : nil
-
-      next if arg_name.blank?
-
-      param_def = parsed_params_map[arg_name]
-
-      raise UnexpectedParam.new(
-        "Unexpected param #{arg_name} when parsing #{method_def.name}"
-      ) unless param_def.present?
+    # Given an AST node, returns the source code from which it was constructed.
+    # If the given AST node is nil, this returns nil.
+    # Taken from https://github.com/AaronC81/parlour/blob/master/lib/parlour/type_parser.rb#L506
+    sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
+    def self.node_to_s(node)
+      return nil unless node
 
-      param_def.default = default
+      exp = node.loc.expression
+      exp.source_buffer.source[exp.begin_pos...exp.end_pos]
     end
-  end
-
-  # Given an AST node, returns the source code from which it was constructed.
-  # If the given AST node is nil, this returns nil.
-  # Taken from https://github.com/AaronC81/parlour/blob/master/lib/parlour/type_parser.rb#L506
-  sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
-  def self.node_to_s(node)
-    return nil unless node
 
-    exp = node.loc.expression
-    exp.source_buffer.source[exp.begin_pos...exp.end_pos]
+    class UnexpectedParam < StandardError; end
   end
-
-  class UnexpectedParam < StandardError; end
 end