serialize.rb in prism-0.17.0

- old
+ new

@@ -9,40 +9,53 @@
 
 # Polyfill for String#unpack1 with the offset parameter.
 if String.instance_method(:unpack1).parameters.none? { |_, name| name == :offset }
   String.prepend(
     Module.new {
-      def unpack1(format, offset: 0)
+      def unpack1(format, offset: 0) # :nodoc:
         offset == 0 ? super(format) : self[offset..].unpack1(format)
       end
     }
   )
 end
 
 module Prism
+  # A module responsible for deserializing parse results.
   module Serialize
+    # The major version of prism that we are expecting to find in the serialized
+    # strings.
     MAJOR_VERSION = 0
-    MINOR_VERSION = 16
+
+    # The minor version of prism that we are expecting to find in the serialized
+    # strings.
+    MINOR_VERSION = 17
+
+    # The patch version of prism that we are expecting to find in the serialized
+    # strings.
     PATCH_VERSION = 0
 
+    # Deserialize the AST represented by the given string into a parse result.
     def self.load(input, serialized)
       input = input.dup
       source = Source.new(input)
       loader = Loader.new(source, serialized)
       result = loader.load_result
 
       input.force_encoding(loader.encoding)
       result
     end
 
+    # Deserialize the tokens represented by the given string into a parse
+    # result.
     def self.load_tokens(source, serialized)
       Loader.new(source, serialized).load_tokens_result
     end
 
-    class Loader
+    class Loader # :nodoc:
       attr_reader :encoding, :input, :serialized, :io
       attr_reader :constant_pool_offset, :constant_pool, :source
+      attr_reader :start_line
 
       def initialize(source, serialized)
         @encoding = Encoding::UTF_8
 
         @input = source.source.dup
@@ -52,11 +65,11 @@
 
         @constant_pool_offset = nil
         @constant_pool = nil
 
         @source = source
-        define_load_node_lambdas unless RUBY_ENGINE == 'ruby'
+        define_load_node_lambdas unless RUBY_ENGINE == "ruby"
       end
 
       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]
@@ -73,12 +86,22 @@
       def load_force_encoding
         @encoding = load_encoding
         @input = input.force_encoding(@encoding).freeze
       end
 
+      def load_start_line
+        source.start_line = load_varint
+      end
+
       def load_comments
-        load_varint.times.map { Comment.new(Comment::TYPES.fetch(load_varint), load_location) }
+        load_varint.times.map do
+          case load_varint
+          when 0 then InlineComment.new(load_location)
+          when 1 then EmbDocComment.new(load_location)
+          when 2 then DATAComment.new(load_location)
+          end
+        end
       end
 
       def load_metadata
         comments = load_comments
         magic_comments = load_varint.times.map { MagicComment.new(load_location, load_location) }
@@ -101,10 +124,11 @@
       end
 
       def load_tokens_result
         tokens = load_tokens
         encoding = load_encoding
+        load_start_line
         comments, magic_comments, errors, warnings = load_metadata
 
         if encoding != @encoding
           tokens.each { |token,| token.value.force_encoding(encoding) }
         end
@@ -114,10 +138,11 @@
       end
 
       def load_nodes
         load_header
         load_force_encoding
+        load_start_line
 
         comments, magic_comments, errors, warnings = load_metadata
 
         @constant_pool_offset = io.read(4).unpack1("L")
         @constant_pool = Array.new(load_varint, nil)
@@ -387,51 +412,51 @@
           when 83 then
             InterpolatedXStringNode.new(load_location, Array.new(load_varint) { load_node }, load_location, location)
           when 84 then
             KeywordHashNode.new(Array.new(load_varint) { load_node }, location)
           when 85 then
-            KeywordParameterNode.new(load_required_constant, load_location, load_optional_node, location)
-          when 86 then
             KeywordRestParameterNode.new(load_optional_constant, load_optional_location, load_location, location)
-          when 87 then
+          when 86 then
             LambdaNode.new(Array.new(load_varint) { load_required_constant }, load_location, load_location, load_location, load_optional_node, load_optional_node, location)
-          when 88 then
+          when 87 then
             LocalVariableAndWriteNode.new(load_location, load_location, load_node, load_required_constant, load_varint, location)
-          when 89 then
+          when 88 then
             LocalVariableOperatorWriteNode.new(load_location, load_location, load_node, load_required_constant, load_required_constant, load_varint, location)
