herb 0.11.1 → 0.11.2

data/vendor/prism/templates/lib/prism/serialize.rb.erb

@@ -1,16 +1,19 @@
+#--
+# rbs_inline: enabled
+
 require "stringio"
 require_relative "polyfill/unpack1"
 
 module Prism
   # A module responsible for deserializing parse results.
-  module Serialize
+  module Serialize # :nodoc:
     # The major version of prism that we are expecting to find in the serialized
     # strings.
-    MAJOR_VERSION = 1
+    MAJOR_VERSION = 2
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 9
+    MINOR_VERSION = 1
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.
@@ -20,34 +23,40 @@ module Prism
     #
     # The formatting of the source of this method is purposeful to illustrate
     # the structure of the serialized data.
+    #
+    #: (String input, String serialized, bool freeze) -> ParseResult
     def self.load_parse(input, serialized, freeze)
       input = input.dup
-      source = Source.for(input)
+      source = Source.for(input, 1, [])
       loader = Loader.new(source, serialized)
 
                        loader.load_header
       encoding =       loader.load_encoding
       start_line =     loader.load_varsint
+      checksum =       loader.load_uint64
       offsets =        loader.load_line_offsets(freeze)
 
       source.replace_start_line(start_line)
+      source.replace_checksum(checksum)
       source.replace_offsets(offsets)
 
-      comments =       loader.load_comments(freeze)
+                       loader.load_comments(source.comments, freeze)
+                       loader.load_comment_attachments(source, freeze)
       magic_comments = loader.load_magic_comments(freeze)
       data_loc =       loader.load_optional_location_object(freeze)
       errors =         loader.load_errors(encoding, freeze)
       warnings =       loader.load_warnings(encoding, freeze)
+      continuable =    loader.load_bool
       cpool_base =     loader.load_uint32
       cpool_size =     loader.load_varuint
 
-      constant_pool = ConstantPool.new(input, serialized, cpool_base, cpool_size)
+      constant_pool = ConstantPool.new(serialized, cpool_base, cpool_size)
 
-      node =           loader.load_node(constant_pool, encoding, freeze)
+      node =           loader.load_nodes(constant_pool, encoding, freeze, cpool_base) #: ProgramNode
                        loader.load_constant_pool(constant_pool)
       raise unless     loader.eof?
 
-      result = ParseResult.new(node, comments, magic_comments, data_loc, errors, warnings, source)
+      result = ParseResult.new(node, magic_comments, data_loc, errors, warnings, continuable, source)
       result.freeze if freeze
 
       input.force_encoding(encoding)
@@ -73,26 +82,32 @@ module Prism
     #
     # The formatting of the source of this method is purposeful to illustrate
     # the structure of the serialized data.
+    #
+    #: (String input, String serialized, bool freeze) -> LexResult
     def self.load_lex(input, serialized, freeze)
-      source = Source.for(input)
+      source = Source.for(input, 1, [])
       loader = Loader.new(source, serialized)
 
       tokens =         loader.load_tokens
       encoding =       loader.load_encoding
       start_line =     loader.load_varsint
+      checksum =       loader.load_uint64
       offsets =        loader.load_line_offsets(freeze)
 
       source.replace_start_line(start_line)
+      source.replace_checksum(checksum)
       source.replace_offsets(offsets)
 
-      comments =       loader.load_comments(freeze)
+                       loader.load_comments(source.comments, freeze)
+                       loader.load_comment_attachments(source, freeze)
       magic_comments = loader.load_magic_comments(freeze)
       data_loc =       loader.load_optional_location_object(freeze)
       errors =         loader.load_errors(encoding, freeze)
       warnings =       loader.load_warnings(encoding, freeze)
+      continuable =    loader.load_bool
       raise unless     loader.eof?
 
-      result = LexResult.new(tokens, comments, magic_comments, data_loc, errors, warnings, source)
+      result = LexResult.new(tokens, magic_comments, data_loc, errors, warnings, continuable, source)
 
       tokens.each do |token|
         token[0].value.force_encoding(encoding)
@@ -117,18 +132,24 @@ module Prism
     #
     # The formatting of the source of this method is purposeful to illustrate
     # the structure of the serialized data.
