sorbet-rails 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58c588bf2eb9eb09d2c4322d54436840452bb5a026e6ca4132df8e651aa26968
-  data.tar.gz: 11b54b70f6c86f5d97152fc5a7c9f0b48b021b8be03472fcb83014557353dc4c
+  metadata.gz: b2400ac696f93d779e930dac9f4d6e5781f1ce976e1ee98599a222a78c658588
+  data.tar.gz: 25d8ef2f00b2eb87afe05144323927df66f328ffe2bcff00c578396824d5053e
 SHA512:
-  metadata.gz: 6b88d51c0fae405a9249974746b250ad6ad2ce8ca09a5620c385105bffd0617dd2fbf5584a07a35abb35104c8242a1954156be9f98ddc456554803ad3b2a92ac
-  data.tar.gz: 98c2836dcbbb20798d0b57579eb7c3a07175bf8e5c58ed062cb652d2c7826bf62c1586cc4a9a5337702e88151862c8caf4cda81a21765f583a3c85caefc3d659
+  metadata.gz: 8bb839d0eb25c882678e7099796b30ad4215d722a809038593b589c3c6b1bb2b37c42813539e0e314977425052f24b11f85f193f03c84aceb0145d32f0e361bb
+  data.tar.gz: ce4d93314cbeb06d881177429ba7df4b02d5c7783e9cae839dbfa46fb746b611d13dcc49fd996baf839319af47d848d44860e4561474db104d79fd8f797220f4

data/README.md

