perf: optimize schema and serde hot paths

gems/smithy-cbor/lib/smithy-cbor/builder.rb

@@ -17,12 +17,13 @@ def build(shape, data)
       private
 
       def build_shape(shape, value)
-        case Schema::Extension.target_shape(shape)
-        when Schema::Extension::SHAPE_BLOB then blob(value)
-        when Schema::Extension::SHAPE_LIST then list(shape, value)
-        when Schema::Extension::SHAPE_MAP then map(shape, value)
-        when Schema::Extension::SHAPE_STRUCTURE then structure(shape, value)
-        when Schema::Extension::SHAPE_UNION then union(shape, value)
+        target = shape.target
+        case target
+        when Schema::Shapes::BlobShape then blob(value)
+        when Schema::Shapes::ListShape then list(shape, value)
+        when Schema::Shapes::MapShape then map(shape, value)
+        when Schema::Shapes::StructureShape then structure(shape, value)
+        when Schema::Shapes::UnionShape then union(shape, value)
         else value
         end
       end
@@ -34,7 +35,7 @@ def blob(value)
       def list(shape, values)
         return if values.nil?
 
-        member, _target_shape, _sparse = Schema::Extension.list_member(shape.target)
+        member = shape.target.member
         values.collect do |value|
           build_shape(member, value)
         end
@@ -43,40 +44,41 @@ def list(shape, values)
       def map(shape, values)
         return if values.nil?
 
-        value_member, _target_shape, _sparse = Schema::Extension.map_value_member(shape.target)
-        values.each.with_object({}) do |(key, value), data|
+        value_member = shape.target.value
+        data = {}
+        values.each do |key, value|
           data[key] = build_shape(value_member, value)
         end
+        data
       end
 
       def structure(shape, values)
         return if values.nil?
 
-        index = Schema::Extension.member_index(shape.target)
-        values.each_pair.with_object({}) do |(member_name, value), data|
+        target = shape.target
+        data = {}
+        values.each_pair do |member_name, value|
           next if value.nil?
-          next unless (entry = index[member_name])
+          next unless (member_shape = target.member(member_name))
 
-          wire_name, member_shape, _target_shape = entry
-          data[wire_name] = build_shape(member_shape, value)
+          data[member_shape.name] = build_shape(member_shape, value)
         end
+        data
       end
 
       def union(shape, values)
         return if values.nil?
 
         key, value =
           if values.is_a?(Schema::Union)
-            member_name, _member_shape = shape.target.member_by_type(values.class)
-            [member_name, values.value]
+            [values.member, values.value]
           else
             values.first
           end
-        entry = Schema::Extension.member_index(shape.target)[key]
-        return {} unless entry
+        member_shape = shape.target.member(key)
+        return {} unless member_shape
 
-        wire_name, member_shape, _target_shape = entry
-        { wire_name => build_shape(member_shape, value) }
+        { member_shape.name => build_shape(member_shape, value) }
       end
     end
   end

gems/smithy-cbor/lib/smithy-cbor/codec.rb

@@ -6,22 +6,23 @@ module Cbor
     class Codec
       # @param [Hash] options
       def initialize(options = {})
-        @options = options
+        @builder = Builder.new(options).freeze
+        @parser = Parser.new(options).freeze
       end
 
       # @param [Shape] shape
       # @param [Object] data
       # @return [String, nil]
       def build(shape, data)
-        Builder.new(@options).build(shape, data)
+        @builder.build(shape, data)
       end
 
       # @param [Shape] shape
       # @param [String] bytes
       # @param [Object, nil] result (nil)
       # @return [Object, nil]
       def parse(shape, bytes, result = nil)
-        Parser.new(@options).parse(shape, bytes, result)
+        @parser.parse(shape, bytes, result)
       end
     end
   end