+    #
+    #: (String input, String serialized, bool freeze) -> Array[Comment]
     def self.load_parse_comments(input, serialized, freeze)
-      source = Source.for(input)
+      source = Source.for(input, 1, [])
       loader = Loader.new(source, serialized)
 
-                   loader.load_header
-                   loader.load_encoding
-      start_line = loader.load_varsint
+                    loader.load_header
+                    loader.load_encoding
+      start_line =  loader.load_varsint
+      checksum =    loader.load_uint64
+      offsets =     loader.load_line_offsets(freeze)
 
       source.replace_start_line(start_line)
+      source.replace_checksum(checksum)
+      source.replace_offsets(offsets)
 
-      result =     loader.load_comments(freeze)
-      raise unless loader.eof?
+      result =      loader.load_comments(source.comments, freeze)
+      raise unless  loader.eof?
 
       source.deep_freeze if freeze
       result
@@ -139,35 +160,41 @@ module Prism
     #
     # The formatting of the source of this method is purposeful to illustrate
     # the structure of the serialized data.
+    #
+    #: (String input, String serialized, bool freeze) -> ParseLexResult
     def self.load_parse_lex(input, serialized, freeze)
-      source = Source.for(input)
+      source = Source.for(input, 1, [])
       loader = Loader.new(source, serialized)
 
       tokens =         loader.load_tokens
                        loader.load_header
       encoding =       loader.load_encoding
       start_line =     loader.load_varsint
+      checksum =       loader.load_uint64
       offsets =        loader.load_line_offsets(freeze)
 
       source.replace_start_line(start_line)
+      source.replace_checksum(checksum)
       source.replace_offsets(offsets)
 
-      comments =       loader.load_comments(freeze)
+                       loader.load_comments(source.comments, freeze)
+                       loader.load_comment_attachments(source, freeze)
       magic_comments = loader.load_magic_comments(freeze)
       data_loc =       loader.load_optional_location_object(freeze)
       errors =         loader.load_errors(encoding, freeze)
       warnings =       loader.load_warnings(encoding, freeze)
+      continuable =    loader.load_bool
       cpool_base =     loader.load_uint32
       cpool_size =     loader.load_varuint
 
-      constant_pool = ConstantPool.new(input, serialized, cpool_base, cpool_size)
+      constant_pool = ConstantPool.new(serialized, cpool_base, cpool_size)
 
-      node =           loader.load_node(constant_pool, encoding, freeze)
+      node =           loader.load_nodes(constant_pool, encoding, freeze, cpool_base) #: ProgramNode
                        loader.load_constant_pool(constant_pool)
       raise unless     loader.eof?
 
-      value = [node, tokens]
-      result = ParseLexResult.new(value, comments, magic_comments, data_loc, errors, warnings, source)
+      value = [node, tokens] #: [ProgramNode, Array[Token]]
+      result = ParseLexResult.new(value, magic_comments, data_loc, errors, warnings, continuable, source)
 
       tokens.each do |token|
         token[0].value.force_encoding(encoding)
@@ -189,34 +216,36 @@ module Prism
     end
 
     class ConstantPool # :nodoc:
-      attr_reader :size
+      attr_reader :size #: Integer
+
+      # @rbs @serialized: String
+      # @rbs @base: Integer
+      # @rbs @pool: Array[Symbol?]
 
-      def initialize(input, serialized, base, size)
-        @input = input
+      #: (String serialized, Integer base, Integer size) -> void
+      def initialize(serialized, base, size)
         @serialized = serialized
         @base = base
         @size = size
         @pool = Array.new(size, nil)
       end
 
+      #: (Integer index, Encoding encoding) -> Symbol
       def get(index, encoding)
         @pool[index] ||=
           begin
             offset = @base + index * 8
-            start = @serialized.unpack1("L", offset: offset)
-            length = @serialized.unpack1("L", offset: offset + 4)
+            start = @serialized.unpack1("L", offset: offset) #: Integer
+            length = @serialized.unpack1("L", offset: offset + 4) #: Integer
 