-          when 90 then
+          when 89 then
             LocalVariableOrWriteNode.new(load_location, load_location, load_node, load_required_constant, load_varint, location)
-          when 91 then
+          when 90 then
             LocalVariableReadNode.new(load_required_constant, load_varint, location)
-          when 92 then
+          when 91 then
             LocalVariableTargetNode.new(load_required_constant, load_varint, location)
-          when 93 then
+          when 92 then
             LocalVariableWriteNode.new(load_required_constant, load_varint, load_location, load_node, load_location, location)
-          when 94 then
+          when 93 then
             MatchLastLineNode.new(load_location, load_location, load_location, load_string, load_varint, location)
-          when 95 then
+          when 94 then
             MatchPredicateNode.new(load_node, load_node, load_location, location)
-          when 96 then
+          when 95 then
             MatchRequiredNode.new(load_node, load_node, load_location, location)
-          when 97 then
+          when 96 then
             MatchWriteNode.new(load_node, Array.new(load_varint) { load_required_constant }, location)
-          when 98 then
+          when 97 then
             MissingNode.new(location)
-          when 99 then
+          when 98 then
             ModuleNode.new(Array.new(load_varint) { load_required_constant }, load_location, load_node, load_optional_node, load_location, load_required_constant, location)
-          when 100 then
+          when 99 then
             MultiTargetNode.new(Array.new(load_varint) { load_node }, load_optional_node, Array.new(load_varint) { load_node }, load_optional_location, load_optional_location, location)
-          when 101 then
+          when 100 then
             MultiWriteNode.new(Array.new(load_varint) { load_node }, load_optional_node, Array.new(load_varint) { load_node }, load_optional_location, load_optional_location, load_location, load_node, location)
-          when 102 then
+          when 101 then
             NextNode.new(load_optional_node, load_location, location)
-          when 103 then
+          when 102 then
             NilNode.new(location)
-          when 104 then
+          when 103 then
             NoKeywordsParameterNode.new(load_location, load_location, location)
-          when 105 then
+          when 104 then
             NumberedReferenceReadNode.new(load_varint, location)
+          when 105 then
+            OptionalKeywordParameterNode.new(load_required_constant, load_location, load_node, location)
           when 106 then
             OptionalParameterNode.new(load_required_constant, load_location, load_location, load_node, location)
           when 107 then
             OrNode.new(load_node, load_node, load_location, location)
           when 108 then
@@ -455,58 +480,60 @@
           when 117 then
             RedoNode.new(location)
           when 118 then
             RegularExpressionNode.new(load_location, load_location, load_location, load_string, load_varint, location)
           when 119 then
-            RequiredParameterNode.new(load_required_constant, location)
+            RequiredKeywordParameterNode.new(load_required_constant, load_location, location)
           when 120 then
-            RescueModifierNode.new(load_node, load_location, load_node, location)
+            RequiredParameterNode.new(load_required_constant, location)
           when 121 then
-            RescueNode.new(load_location, Array.new(load_varint) { load_node }, load_optional_location, load_optional_node, load_optional_node, load_optional_node, location)
+            RescueModifierNode.new(load_node, load_location, load_node, location)
           when 122 then
-            RestParameterNode.new(load_optional_constant, load_optional_location, load_location, location)
+            RescueNode.new(load_location, Array.new(load_varint) { load_node }, load_optional_location, load_optional_node, load_optional_node, load_optional_node, location)
           when 123 then
-            RetryNode.new(location)
+            RestParameterNode.new(load_optional_constant, load_optional_location, load_location, location)
           when 124 then
-            ReturnNode.new(load_location, load_optional_node, location)
+            RetryNode.new(location)
           when 125 then
-            SelfNode.new(location)
+            ReturnNode.new(load_location, load_optional_node, location)
           when 126 then
-            SingletonClassNode.new(Array.new(load_varint) { load_required_constant }, load_location, load_location, load_node, load_optional_node, load_location, location)
+            SelfNode.new(location)
           when 127 then
-            SourceEncodingNode.new(location)
+            SingletonClassNode.new(Array.new(load_varint) { load_required_constant }, load_location, load_location, load_node, load_optional_node, load_location, location)
           when 128 then
-            SourceFileNode.new(load_string, location)
+            SourceEncodingNode.new(location)
           when 129 then
-            SourceLineNode.new(location)
+            SourceFileNode.new(load_string, location)
           when 130 then