@@ -30,14 +30,14 @@ Add `sorbet-rails` to the [`:default` group](https://bundler.io/v2.0/guides/grou
 
 3. Generate RBI files for your routes, models, etc
 ```sh
-❯ rake rails_rbi:routes
-❯ rake rails_rbi:models
-❯ rake rails_rbi:helpers
-❯ rake rails_rbi:mailers
-❯ rake rails_rbi:custom
+❯ bundle exec rake rails_rbi:routes
+❯ bundle exec rake rails_rbi:models
+❯ bundle exec rake rails_rbi:helpers
+❯ bundle exec rake rails_rbi:mailers
+❯ bundle exec rake rails_rbi:custom
 
 # or run them all at once
-❯ rake rails_rbi:all
+❯ bundle exec rake rails_rbi:all
 ```
 
 4. Update hidden-definition files and automatically upgrade each file's typecheck level:
@@ -53,11 +53,11 @@ Because we've generated RBI files for routes, models, and helpers, a lot more fi
 
 This Rake task generates RBI files for all models in the Rails application (all descendants of `ActiveRecord::Base`):
 ```sh
-❯ rake rails_rbi:models
+❯ bundle exec rake rails_rbi:models
 ```
 You can also regenerate RBI files for specific models. To accommodate for STI, this will generate rbi for all the subclasses of the models included.
 ```sh
-❯ rake rails_rbi:models[ModelName,AnotherOne,...]
+❯ bundle exec rake rails_rbi:models[ModelName,AnotherOne,...]
 ```
 The generation task currently creates the following signatures:
 - Column getters & setters
@@ -73,6 +73,7 @@ We also add following methods to make type-checking more easily:
 - [`find_n`, `first_n`, `last_n`](https://github.com/chanzuckerberg/sorbet-rails#find-first-and-last)
 - [`pluck_to_tstruct`](#pluck_to_tstruct-instead-of-pluck)
 - [`typed_enum`](#enums)
+- [`Model::RelationType`](#relationtype-alias)
 
 #### `pluck_to_tstruct` instead of `pluck`
 
@@ -159,9 +160,25 @@ Generates only typed enum setter & getter:
   def typed_house=(value); end
 ```
 
+#### `RelationType` alias
+
+There are several kinds of relations of a model: `User::ActiveRecord_Relation`, `User::ActiveRecord_AssociationRelation` and `User::ActiveRecord_Associations_CollectionProxy`. Usually the code may need just any relation type. We add a `Model::RelationType` type alias for every model to use it.
+ 
+```ruby
+class User
+  RelationType = T.type_alias do
+    T.any(
+      User::ActiveRecord_Relation,
+      User::ActiveRecord_AssociationRelation,
+      User::ActiveRecord_Associations_CollectionProxy
+    )
+  end
+end
+```
+
 ### Controllers
 ```sh
-❯ rake rails_rbi:custom
+❯ bundle exec  rake rails_rbi:custom
 ```
 
 `sorbet-rails` adds `TypedParams` to extact typed controller parameters.
@@ -191,7 +208,7 @@ Note: [`require_typed` and `fetch_typed`](https://github.com/chanzuckerberg/sorb
 
 This Rake task generates an RBI file defining `_path` and `_url` methods for all named routes in `routes.rb`:
 ```sh
-❯ rake rails_rbi:routes
+❯ bundle exec rake rails_rbi:routes
 ```
 
 ### Helpers
@@ -199,7 +216,7 @@ This Rake task generates an RBI file defining `_path` and `_url` methods for all
 This Rake task generates a `helpers.rbi` file that includes a basic module definition which includes the `Kernel` module and `ActionView::Helpers`, to allow for some basic Ruby methods to be used in helpers without Sorbet complaining.
 
 ```sh
-❯ rake rails_rbi:helpers
+❯ bundle exec rake rails_rbi:helpers
 ```
 
 If you have additional modules that are included in all your helpers and you want `helpers.rbi` to reflect this, you can configure it:
@@ -215,7 +232,7 @@ end
 
 This Rake task generates RBI files for all mailer classes in the Rails application (all descendants of `ActionMailer::Base`)
 ```sh
-❯ rake rails_rbi:mailers
+❯ bundle exec rake rails_rbi:mailers
 ```
 
 Since mailing action methods is based on instance methods defined in a mailer class, the signature of a mailing action method will be dependent on the signature the instance method has
@@ -231,16 +248,19 @@ instructions specify that `sorbet-rails` should be placed in the [`:default`
 group](https://bundler.io/v2.0/guides/groups.html) of the `Gemfile`, not a
 specific environment group (eg. `development` only).
 
-- Relation class: Making the relations available at runtime (they are normally private constants, the gem makes them public)
-  - Examples: `User::ActiveRecord_Relation`, `User::ActiveRecord_AssociationRelation`
-- Model:
+- Model: The gem provides some helper method to a model to make type-checking easier:
   - `find_n`, `first_n`, `last_n`
   - `pluck_to_tstruct`
   - `typed_enum`
-- Controller: using `TypedParams`
+  
+- Model Relation: 
+  - Make relation classes public. By default, relation classes like `User::ActiveRecord_Relation`, `User::ActiveRecord_AssociationRelation` are private
+  - Add type alias, eg `Model::RelationType`, to represents any type of relation of a model.
+
+- Controller: use `TypedParams` to convert controller parameters to a typed structure
 
 In addition to `require`ing `sorbet-rails`, you must also run
-`rake rails_rbi:custom`, which will produce the RBI for these runtime features.
+`bundle exec rake rails_rbi:custom`, which will produce the RBI for these runtime features.
 
 Discussion:
 [#211](https://github.com/chanzuckerberg/sorbet-rails/issues/211),
@@ -248,7 +268,13 @@ Discussion:
 
 ## Tips & Tricks
 
-### Overriding generated signatures
+### Look for `# typed: ignore` files
+
+Because Sorbet's initial setup tries to flag files at whichever typecheck level generates 0 errors, there may be files in your repository that are `# typed: ignore`. This is because sometimes Rails allows very dynamic code that Sorbet does not believe it can typecheck.
+
+It is worth going through the list of files that is ignored and resolve them (and auto upgrade the types of other files; see [initial setup](#initial-setup) above). Usually this will make many more files able to be typechecked.
+
+### Overriding generated signatures if needed
 
 `sorbet-rails` relies on Rails reflection to generate signatures. There are features this gem doesn't support yet such as [serialize](https://github.com/chanzuckerberg/sorbet-rails/issues/49) and [attribute custom types](https://github.com/chanzuckerberg/sorbet-rails/issues/16). The gem also doesn't know the signature of any methods you have overridden. However, it is possible to override the signatures that `sorbet-rails` generates.
 
@@ -333,12 +359,6 @@ If you wanted to make these changes using [Codemod](https://github.com/facebook/
 ```
 Note that Codemod's preview may show that the indentation is off, but it works.
 
-### Look for `# typed: ignore` files
-
-Because Sorbet's initial setup tries to flag files at whichever typecheck level generates 0 errors, there may be files in your repository that are `# typed: ignore`. This is because sometimes Rails allows very dynamic code that Sorbet does not believe it can typecheck.
-
-It is worth going through the list of files that is ignored and resolve them (and auto upgrade the types of other files; see [initial setup](#initial-setup) above). Usually this will make many more files able to be typechecked.
-
 ### `unscoped` with a block
 
 The [`unscoped` method](https://apidock.com/rails/ActiveRecord/Scoping/Default/ClassMethods/unscoped) returns a `Relation` when no block is provided. When a block is provided, `unscoped` calls the block and returns its result, which could be any type.
@@ -356,6 +376,31 @@ Model.unscoped.scoping do … end
 
 The [`select` method](https://apidock.com/rails/v4.0.2/ActiveRecord/QueryMethods/select) in Rails has two modes: it can be given a list of symbols, in which case rails will only return the given columns from the database, or it can be given a block, in which case it acts like [`Enumerable.select`](https://ruby-doc.org/core-2.6.4/Enumerable.html) and returns an array. We have chosen to support the first use case. If you want to pass a block to `select`, you can simply call `to_a` before you do. Note that this would be done within the `select` call anyway, so the performance penalty will be minimal.
 
+### `flatten` an array of relation
+
+When you call `flatten` on an array of ActiveRecord::Relation, sorbet [doesn't recognize](https://github.com/sorbet/sorbet/issues/2767) that it will flatten the relation and return an array of model. The work around is to call `to_a` on the relation first.
+
+```ruby
+# doesn't work
+arr = [Model.recent, Model.old].flatten # T::Array[Model::ActiveRecord_Relation]
+
+# work around
+arr = [Model.recent, Model.old].map(&:to_a).flatten # T::Array[Model]
+```
+
+### Avoid `and_call_original` in rspecs
+
+If you run into the following issue when running rspec, it's likely because you're using `expect(:method_name).and_call_original` to mock a method in RSpec. We've found the double mock doesn't interact well with Sorbet's sig wrapper and caused flaky spec. The spec should be rewritten to expect the outcome of the method instead. (It still works with `expect(:method_name)` and `expect(:method_name).and_return(...)`
+
+```
+     RuntimeError:
+       `sig` not present for method `:method_name` but you're trying to run it anyways. This should
+       only be executed if you used `alias_method` to grab a handle to a method after `sig`ing it, but
+       that clearly isn't what you are doing. Maybe look to see if an exception was thrown in your `sig`
+       lambda or somehow else your `sig` wasn't actually applied to the method. Contact #dev-productivity
+       if you're really stuck.
+```
+
 ## Extending Model Generation Task with Custom Plugins
 
 `sorbet-rails` support a customizable plugin system that you can use to generate additional RBI for each model. This will be useful to generate RBI for methods dynamically added by gems or private concerns. If you write plugins for public gems, please feel free to contribute it to this repo.

data/bin/sorbet

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -e
+
+`bundle show sorbet-static`/libexec/sorbet $@
+

data/lib/sorbet-rails/helper_rbi_formatter.rb

@@ -18,7 +18,7 @@ class SorbetRails::HelperRbiFormatter
 
     @parlour.root.add_comments([
       'This is an autogenerated file for Rails helpers.',
-      'Please rerun rake rails_rbi:helpers to regenerate.'
+      'Please rerun bundle exec rake rails_rbi:helpers to regenerate.'
     ])
 
     @helpers.each do |helper|

data/lib/sorbet-rails/mailer_rbi_formatter.rb

@@ -17,7 +17,7 @@ class SorbetRails::MailerRbiFormatter
 
     @parlour.root.add_comments([
       'This is an autogenerated file for Rails helpers.',
-      'Please rerun rake rails_rbi:mailers to regenerate.'
+      'Please rerun bundle exec rake rails_rbi:mailers to regenerate.'
     ])
 
     @parlour.root.create_class(@mailer_class.name) do |mailer_rbi|

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

@@ -2,6 +2,22 @@
 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
+      type = "T.nilable(#{type})" if nilable
+      type = "T::Array[#{type}]" if array_type
+      type
+    end
+  end
+
   sig { override.params(root: Parlour::RbiGenerator::Namespace).void }
   def generate(root)
     columns_hash = @model_class.table_exists? ? @model_class.columns_hash : {}
@@ -123,7 +139,7 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     end
   end
 
-  sig { params(column_def: T.untyped).returns(T.any(String, Class)) }
+  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) :
@@ -135,10 +151,11 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
         time_zone_aware: time_zone_aware_column?(column_def, cast_type),
       )
 
-    if column_def.respond_to?(:array?) && column_def.array?
-      strict_type = "T::Array[#{strict_type}]"
-    end
-    column_def.null ? "T.nilable(#{strict_type})" : strict_type
+    ColumnType.new(
+      base_type: strict_type,
+      nilable: column_def.null,
+      array_type: column_def.try(:array?),
+    )
   end
 
   sig do
@@ -197,29 +214,23 @@ class SorbetRails::ModelPlugins::ActiveRecordAttribute < SorbetRails::ModelPlugi
     )
   end
 
-  sig { params(column_type: Object).returns(String) }
+  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
     # aware attribute because Rails will cast it to a `ActiveSupport::TimeWithZone`
     # (so rereading the attribute will always return the `TimeWithZone` type)
-    assignable_time_types = [DateTime, Date, Time, ActiveSupport::TimeWithZone].map(&:to_s)
-
-    # same thing applies with the many types that respond to `#to_i` or `#to_f`
-    assignable_numeric_types = [Integer, Float, ActiveSupport::Duration]
-
-    # TODO: this could be a lot tidier
-    if column_type == ActiveSupport::TimeWithZone
-      "T.any(#{assignable_time_types.join(', ')})"
-    elsif column_type == "T.nilable(ActiveSupport::TimeWithZone)"
-      "T.nilable(T.any(#{assignable_time_types.join(', ')}))"
-    elsif ["T.nilable(Float)", "T.nilable(Integer)"].include?(column_type)
-      "T.nilable(T.any(#{assignable_numeric_types.join(', ')}))"
-    elsif ["Float", "Integer"].include?(column_type.to_s)
-      "T.any(#{assignable_numeric_types.join(', ')})"
-    elsif column_type == String
-      'T.any(String, Symbol)'
-    else
-      column_type.to_s
+    assignable_time_supertypes = [Date, Time, ActiveSupport::TimeWithZone].map(&:to_s)
+
+    type = column_type.base_type
+    if type.is_a?(Class)
+      if type == ActiveSupport::TimeWithZone
+        type = "T.any(#{assignable_time_supertypes.join(', ')})"
+      elsif type < Numeric || type == ActiveSupport::Duration
+        type = "T.any(Numeric, ActiveSupport::Duration)"
+      elsif type == String
+        type = "T.any(String, Symbol)"
+      end
     end
+    ColumnType.new(base_type: type, nilable: column_type.nilable, array_type: column_type.array_type).to_s
   end
 end

data/lib/sorbet-rails/model_rbi_formatter.rb

@@ -58,7 +58,7 @@ class SorbetRails::ModelRbiFormatter
 
     rbi = <<~MESSAGE
       # This is an autogenerated file for dynamic methods in #{self.model_class_name}
-      # Please rerun rake rails_rbi:models[#{self.model_class_name}] to regenerate.
+      # Please rerun bundle exec rake rails_rbi:models[#{self.model_class_name}] to regenerate.
 
     MESSAGE
 
@@ -109,6 +109,10 @@ class SorbetRails::ModelRbiFormatter
     )
     model_rbi.create_extend("T::Sig")
     model_rbi.create_extend("T::Generic")
+    model_rbi.create_type_alias(
+      self.model_relation_type_class_name,
+      type: self.model_relation_type_alias
+    )
   end
 
   sig {

data/lib/sorbet-rails/model_utils.rb

@@ -28,6 +28,22 @@ module SorbetRails::ModelUtils
     "#{model_class.name}::ActiveRecord_AssociationRelation"
   end
 
+  sig { returns(String) }
+  def model_relation_type_alias
+    types = [
+      self.model_relation_class_name,
+      self.model_assoc_proxy_class_name,
+      self.model_assoc_relation_class_name
+    ].join(', ')
+
+    "T.any(#{types})"
+  end
+
+  sig { returns(String) }
+  def model_relation_type_class_name
+    'RelationType'
+  end
+
   sig { params(module_name: String).returns(String) }
   def model_module_name(module_name)
     "#{model_class.name}::#{module_name}"
@@ -89,4 +105,4 @@ module SorbetRails::ModelUtils
       return_type: self.model_assoc_relation_class_name,
     )
   end
-end
+end

data/lib/sorbet-rails/railtie.rb

@@ -34,6 +34,16 @@ class SorbetRails::Railtie < Rails::Railtie
             child.send(:public_constant, :ActiveRecord_Relation)
             child.send(:public_constant, :ActiveRecord_AssociationRelation)
             child.send(:public_constant, :ActiveRecord_Associations_CollectionProxy)
+
+            relation_type = T.type_alias do
+              T.any(
+                child.const_get(:ActiveRecord_Relation),
+                child.const_get(:ActiveRecord_AssociationRelation),
+                child.const_get(:ActiveRecord_Associations_CollectionProxy)
+              )
+            end
+            child.const_set(:RelationType, relation_type)
+            child.send(:public_constant, :RelationType)
           end
         end
       end

data/lib/sorbet-rails/routes_rbi_formatter.rb

@@ -21,7 +21,7 @@ class SorbetRails::RoutesRbiFormatter
   def header(routes)
     @parlour.root.add_comments([
       'This is an autogenerated file for Rails routes.',
-      'Please run rake rails_rbi:routes to regenerate.'
+      'Please run bundle exec rake rails_rbi:routes to regenerate.'
     ])
 
     @parlour.root.create_class('ActionController::Base') do |klass|

data/lib/sorbet-rails/sorbet_utils.rb

@@ -2,76 +2,171 @@
 
 require('parlour')
 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|
-        p1 = p.size == 1 ? p + ['_'] : p # give param without name default name _
-        p1 + ['T.untyped'] # append untyped as type of each param
+        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)
 
-    parameters_with_type.map do |param_def|
-      param_name = param_def[1]
-      prefix =
-        case param_def[0]
+    # 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 ''
+        else nil
         end
 
-      suffix =
-        case param_def[0]
+      param_def.suffix =
+        case param_def.kind
         when :key, :keyreq; ':'
-        else ''
+        else nil
         end
+    end
 
-      param_type = param_def[2].to_s
-      if param_def[0] == :block
-        # special case `.void` in a proc
-        # see https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/types/proc.rb#L10
-        param_type = param_type.gsub('returns(<VOID>)', 'void')
-      end
+    extract_default_value_for_params!(
+      parameters_with_type,
+      method_def,
+    )
 
-      ::Parlour::RbiGenerator::Parameter.new("#{prefix}#{param_name}#{suffix}", type: 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
 
   sig {
     params(signature: T::Private::Methods::Signature).
-    returns(T::Array[[Symbol, Symbol, T::Types::Base]])
+    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 = []
+    params = T.let([], T::Array[ParsedParamDef])
     signature.arg_types.each do |arg_type|
       # could be :opt, but doesn't matter
-      params << [:req, arg_type[0], arg_type[1]]
+      params << ParsedParamDef.new(
+        name: arg_type[0],
+        kind: :req,
+        type_str: arg_type[1].to_s,
+      )
     end
-    signature.req_kwarg_names.each do |kwarg_name|
+    signature.kwarg_types.each do |kwarg_name, kwarg_type|
       # could be :key, but doesn't matter
-      params << [:keyreq, kwarg_name, signature.kwarg_types[kwarg_name]]
+      params << ParsedParamDef.new(
+        name: kwarg_name,
+        kind: :keyreq,
+        type_str: kwarg_type.to_s,
+      )
     end
     if signature.has_rest
-      params << [:rest, signature.rest_name, signature.rest_type]
+      params << ParsedParamDef.new(
+        name: signature.rest_name,
+        kind: :rest,
+        type_str: signature.rest_type.to_s,
+      )
     end
     if signature.has_keyrest
-      params << [:keyrest, signature.keyrest_name, signature.keyrest_type]
+      params << ParsedParamDef.new(
+        name: signature.keyrest_name,
+        kind: :keyrest,
+        type_str: signature.keyrest_type.to_s,
+      )
     end
     if !signature.block_name.nil?
-      params << [:block, signature.block_name, signature.block_type]
+      # 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
+
+  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
+
+  # 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]
+  end
+
+  class UnexpectedParam < StandardError; end
 end