-            if start.nobits?(1 << 31)
-              @input.byteslice(start, length).force_encoding(encoding).to_sym
-            else
-              @serialized.byteslice(start & ((1 << 31) - 1), length).force_encoding(encoding).to_sym
-            end
+            (@serialized.byteslice(start, length) or raise).force_encoding(encoding).to_sym
           end
       end
     end
 
     if RUBY_ENGINE == "truffleruby"
       # StringIO is synchronized and that adds a high overhead on TruffleRuby.
+      # @rbs skip
       class FastStringIO # :nodoc:
         attr_accessor :pos
 
@@ -246,8 +275,11 @@ module Prism
     end
 
     class Loader # :nodoc:
-      attr_reader :input, :io, :source
+      attr_reader :input #: String
+      attr_reader :io #: StringIO
+      attr_reader :source #: Source
 
+      #: (Source source, String serialized) -> void
       def initialize(source, serialized)
         @input = source.source.dup
         raise unless serialized.encoding == Encoding::BINARY
@@ -256,57 +288,91 @@ module Prism
         define_load_node_lambdas if RUBY_ENGINE != "ruby"
       end
 
+      #: () -> bool
       def eof?
         io.getbyte
         io.eof?
       end
 
+      #: (ConstantPool constant_pool) -> void
       def load_constant_pool(constant_pool)
         trailer = 0
 
         constant_pool.size.times do |index|
-          start, length = io.read(8).unpack("L2")
-          trailer += length if start.anybits?(1 << 31)
+          length = (io.read(8) or raise).unpack1("L", offset: 4) #: Integer
+          trailer += length
         end
 
         io.read(trailer)
       end
 
+      #: () -> void
       def load_header
         raise "Invalid serialization" if io.read(5) != "PRISM"
-        raise "Invalid serialization" if io.read(3).unpack("C3") != [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION]
+        raise "Invalid serialization" if (io.read(3) or raise).unpack("C3") != [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION]
         raise "Invalid serialization (location fields must be included but are not)" if io.getbyte != 0
       end
 
+      #: () -> Encoding
       def load_encoding
-        encoding = Encoding.find(io.read(load_varuint))
+        encoding = Encoding.find((io.read(load_varuint) or raise)) or raise
         @input = input.force_encoding(encoding).freeze
         encoding
       end
 
+      #: (bool freeze) -> Array[Integer]
       def load_line_offsets(freeze)
         offsets = Array.new(load_varuint) { load_varuint }
         offsets.freeze if freeze
         offsets
       end
 
-      def load_comments(freeze)
-        comments =
-          Array.new(load_varuint) do
-            comment =
-              case load_varuint
-              when 0 then InlineComment.new(load_location_object(freeze))
-              when 1 then EmbDocComment.new(load_location_object(freeze))
-              end
-
-            comment.freeze if freeze
-            comment
-          end
+      # Load the comments attached to each node into the comment attachments and
+      # comment ranges of the given source. For each node that owns comments, the
+      # index at which its comments begin is stored at its node id and the index
+      # at which they end at the following node id.
+      #
+      #: (Source source, bool freeze) -> void
+      def load_comment_attachments(source, freeze)
+        comments = source.comments
+        attachments = source.comment_attachments
+        ranges = source.comment_ranges
+
+        load_varuint.times do
+          node_id = load_varuint
+          ranges[node_id] = attachments.length
+          load_varuint.times { attachments << comments[load_varuint] }
+          ranges[node_id + 1] = attachments.length
+        end
+
+        if freeze
+          attachments.freeze
+          ranges.freeze
+        end
+      end
+
+      # Load the comments into the given list, which belongs to the source that
+      # the comments refer to.
+      #
+      #: (Array[Comment] comments, bool freeze) -> Array[Comment]
+      def load_comments(comments, freeze)
+        load_varuint.times do
+          comment =
+            case load_varuint
+            when 0 then InlineComment.new(load_location_object(freeze))
+            when 1 then EmbDocComment.new(load_location_object(freeze))
+            else raise
+            end
+
+          comment.freeze if freeze
+          comments << comment
+        end
 
         comments.freeze if freeze
         comments
       end
 