-            SplatNode.new(load_location, load_optional_node, location)
+            SourceLineNode.new(location)
           when 131 then
-            StatementsNode.new(Array.new(load_varint) { load_node }, location)
+            SplatNode.new(load_location, load_optional_node, location)
           when 132 then
-            StringConcatNode.new(load_node, load_node, location)
+            StatementsNode.new(Array.new(load_varint) { load_node }, location)
           when 133 then
-            StringNode.new(load_varint, load_optional_location, load_location, load_optional_location, load_string, location)
+            StringConcatNode.new(load_node, load_node, location)
           when 134 then
-            SuperNode.new(load_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, location)
+            StringNode.new(load_varint, load_optional_location, load_location, load_optional_location, load_string, location)
           when 135 then
-            SymbolNode.new(load_optional_location, load_optional_location, load_optional_location, load_string, location)
+            SuperNode.new(load_location, load_optional_location, load_optional_node, load_optional_location, load_optional_node, location)
           when 136 then
-            TrueNode.new(location)
+            SymbolNode.new(load_optional_location, load_optional_location, load_optional_location, load_string, location)
           when 137 then
-            UndefNode.new(Array.new(load_varint) { load_node }, load_location, location)
+            TrueNode.new(location)
           when 138 then
-            UnlessNode.new(load_location, load_node, load_optional_node, load_optional_node, load_optional_location, location)
+            UndefNode.new(Array.new(load_varint) { load_node }, load_location, location)
           when 139 then
-            UntilNode.new(load_location, load_optional_location, load_node, load_optional_node, load_varint, location)
+            UnlessNode.new(load_location, load_node, load_optional_node, load_optional_node, load_optional_location, location)
           when 140 then
-            WhenNode.new(load_location, Array.new(load_varint) { load_node }, load_optional_node, location)
+            UntilNode.new(load_location, load_optional_location, load_node, load_optional_node, load_varint, location)
           when 141 then
-            WhileNode.new(load_location, load_optional_location, load_node, load_optional_node, load_varint, location)
+            WhenNode.new(load_location, Array.new(load_varint) { load_node }, load_optional_node, location)
           when 142 then
-            XStringNode.new(load_location, load_location, load_location, load_string, location)
+            WhileNode.new(load_location, load_optional_location, load_node, load_optional_node, load_varint, location)
           when 143 then
+            XStringNode.new(load_location, load_location, load_location, load_string, location)
+          when 144 then
             YieldNode.new(load_location, load_optional_location, load_optional_node, load_optional_location, location)
           end
         end
       else
         def load_node
@@ -854,14 +881,10 @@
               location = load_location
               KeywordHashNode.new(Array.new(load_varint) { load_node }, location)
             },
             -> {
               location = load_location
-              KeywordParameterNode.new(load_required_constant, load_location, load_optional_node, location)
-            },
-            -> {
-              location = load_location
               KeywordRestParameterNode.new(load_optional_constant, load_optional_location, load_location, location)
             },
             -> {
               location = load_location
               LambdaNode.new(Array.new(load_varint) { load_required_constant }, load_location, load_location, load_location, load_optional_node, load_optional_node, location)
@@ -938,10 +961,14 @@
               location = load_location
               NumberedReferenceReadNode.new(load_varint, location)
             },
             -> {
               location = load_location
+              OptionalKeywordParameterNode.new(load_required_constant, load_location, load_node, location)
+            },
+            -> {
+              location = load_location
               OptionalParameterNode.new(load_required_constant, load_location, load_location, load_node, location)
             },
             -> {
               location = load_location
               OrNode.new(load_node, load_node, load_location, location)
@@ -990,10 +1017,14 @@
               location = load_location
               RegularExpressionNode.new(load_location, load_location, load_location, load_string, load_varint, location)
             },
             -> {
               location = load_location
+              RequiredKeywordParameterNode.new(load_required_constant, load_location, location)
+            },
+            -> {
+              location = load_location
               RequiredParameterNode.new(load_required_constant, location)
             },
             -> {
               location = load_location
               RescueModifierNode.new(load_node, load_location, load_node, location)
@@ -1093,9 +1124,10 @@
           ]
         end
       end
     end
 
+    # The token types that can be indexed by their enum values.
     TOKEN_TYPES = [
       nil,
       :EOF,
       :MISSING,
       :NOT_PROVIDED,