feat: RBS size reduction

build_tools/aws-sdk-code-generator/lib/aws-sdk-code-generator.rb

@@ -83,13 +83,15 @@
 require_relative 'aws-sdk-code-generator/rbs/error_list'
 require_relative 'aws-sdk-code-generator/rbs/method_signature'
 require_relative 'aws-sdk-code-generator/rbs/keyword_argument_builder'
+require_relative 'aws-sdk-code-generator/rbs/input_type_alias_collector'
 require_relative 'aws-sdk-code-generator/rbs/resource_action'
 require_relative 'aws-sdk-code-generator/rbs/resource_association'
 require_relative 'aws-sdk-code-generator/rbs/resource_batch_action'
 require_relative 'aws-sdk-code-generator/rbs/resource_client_request'
 require_relative 'aws-sdk-code-generator/rbs/waiter'
 require_relative 'aws-sdk-code-generator/views/rbs/async_client_class'
 require_relative 'aws-sdk-code-generator/views/rbs/client_class'
+require_relative 'aws-sdk-code-generator/views/rbs/params'
 require_relative 'aws-sdk-code-generator/views/rbs/errors_module'
 require_relative 'aws-sdk-code-generator/views/rbs/resource_class'
 require_relative 'aws-sdk-code-generator/views/rbs/root_resource_class'

build_tools/aws-sdk-code-generator/lib/aws-sdk-code-generator/code_builder.rb

@@ -114,8 +114,17 @@ def rbs_files(options = {})
         prefix = options.fetch(:prefix, '')
         codegenerated_plugins = codegen_plugins(prefix)
         unless @service.h2_required_setting?
-          client_class = client_class_rbs(codegenerated_plugins)
+          collector = RBS::InputTypeAliasCollector.new(api: @service.api)
+          aliased_shapes = collector.shapes_to_alias
+          client_class = client_class_rbs(codegenerated_plugins, aliased_shapes)
           y.yield("#{prefix}/client.rbs", client_class.render)