+      #: (bool freeze) -> Array[MagicComment]
       def load_magic_comments(freeze)
         magic_comments =
           Array.new(load_varuint) do
@@ -331,10 +397,11 @@ module Prism
         <%- warnings.each do |warning| -%>
         <%= warning.name.downcase.to_sym.inspect %>,
         <%- end -%>
-      ].freeze
+      ].freeze #: Array[Symbol]
 
       private_constant :DIAGNOSTIC_TYPES
 
+      #: () -> Symbol
       def load_error_level
         level = io.getbyte
 
@@ -350,13 +417,14 @@ module Prism
         end
       end
 
+      #: (Encoding encoding, bool freeze) -> Array[ParseError]
       def load_errors(encoding, freeze)
         errors =
           Array.new(load_varuint) do
             error =
               ParseError.new(
                 DIAGNOSTIC_TYPES.fetch(load_varuint),
-                load_embedded_string(encoding),
+                load_string(encoding),
                 load_location_object(freeze),
                 load_error_level
               )
@@ -369,6 +437,7 @@ module Prism
         errors
       end
 
+      #: () -> Symbol
       def load_warning_level
         level = io.getbyte
 
@@ -382,13 +451,14 @@ module Prism
         end
       end
 
+      #: (Encoding encoding, bool freeze) -> Array[ParseWarning]
       def load_warnings(encoding, freeze)
         warnings =
           Array.new(load_varuint) do
             warning =
               ParseWarning.new(
                 DIAGNOSTIC_TYPES.fetch(load_varuint),
-                load_embedded_string(encoding),
+                load_string(encoding),
                 load_location_object(freeze),
                 load_warning_level
               )
@@ -401,18 +471,18 @@ module Prism
         warnings
       end
 
+      #: () -> Array[Token]
       def load_tokens
-        tokens = []
+        tokens = [] #: Array[Token]
 
         while (type = TOKEN_TYPES.fetch(load_varuint))
-          start = load_varuint
-          length = load_varuint
+          location = load_location_object(false)
+
           lex_state = load_varuint
 
-          location = Location.new(@source, start, length)
-          token = Token.new(@source, type, location.slice, location)
+          token = Token.new(@source, type, location.slice, location, lex_state)
 
-          tokens << [token, lex_state]
+          tokens << token
         end
 
         tokens
@@ -420,25 +490,29 @@ module Prism
 
       # variable-length integer using https://en.wikipedia.org/wiki/LEB128
       # This is also what protobuf uses: https://protobuf.dev/programming-guides/encoding/#varints
+      #
+      #: () -> Integer
       def load_varuint
-        n = io.getbyte
+        n = (io.getbyte or raise)
         if n < 128
           n
         else
           n -= 128
           shift = 0
-          while (b = io.getbyte) >= 128
+          while (b = (io.getbyte or raise)) >= 128
             n += (b - 128) << (shift += 7)
           end
           n + (b << (shift + 7))
         end
       end
 
+      #: () -> Integer
       def load_varsint
         n = load_varuint
         (n >> 1) ^ (-(n & 1))
       end
 
+      #: () -> Integer
       def load_integer
         negative = io.getbyte != 0
         length = load_varuint
@@ -450,133 +524,212 @@ module Prism
         value
       end
 
+      #: () -> Float
       def load_double
-        io.read(8).unpack1("D")
+        (io.read(8) or raise).unpack1("D") #: Float
       end
 
-      def load_uint32
-        io.read(4).unpack1("L")
+      #: () -> bool
+      def load_bool
+        (io.getbyte or raise) != 0
       end
 
-      def load_optional_node(constant_pool, encoding, freeze)
-        if io.getbyte != 0
-          io.pos -= 1
-          load_node(constant_pool, encoding, freeze)
-        end
+      #: () -> Integer
+      def load_uint32
+        (io.read(4) or raise).unpack1("L") #: Integer
       end
 
-      def load_embedded_string(encoding)
-        io.read(load_varuint).force_encoding(encoding).freeze
+      #: () -> Integer
+      def load_uint64
+        (io.read(8) or raise).unpack1("Q") #: Integer
       end
 
