lib/prism/serialize.rb in prism-0.13.0 vs lib/prism/serialize.rb in prism-0.14.0

@@ -19,11 +19,11 @@
 end
 
 module Prism
   module Serialize
     MAJOR_VERSION = 0
-    MINOR_VERSION = 13
+    MINOR_VERSION = 14
     PATCH_VERSION = 0
 
     def self.load(input, serialized)
       input = input.dup
       source = Source.new(input)
@@ -60,13 +60,14 @@
         Encoding.find(io.read(load_varint))
       end
 
       def load_metadata
         comments = load_varint.times.map { Comment.new(Comment::TYPES.fetch(load_varint), load_location) }
+        magic_comments = load_varint.times.map { MagicComment.new(load_location, load_location) }
         errors = load_varint.times.map { ParseError.new(load_embedded_string, load_location) }
         warnings = load_varint.times.map { ParseWarning.new(load_embedded_string, load_location) }
-        [comments, errors, warnings]
+        [comments, magic_comments, errors, warnings]
       end
 
       def load_tokens
         tokens = []
         while type = TOKEN_TYPES.fetch(load_varint)
@@ -81,18 +82,18 @@
       end
 
       def load_tokens_result
         tokens = load_tokens
         encoding = load_encoding
-        comments, errors, warnings = load_metadata
+        comments, magic_comments, errors, warnings = load_metadata
 
         if encoding != @encoding
           tokens.each { |token,| token.value.force_encoding(encoding) }
         end
 
         raise "Expected to consume all bytes while deserializing" unless @io.eof?
-        Prism::ParseResult.new(tokens, comments, errors, warnings, @source)
+        Prism::ParseResult.new(tokens, comments, magic_comments, errors, warnings, @source)
       end
 
       def load_nodes
         raise "Invalid serialization" if io.read(5) != "PRISM"
         raise "Invalid serialization" if io.read(3).unpack("C3") != [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION]
@@ -102,21 +103,21 @@
         end
 
         @encoding = load_encoding
         @input = input.force_encoding(@encoding).freeze
 
-        comments, errors, warnings = load_metadata
+        comments, magic_comments, errors, warnings = load_metadata
 
         @constant_pool_offset = io.read(4).unpack1("L")
         @constant_pool = Array.new(load_varint, nil)
 
-        [load_node, comments, errors, warnings]
+        [load_node, comments, magic_comments, errors, warnings]
       end
 
       def load_result
-        node, comments, errors, warnings = load_nodes
-        Prism::ParseResult.new(node, comments, errors, warnings, @source)
+        node, comments, magic_comments, errors, warnings = load_nodes
+        Prism::ParseResult.new(node, comments, magic_comments, errors, warnings, @source)
       end
 
       private
 
       # variable-length integer using https://en.wikipedia.org/wiki/LEB128
@@ -149,17 +150,18 @@
       def load_embedded_string
         io.read(load_varint).force_encoding(encoding)
       end
 
       def load_string
-        case io.getbyte
+        type = io.getbyte
+        case type
         when 1
           input.byteslice(load_varint, load_varint).force_encoding(encoding)
         when 2
           load_embedded_string
         else
-          raise
+          raise "Unknown serialized string type: #{type}"
         end
       end
 
       def load_location
         Location.new(source, load_varint, load_varint)
@@ -237,16 +239,16 @@
         when 16 then
           BlockParametersNode.new(load_optional_node, Array.new(load_varint) { load_node }, load_optional_location, load_optional_location, location)
         when 17 then
           BreakNode.new(load_optional_node, load_location, location)
         when 18 then
-          CallAndWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_string, load_string, load_location, load_node, location)
+          CallAndWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_required_constant, load_required_constant, load_location, load_node, location)
         when 19 then
-          CallNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, load_varint, load_string, location)
+          CallNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, load_varint, load_required_constant, location)
         when 20 then
-          CallOperatorWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_string, load_string, load_required_constant, load_location, load_node, location)
+          CallOperatorWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_required_constant, load_required_constant, load_required_constant, load_location, load_node, location)
         when 21 then
-          CallOrWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_string, load_string, load_location, load_node, location)
+          CallOrWriteNode.new(load_optional_node, load_optional_location, load_optional_location, load_optional_location, load_optional_node, load_optional_location, load_varint, load_required_constant, load_required_constant, load_location, load_node, location)
         when 22 then
           CapturePatternNode.new(load_node, load_node, load_location, location)
         when 23 then
           CaseNode.new(load_optional_node, Array.new(load_varint) { load_node }, load_optional_node, load_location, load_location, location)
         when 24 then