Label T::Struct props with immutable: true as readonly

Author: dduugg

CHANGELOG.md

@@ -2,9 +2,10 @@
 
 ## main
 
-###
+### Bug Fixes
 
 * Handle multiple invocations of `mixes_in_class_methods` within a class
+* Label `T::Struct` `prop`s with `immutable: true` as `readonly`
 
 ## 0.7.0 (2022-08-24)
 

lib/yard-sorbet/handlers/enums_handler.rb

@@ -27,7 +27,7 @@ def process
 
       sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
       def const_assign_node?(node)
-        node.type == :assign && node[0][0].type == :const
+        node.type == :assign && node.dig(0, 0).type == :const
       end
     end
   end

lib/yard-sorbet/handlers/sig_handler.rb

@@ -48,8 +48,8 @@ def parse_params(method_node, node, docstring)
         return if ATTR_NODE_TYPES.include?(method_node.type)
 
         sibling = NodeUtils.sibling_node(node)
-        sibling[0][0].each do |param|
-          param_name = param[0][0]
+        sibling.dig(0, 0).each do |param|
+          param_name = param.dig(0, 0)
           types = SigToYARD.convert(param.last)
           TagUtils.upsert_tag(docstring, 'param', types, param_name)
         end

lib/yard-sorbet/handlers/struct_prop_handler.rb

@@ -13,7 +13,7 @@ class StructPropHandler < YARD::Handlers::Ruby::Base
 
       sig { void }
       def process
-        name = statement.parameters.first.last.last.source
+        name = params.dig(0, -1, -1).source
         prop = make_prop(name)
         update_state(prop)
         object = YARD::CodeObjects::MethodObject.new(namespace, name, scope)
@@ -27,36 +27,45 @@ def process
       sig { params(object: YARD::CodeObjects::MethodObject, prop: TStructProp).void }
       def decorate_object(object, prop)
         object.source = prop.source
-        # TODO: this should use `+` to delimit the attribute name when markdown is disabled
-        reader_docstring = prop.doc.empty? ? "Returns the value of attribute `#{prop.prop_name}`." : prop.doc
+        # TODO: this should use `+` to delimit the prop name when markdown is disabled
+        reader_docstring = prop.doc.empty? ? "Returns the value of prop `#{prop.prop_name}`." : prop.doc
         docstring = YARD::DocstringParser.new.parse(reader_docstring).to_docstring
         docstring.add_tag(YARD::Tags::Tag.new(:return, '', prop.types))
         object.docstring = docstring.to_raw
       end
 
-      # Get the default prop value
-      sig { returns(T.nilable(String)) }
-      def default_value
-        statement.traverse { break _1 if _1.type == :label && _1.source == 'default:' }&.parent&.[](1)&.source
+      sig { returns(T::Boolean) }
+      def immutable?
+        statement.method_name(true) == :const || kw_arg('immutable:') == 'true'
+      end
+
+      # @return the value passed to the keyword argument, or nil
+      sig { params(kwd: String).returns(T.nilable(String)) }
+      def kw_arg(kwd)
+        params[2]&.find { _1.jump(:label).source == kwd }&.[](1)&.source
       end
 
       sig { params(name: String).returns(TStructProp) }
       def make_prop(name)
         TStructProp.new(
-          default: default_value,
+          default: kw_arg('default:'),
           doc: statement.docstring.to_s,
           prop_name: name,
           source: statement.source,
-          types: SigToYARD.convert(statement.parameters[1])
+          types: SigToYARD.convert(params[1])
         )
       end
 
+      sig { returns(T::Array[T.untyped]) }
+      def params
+        @params ||= T.let(statement.parameters(false), T.nilable(T::Array[T.untyped]))
+      end
+
       # Register the field explicitly as an attribute.
-      # While `const` attributes are immutable, `prop` attributes may be reassigned.
       sig { params(object: YARD::CodeObjects::MethodObject, name: String).void }
       def register_attrs(object, name)
-        # Create the virtual method in our current scope
-        write = statement.method_name(true) == :prop ? object : nil
+        write = immutable? ? nil : object
+        # Create the virtual attribute in our current scope
         namespace.attributes[scope][name] ||= SymbolHash[read: object, write: write]
       end
 

lib/yard-sorbet/sig_to_yard.rb

@@ -88,7 +88,7 @@ def self.convert(node)
     sig { params(node: YARD::Parser::Ruby::AstNode).returns([String]) }
     private_class_method def self.convert_collection(node)
       collection_type = node.first.source.split('::').last
-      member_type = convert_node(node.last.first).join(', ')
+      member_type = convert_node(node.dig(-1, 0)).join(', ')
       ["#{collection_type}<#{member_type}>"]
     end
 
@@ -116,7 +116,7 @@ def self.convert(node)
       # Order matters here, putting `nil` last results in a more concise return syntax in the UI (superscripted `?`):
       # https://github.com/lsegal/yard/blob/cfa62ae/lib/yard/templates/helpers/html_helper.rb#L499-L500
       when :nilable then convert_node(node.last).push('nil')
-      when :any then node.last.first.children.flat_map { convert_node(_1) }
+      when :any then node.dig(-1, 0).children.flat_map { convert_node(_1) }
       else [node.source]
       end
     end

spec/data/struct_handler.txt

@@ -12,6 +12,7 @@ class PersonStruct < T::Struct
   # A writable
   prop :writable, String
   const :mystery, T.untyped
+  prop :not_mutable, Integer, default: 0, immutable: true
 end
 
 class SpecializedPersonStruct < T::Struct

spec/yard_sorbet/handlers/struct_prop_handler_spec.rb

@@ -22,7 +22,7 @@
 
     it 'creates a docstring if it does not exist' do
       node = YARD::Registry.at('PersonStruct#mystery')
-      expect(node.docstring).to eq('Returns the value of attribute `mystery`.')
+      expect(node.docstring).to eq('Returns the value of prop `mystery`.')
     end
 
     it 'handles default values appropriately' do
@@ -35,6 +35,11 @@
       expect(node.writer?).to be(false)
     end
 
+    it 'marks `immutable: true` attributes read-only' do
+      node = YARD::Registry.at('PersonStruct#not_mutable')
+      expect(node.writer?).to be(false)
+    end
+
     it 'does not mark `prop` attributes read-only' do
       node = YARD::Registry.at('PersonStruct#writable')
       expect(node.writer?).to be(true)