+      #: (Encoding encoding) -> String
       def load_string(encoding)
-        case (type = io.getbyte)
-        when 1
-          input.byteslice(load_varuint, load_varuint).force_encoding(encoding).freeze
-        when 2
-          load_embedded_string(encoding)
-        else
-          raise "Unknown serialized string type: #{type}"
-        end
+        (io.read(load_varuint) or raise).force_encoding(encoding).freeze
       end
 
+      #: (bool freeze) -> Location
       def load_location_object(freeze)
         location = Location.new(source, load_varuint, load_varuint)
         location.freeze if freeze
         location
       end
 
+      # Load a location object from the serialized data. Note that we are lying
+      # about the signature a bit here, because we sometimes load it as a packed
+      # integer instead of an object.
+      #
+      #: (bool freeze) -> Location
       def load_location(freeze)
         return load_location_object(freeze) if freeze
-        (load_varuint << 32) | load_varuint
+        (load_varuint << 32) | load_varuint #: Location
       end
 
+      # Load an optional location object from the serialized data if it is
+      # present. Note that we are lying about the signature a bit here, because
+      # we sometimes load it as a packed integer instead of an object.
+      #
+      #: (bool freeze) -> Location?
       def load_optional_location(freeze)
         load_location(freeze) if io.getbyte != 0
       end
 
+      #: (bool freeze) -> Location?
       def load_optional_location_object(freeze)
         load_location_object(freeze) if io.getbyte != 0
       end
 
+      #: (ConstantPool constant_pool, Encoding encoding) -> Symbol
       def load_constant(constant_pool, encoding)
         index = load_varuint
         constant_pool.get(index - 1, encoding)
       end
 
+      #: (ConstantPool constant_pool, Encoding encoding) -> Symbol?
       def load_optional_constant(constant_pool, encoding)
         index = load_varuint
         constant_pool.get(index - 1, encoding) if index != 0
       end
 
       if RUBY_ENGINE == "ruby"
