ForbidTStruct handles nilable properties

lib/rubocop/cop/sorbet/forbid_t_struct.rb

@@ -131,8 +131,13 @@ def initialize_sig_param
           def initialize_param
             rb = String.new
             rb << "#{name}:"
-            rb << " #{default}" if default
-            rb << " #{factory}" if factory
+            if default
+              rb << " #{default}"
+            elsif factory
+              rb << " #{factory}"
+            elsif nilable?
+              rb << " nil"
+            end
             rb
           end
 
@@ -142,6 +147,10 @@ def initialize_assign
             rb << ".call" if factory
             rb
           end
+
+          def nilable?
+            type.start_with?("T.nilable(")
+          end
         end
 
         # @!method t_struct?(node)
@@ -203,11 +212,11 @@ def on_send(node)
 
         def initialize_method(indent, props)
           # We sort optional keyword arguments after required ones
-          props = props.sort_by { |prop| prop.default || prop.factory ? 1 : 0 }
+          sorted_props = props.sort_by { |prop| prop.default || prop.factory || prop.nilable? ? 1 : 0 }
 
           string = +"\n"
-          string << "#{indent}sig { params(#{props.map(&:initialize_sig_param).join(", ")}).void }\n"
-          string << "#{indent}def initialize(#{props.map(&:initialize_param).join(", ")})\n"
+          string << "#{indent}sig { params(#{sorted_props.map(&:initialize_sig_param).join(", ")}).void }\n"
+          string << "#{indent}def initialize(#{sorted_props.map(&:initialize_param).join(", ")})\n"
           props.each do |prop|
             string << "#{indent}  #{prop.initialize_assign}\n"
           end

spec/rubocop/cop/sorbet/forbid_t_struct_spec.rb

@@ -162,8 +162,8 @@ class Foo
           sig { params(foo: Integer, baz: Symbol, bar: String).void }
           def initialize(foo:, baz:, bar: "foo")
             @foo = foo
-            @baz = baz
             @bar = bar
+            @baz = baz
           end
         end
       RUBY
@@ -374,5 +374,39 @@ def initialize(foo:, bar:)
 
       expect(autocorrect_source(source)).to(eq(corrected))
     end
+
+    it "handles optional nilable properties" do
+      source = <<~RUBY
+        class Foo < T::Struct
+          const :foo, T.nilable(Integer)
+          prop :bar, T.nilable(String)
+          prop :baz, Integer
+        end
+      RUBY
+
+      corrected = <<~RUBY
+        class Foo
+          extend T::Sig
+
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :foo
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :bar
+
+          sig { returns(Integer) }
+          attr_accessor :baz
+
+          sig { params(baz: Integer, foo: T.nilable(Integer), bar: T.nilable(String)).void }
+          def initialize(baz:, foo: nil, bar: nil)
+            @foo = foo
+            @bar = bar
+            @baz = baz
+          end
+        end
+      RUBY
+
+      expect(autocorrect_source(source)).to(eq(corrected))
+    end
   end
 end