+          if aliased_shapes.any?
+            y.yield("#{prefix}/params.rbs", Views::RBS::Params.new(
+              service_name: @service.name,
+              api: @service.api,
+              aliased_shapes: aliased_shapes
+            ).render)
+          end
           y.yield("#{prefix}/resource.rbs", Views::RBS::RootResourceClass.new(
             service_name: @service.name,
             client_class: client_class,
@@ -197,7 +206,7 @@ def client_class(codegenerated_plugins)
       ).render
     end
 
-    def client_class_rbs(codegenerated_plugins)
+    def client_class_rbs(codegenerated_plugins, aliased_shapes)
       Views::RBS::ClientClass.new(
         service_name: @service.name,
         codegenerated_plugins: codegenerated_plugins,
@@ -209,7 +218,8 @@ def client_class_rbs(codegenerated_plugins)
         protocol: @service.protocol,
         add_plugins: @service.add_plugins,
         remove_plugins: @service.remove_plugins,
-        protocol_settings: @service.protocol_settings
+        protocol_settings: @service.protocol_settings,
+        aliased_shapes: aliased_shapes
       )
     end
 

build_tools/aws-sdk-code-generator/lib/aws-sdk-code-generator/rbs/input_type_alias_collector.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module RBS
+    # Collects structure shapes referenced more than once in input shape.
+    class InputTypeAliasCollector
+      def initialize(api:)
+        @api = api
+        @shape_usage_count = Hash.new(0)
+        @size_cache = {}
+      end
+      # Returns a topologically sorted array of shape names to render as type aliases.
+      # Leaf dependencies come first so aliases can reference each other.
+      # params.rbs uses aliases in this list to define RBS type aliases.
+      # client_class.rbs uses aliases in this list to deduplicate content.
+      def shapes_to_alias
+        count_shape_usage
+        aliased = @shape_usage_count.select do |shape_name, count|
+          shape = @api['shapes'][shape_name]
+          shape['type'] == 'structure' &&
+            count > 1 &&
+            rendered_rbs_line_count_heuristic(shape_name) > 5
+        end.keys.to_set
+        topological_sort(aliased)
+      end
+
+      private
+
+      def topological_sort(shape_names)
+        sorted = []
+        visited = Set.new
+        shape_names.each { |name| topo_visit(name, shape_names, visited, sorted) }
+        sorted
+      end
+
+      def topo_visit(name, shape_names, visited, sorted)
+        return if visited.include?(name)
+
+        visited << name
+        shape = @api['shapes'][name]
+        shape['members']&.each_value do |ref|
+          dep = ref['shape']
+          topo_visit(dep, shape_names, visited, sorted) if shape_names.include?(dep)
+        end
+        sorted << name
+      end
+
+      def count_shape_usage
+        @api['operations'].each_value do |op|
+          input_shape_name = op.dig('input', 'shape')
+          next unless input_shape_name
+
+          walk_shape(input_shape_name, Set.new)
+        end
+      end
+
+      def walk_shape(shape_name, ancestors)
+        return if ancestors.include?(shape_name)
+
+        ancestors += [shape_name]
+
+        shape = @api['shapes'][shape_name]
+        return unless shape && shape['type'] == 'structure'
+
+        shape['members']&.each_value do |member_ref|
+          member_shape_name = member_ref['shape']
+          member_shape = @api['shapes'][member_shape_name]
+          next unless member_shape
+
+          case member_shape['type']
+          when 'structure'
+            @shape_usage_count[member_shape_name] += 1
+            walk_shape(member_shape_name, ancestors)
+          when 'list'
+            walk_list(member_shape, ancestors)
+          when 'map'
+            walk_map(member_shape, ancestors)
+          end
+        end
+      end
+
+      def walk_list(list_shape, ancestors)
+        member_ref = list_shape['member']
+        member_shape = @api['shapes'][member_ref['shape']]
+        return unless member_shape
+
+        case member_shape['type']
+        when 'structure'
+          @shape_usage_count[member_ref['shape']] += 1
+          walk_shape(member_ref['shape'], ancestors)
+        when 'list'
+          walk_list(member_shape, ancestors)
+        when 'map'
+          walk_map(member_shape, ancestors)
+        end
+      end
+
+      def walk_map(map_shape, ancestors)
+        value_ref = map_shape['value']
+        value_shape = @api['shapes'][value_ref['shape']]
+        return unless value_shape
+
+        case value_shape['type']
+        when 'structure'
+          @shape_usage_count[value_ref['shape']] += 1
+          walk_shape(value_ref['shape'], ancestors)
+        when 'list'
+          walk_list(value_shape, ancestors)
+        when 'map'
+          walk_map(value_shape, ancestors)
+        end
+      end
+
+      def rendered_rbs_line_count_heuristic(shape_name, visited = Set.new)
+        return 0 if visited.include?(shape_name)
+
+        # Cache results to deduplicate calculation for nested structure types that get used multiple times in the model.
+        @size_cache ||= {}
+        return @size_cache[shape_name] if @size_cache.key?(shape_name)
+
+        visited += [shape_name]
+        shape = @api['shapes'][shape_name]
+        return @size_cache[shape_name] = 1 unless shape['members']
+
+        @size_cache[shape_name] = shape['members'].sum do |_, ref|
+          member_line_count(ref, visited)
+        end
+      end
+
+      def member_line_count(ref, visited)
+        child = @api['shapes'][ref['shape']]
+        case child['type']
+          # If it's a structure, add 2 lines then recurse (one line each for '{' and '}' in rendered RBS)
+        when 'structure' then 2 + rendered_rbs_line_count_heuristic(ref['shape'], visited)
+        when 'list'
+          member_shape = @api['shapes'][child['member']['shape']]
+          # If it's a list with structure member, add 2 lines & recurse.
+          #   (one line each for 'Hash[::String, {' and '}]' in rendered RBS)
+          # If it's a list with primitive member, add 1 and return
+          #   (e.g., renders as 1-liner, like 'list: Array[::String]')
+          member_shape['type'] == 'structure' ? 2 +
+            rendered_rbs_line_count_heuristic(child['member']['shape'], visited) : 1
+        when 'map'
+          value_shape = @api['shapes'][child['value']['shape']]
+          # If it's a map with structure member, add 2 lines & recurse.
+          #   (one line each for 'Hash[::String, {' and '}]' in rendered RBS)
+          # If it's a map with primitive member, add 1 and return
+          #   (e.g., renders as 1-liner, like 'map: Hash[::String, ::String]')
+          value_shape['type'] == 'structure' ? 2 +
+            rendered_rbs_line_count_heuristic(child['value']['shape'], visited) : 1
+        else 1
+        end
+      end
+    end
+  end
+end

build_tools/aws-sdk-code-generator/lib/aws-sdk-code-generator/rbs/keyword_argument_builder.rb

@@ -8,11 +8,13 @@ class KeywordArgumentBuilder
 
       attr_reader :newline
 
-      def initialize(api:, shape:, newline:, options: {})
+      def initialize(api:, shape:, newline:, options: {}, aliased_shapes: Set.new, alias_namespace: nil)
         @api = api
         @shape = shape
         @newline = newline
         @options = options
+        @aliased_shapes = aliased_shapes
+        @alias_namespace = alias_namespace
       end
 
       def format(indent: '')
@@ -69,10 +71,16 @@ def struct_member(struct, member_name, member_ref, i, visited, keyword:)
       def ref_value(ref, i, visited)
         if visited.include?(ref['shape'])
           return "untyped"
-        else
-          visited  = visited + [ref['shape']]
         end
 
+        # If this shape should be aliased, emit the alias reference
+        if @aliased_shapes.include?(ref['shape'])
+          alias_name = Underscore.underscore(ref['shape'])
+          return @alias_namespace ? "#{@alias_namespace}::#{alias_name}" : alias_name
+        end
+
+        visited  = visited + [ref['shape']]
+
         s = shape(ref)
         case s['type']
         when 'structure'
@@ -115,7 +123,7 @@ def scalar_list(member_ref, i, visited)
 
       def complex_list(member_ref, i, visited)
         newline_indent = newline ? "\n#{i}" : ""
-        "Array[#{newline_indent}#{more_indent}#{ref_value(member_ref, i + more_indent, visited)},#{newline_indent}]"
+        "Array[#{newline_indent}#{more_indent}#{ref_value(member_ref, i + more_indent, visited)}#{newline_indent}]"
       end
 
       def complex?(ref)

build_tools/aws-sdk-code-generator/lib/aws-sdk-code-generator/views/rbs/client_class.rb

@@ -24,6 +24,7 @@ def initialize(options)
           @codegenerated_plugins = options.fetch(:codegenerated_plugins)
           @waiters = AwsSdkCodeGenerator::RBS::Waiter.build_list(api: @api, waiters:options.fetch(:waiters))
           @protocol_settings = options.fetch(:protocol_settings, {})
+          @aliased_shapes = options.fetch(:aliased_shapes, Set.new).to_set
         end
 
         # @return [String|nil]
@@ -60,6 +61,8 @@ def operations
                 api: @api,
                 shape: input_shape,
                 newline: true,
+                aliased_shapes: @aliased_shapes,
+                alias_namespace: 'Params',
               )
               arguments = builder.format(indent: indent)
               include_required = input_shape["required"]&.empty?&.!

build_tools/aws-sdk-code-generator/lib/aws-sdk-code-generator/views/rbs/params.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AwsSdkCodeGenerator
+  module Views
+    module RBS
+      class Params < View
+        include Helper
+
+        def initialize(options)
+          @service_name = options.fetch(:service_name)
+          @api = options.fetch(:api)
+          @aliased_shapes = options.fetch(:aliased_shapes)
+        end
+
+        def generated_src_warning
+          GENERATED_SRC_WARNING
+        end
+
+        def service_name
+          @service_name
+        end
+
+        def type_aliases
+          aliased_set = @aliased_shapes.to_set
+          @aliased_shapes.map do |shape_name|
+            shape = @api['shapes'][shape_name]
+            builder = AwsSdkCodeGenerator::RBS::KeywordArgumentBuilder.new(
+              api: @api,
+              shape: shape,
+              newline: true,
+              aliased_shapes: aliased_set - [shape_name],
+              alias_namespace: 'Params',
+            )
+            {
+              'name' => Underscore.underscore(shape_name),
+              'definition' => builder.struct(shape, '      ', []),
+            }
+          end
+        end
+      end
+    end
+  end
+end