-        def load_node(constant_pool, encoding, freeze)
-          type = io.getbyte
-          node_id = load_varuint
-          location = load_location(freeze)
-          value = case type
-          <%- nodes.each_with_index do |node, index| -%>
-          when <%= index + 1 %> then
-            <%- if node.needs_serialized_length? -%>
-            load_uint32
-            <%- end -%>
-            <%= node.name %>.new(<%= ["source", "node_id", "location", "load_varuint", *node.fields.map { |field|
-              case field
-              when Prism::Template::NodeField then "load_node(constant_pool, encoding, freeze)"
-              when Prism::Template::OptionalNodeField then "load_optional_node(constant_pool, encoding, freeze)"
-              when Prism::Template::StringField then "load_string(encoding)"
-              when Prism::Template::NodeListField then "Array.new(load_varuint) { load_node(constant_pool, encoding, freeze) }.tap { |nodes| nodes.freeze if freeze }"
-              when Prism::Template::ConstantField then "load_constant(constant_pool, encoding)"
-              when Prism::Template::OptionalConstantField then "load_optional_constant(constant_pool, encoding)"
-              when Prism::Template::ConstantListField then "Array.new(load_varuint) { load_constant(constant_pool, encoding) }.tap { |constants| constants.freeze if freeze }"
-              when Prism::Template::LocationField then "load_location(freeze)"
-              when Prism::Template::OptionalLocationField then "load_optional_location(freeze)"
-              when Prism::Template::UInt8Field then "io.getbyte"
-              when Prism::Template::UInt32Field then "load_varuint"
-              when Prism::Template::IntegerField then "load_integer"
-              when Prism::Template::DoubleField then "load_double"
-              else raise
-              end
-            }].join(", ") -%>)
+        # Load the nodes that are serialized before the given offset and return
+        # the root. Nodes are serialized in post-order, so the children of each
+        # node are the topmost values on the stack, in field order, by the time
+        # its record is read.
+        #
+        #: (ConstantPool constant_pool, Encoding encoding, bool freeze, Integer finish) -> node
+        def load_nodes(constant_pool, encoding, freeze, finish)
+          stack = [] #: Array[node?]
+
+          while io.pos < finish
+            case (type = io.getbyte)
+            when 0
+              stack << nil
+            when <%= Prism::Template::LAZY_MARKER %>
+              io.read(8)
+            <%- nodes.each_with_index do |node, index| -%>
+            when <%= index + 1 %>
+              node_id = load_varuint
+              location = load_location(freeze)
+              flags = load_varuint
+              <%- node.fields.each do |field| -%>
+              <%- case field -%>
+              <%- when Prism::Template::NodeField, Prism::Template::OptionalNodeField -%>
+              <%- when Prism::Template::NodeListField -%>
+              <%= field.name %>_size = load_varuint
+              <%- when Prism::Template::StringField -%>
+              field_<%= field.name %> = load_string(encoding)
+              <%- when Prism::Template::ConstantField -%>
+              field_<%= field.name %> = load_constant(constant_pool, encoding)
+              <%- when Prism::Template::OptionalConstantField -%>
+              field_<%= field.name %> = load_optional_constant(constant_pool, encoding)
+              <%- when Prism::Template::ConstantListField -%>
+              field_<%= field.name %> = Array.new(load_varuint) { load_constant(constant_pool, encoding) }
+              field_<%= field.name %>.freeze if freeze
+              <%- when Prism::Template::LocationField -%>
+              field_<%= field.name %> = load_location(freeze)
+              <%- when Prism::Template::OptionalLocationField -%>
+              field_<%= field.name %> = load_optional_location(freeze)
+              <%- when Prism::Template::UInt8Field -%>
+              field_<%= field.name %> = (io.getbyte or raise)
+              <%- when Prism::Template::UInt32Field -%>
+              field_<%= field.name %> = load_varuint
+              <%- when Prism::Template::IntegerField -%>
+              field_<%= field.name %> = load_integer
+              <%- when Prism::Template::DoubleField -%>
+              field_<%= field.name %> = load_double
+              <%- else raise -%>
+              <%- end -%>
+              <%- end -%>
+              <%- node.child_fields.reverse_each do |field| -%>
+              <%- if field.is_a?(Prism::Template::NodeListField) -%>
+              field_<%= field.name %> = stack.slice!(-<%= field.name %>_size, <%= field.name %>_size) #: <%= field.rbs_class %>
+              field_<%= field.name %>.freeze if freeze
+              <%- else -%>
+              field_<%= field.name %> = stack.pop #: <%= field.rbs_class %>
+              <%- end -%>
+              <%- end -%>
+              value = <%= node.name %>.new(source, node_id, location, flags<%= node.fields.map { |field| ", field_#{field.name}" }.join %>)
+              value.freeze if freeze
+              stack << value
             <%- end -%>
+            else
+              raise "Unknown node type: #{type}"
+            end
           end
 
-          value.freeze if freeze
-          value
+          raise unless io.pos == finish && stack.length == 1
+          stack.first or raise
         end
       else
-        def load_node(constant_pool, encoding, freeze)
-          @load_node_lambdas[io.getbyte].call(constant_pool, encoding, freeze)
+        # @rbs skip
+        def load_nodes(constant_pool, encoding, freeze, finish)
+          stack = [] #: Array[node?]
+
+          while io.pos < finish
+            type = (io.getbyte or raise)
+
+            if type == 0
+              stack << nil
+            elsif type == <%= Prism::Template::LAZY_MARKER %>
+              io.read(8)
+            else
+              stack << @load_node_lambdas[type].call(constant_pool, encoding, freeze, stack)
+            end
+          end
+
+          raise unless io.pos == finish && stack.length == 1
+          stack.first or raise
         end
 
+        # @rbs skip
         def define_load_node_lambdas
           @load_node_lambdas = [
             nil,
             <%- nodes.each do |node| -%>
-            -> (constant_pool, encoding, freeze) {
+            -> (constant_pool, encoding, freeze, stack) {
               node_id = load_varuint
               location = load_location(freeze)
-              <%- if node.needs_serialized_length? -%>
-              load_uint32
+              flags = load_varuint
+              <%- node.fields.each do |field| -%>
+              <%- case field -%>
+              <%- when Prism::Template::NodeField, Prism::Template::OptionalNodeField -%>
+              <%- when Prism::Template::NodeListField -%>
+              <%= field.name %>_size = load_varuint
+              <%- when Prism::Template::StringField -%>
+              field_<%= field.name %> = load_string(encoding)
+              <%- when Prism::Template::ConstantField -%>
+              field_<%= field.name %> = load_constant(constant_pool, encoding)
+              <%- when Prism::Template::OptionalConstantField -%>
+              field_<%= field.name %> = load_optional_constant(constant_pool, encoding)
+              <%- when Prism::Template::ConstantListField -%>
+              field_<%= field.name %> = Array.new(load_varuint) { load_constant(constant_pool, encoding) }
+              field_<%= field.name %>.freeze if freeze
+              <%- when Prism::Template::LocationField -%>
+              field_<%= field.name %> = load_location(freeze)
+              <%- when Prism::Template::OptionalLocationField -%>
+              field_<%= field.name %> = load_optional_location(freeze)
+              <%- when Prism::Template::UInt8Field -%>
+              field_<%= field.name %> = (io.getbyte or raise)
+              <%- when Prism::Template::UInt32Field -%>
+              field_<%= field.name %> = load_varuint
+              <%- when Prism::Template::IntegerField -%>
+              field_<%= field.name %> = load_integer
+              <%- when Prism::Template::DoubleField -%>
+              field_<%= field.name %> = load_double
+              <%- else raise -%>
+              <%- end -%>
               <%- end -%>
-              value = <%= node.name %>.new(<%= ["source", "node_id", "location", "load_varuint", *node.fields.map { |field|
-                case field
-                when Prism::Template::NodeField then "load_node(constant_pool, encoding, freeze)"
-                when Prism::Template::OptionalNodeField then "load_optional_node(constant_pool, encoding, freeze)"
-                when Prism::Template::StringField then "load_string(encoding)"
-                when Prism::Template::NodeListField then "Array.new(load_varuint) { load_node(constant_pool, encoding, freeze) }"
-                when Prism::Template::ConstantField then "load_constant(constant_pool, encoding)"
-                when Prism::Template::OptionalConstantField then "load_optional_constant(constant_pool, encoding)"
-                when Prism::Template::ConstantListField then "Array.new(load_varuint) { load_constant(constant_pool, encoding) }"
-                when Prism::Template::LocationField then "load_location(freeze)"
-                when Prism::Template::OptionalLocationField then "load_optional_location(freeze)"
-                when Prism::Template::UInt8Field then "io.getbyte"
-                when Prism::Template::UInt32Field then "load_varuint"
-                when Prism::Template::IntegerField then "load_integer"
-                when Prism::Template::DoubleField then "load_double"
-                else raise
-                end
-              }].join(", ") -%>)
+              <%- node.child_fields.reverse_each do |field| -%>
+              <%- if field.is_a?(Prism::Template::NodeListField) -%>
+              field_<%= field.name %> = stack.slice!(-<%= field.name %>_size, <%= field.name %>_size) #: <%= field.rbs_class %>
+              field_<%= field.name %>.freeze if freeze
+              <%- else -%>
+              field_<%= field.name %> = stack.pop #: <%= field.rbs_class %>
+              <%- end -%>
+              <%- end -%>
+              value = <%= node.name %>.new(source, node_id, location, flags<%= node.fields.map { |field| ", field_#{field.name}" }.join %>)
               value.freeze if freeze
               value
             },
@@ -584,6 +737,10 @@ module Prism
           ]
         end
       end
+
+      # @rbs!
+      #   @load_node_lambdas: Array[Proc]
+      #   def define_load_node_lambdas: () -> void
     end
 
     # The token types that can be indexed by their enum values.
@@ -592,7 +749,7 @@ module Prism
       <%- tokens.each do |token| -%>
       <%= token.name.to_sym.inspect %>,
       <%- end -%>
-    ].freeze
+    ].freeze #: Array[Symbol?]
 
     private_constant :MAJOR_VERSION, :MINOR_VERSION, :PATCH_VERSION
     private_constant :ConstantPool, :FastStringIO, :Loader, :TOKEN_TYPES