yarp 0.9.0 → 0.11.0

data/include/yarp/util/yp_strpbrk.h

@@ -24,6 +24,6 @@
 // characters that are trailing bytes of multi-byte characters. For example, in
 // Shift-JIS, the backslash character can be a trailing byte. In that case we
 // need to take a slower path and iterate one multi-byte character at a time.
-const char * yp_strpbrk(yp_parser_t *parser, const char *source, const char *charset, ptrdiff_t length);
+const uint8_t * yp_strpbrk(yp_parser_t *parser, const uint8_t *source, const uint8_t *charset, ptrdiff_t length);
 
 #endif

data/include/yarp/version.h

@@ -1,4 +1,4 @@
 #define YP_VERSION_MAJOR 0
-#define YP_VERSION_MINOR 9
+#define YP_VERSION_MINOR 11
 #define YP_VERSION_PATCH 0
-#define YP_VERSION "0.9.0"
+#define YP_VERSION "0.11.0"

data/include/yarp.h

@@ -16,6 +16,7 @@
 #include "yarp/version.h"
 
 #include <assert.h>
+#include <errno.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdint.h>
@@ -40,7 +41,7 @@ void yp_scope_node_init(yp_node_t *node, yp_scope_node_t *dest);
 YP_EXPORTED_FUNCTION const char * yp_version(void);
 
 // Initialize a parser with the given start and end pointers.
-YP_EXPORTED_FUNCTION void yp_parser_init(yp_parser_t *parser, const char *source, size_t size, const char *filepath);
+YP_EXPORTED_FUNCTION void yp_parser_init(yp_parser_t *parser, const uint8_t *source, size_t size, const char *filepath);
 
 // Register a callback that will be called whenever YARP changes the encoding it
 // is using to parse based on the magic comment.
@@ -66,14 +67,14 @@ YP_EXPORTED_FUNCTION void yp_prettyprint(yp_parser_t *parser, yp_node_t *node, y
 YP_EXPORTED_FUNCTION void yp_serialize(yp_parser_t *parser, yp_node_t *node, yp_buffer_t *buffer);
 
 // Parse the given source to the AST and serialize the AST to the given buffer.
-YP_EXPORTED_FUNCTION void yp_parse_serialize(const char *source, size_t size, yp_buffer_t *buffer, const char *metadata);
+YP_EXPORTED_FUNCTION void yp_parse_serialize(const uint8_t *source, size_t size, yp_buffer_t *buffer, const char *metadata);
 
 // Lex the given source and serialize to the given buffer.
-YP_EXPORTED_FUNCTION void yp_lex_serialize(const char *source, size_t size, const char *filepath, yp_buffer_t *buffer);
+YP_EXPORTED_FUNCTION void yp_lex_serialize(const uint8_t *source, size_t size, const char *filepath, yp_buffer_t *buffer);
 
 // Parse and serialize both the AST and the tokens represented by the given
 // source to the given buffer.
-YP_EXPORTED_FUNCTION void yp_parse_lex_serialize(const char *source, size_t size, yp_buffer_t *buffer, const char *metadata);
+YP_EXPORTED_FUNCTION void yp_parse_lex_serialize(const uint8_t *source, size_t size, yp_buffer_t *buffer, const char *metadata);
 
 // Returns a string representation of the given token type.
 YP_EXPORTED_FUNCTION const char * yp_token_type_to_str(yp_token_type_t token_type);

data/lib/yarp/desugar_visitor.rb

@@ -8,26 +8,16 @@ module YARP
     #
     # @@foo && @@foo = bar
     def visit_class_variable_and_write_node(node)
-      AndNode.new(
-        ClassVariableReadNode.new(node.name_loc),
-        ClassVariableWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_and_write_node(node, ClassVariableReadNode, ClassVariableWriteNode, node.name)
     end
 
     # @@foo ||= bar
     #
     # becomes
     #
-    # @@foo || @@foo = bar
+    # defined?(@@foo) ? @@foo : @@foo = bar
     def visit_class_variable_or_write_node(node)
-      OrNode.new(
-        ClassVariableReadNode.new(node.name_loc),
-        ClassVariableWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_or_write_defined_node(node, ClassVariableReadNode, ClassVariableWriteNode, node.name)
     end
 
     # @@foo += bar
@@ -36,7 +26,7 @@ module YARP
     #
     # @@foo = @@foo + bar
     def visit_class_variable_operator_write_node(node)
-      desugar_operator_write_node(node, ClassVariableWriteNode, ClassVariableReadNode)
+      desugar_operator_write_node(node, ClassVariableReadNode, ClassVariableWriteNode, node.name)
     end
 
     # Foo &&= bar
@@ -45,26 +35,16 @@ module YARP
     #
     # Foo && Foo = bar
     def visit_constant_and_write_node(node)
-      AndNode.new(
-        ConstantReadNode.new(node.name_loc),
-        ConstantWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_and_write_node(node, ConstantReadNode, ConstantWriteNode, node.name)
     end
 
     # Foo ||= bar
     #
     # becomes
     #
-    # Foo || Foo = bar
+    # defined?(Foo) ? Foo : Foo = bar
     def visit_constant_or_write_node(node)
-      OrNode.new(
-        ConstantReadNode.new(node.name_loc),
-        ConstantWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_or_write_defined_node(node, ConstantReadNode, ConstantWriteNode, node.name)
     end
 
     # Foo += bar
@@ -73,60 +53,7 @@ module YARP
     #
     # Foo = Foo + bar
     def visit_constant_operator_write_node(node)
-      desugar_operator_write_node(node, ConstantWriteNode, ConstantReadNode)
-    end
-
-    # Foo::Bar &&= baz
-    #
-    # becomes
-    #
-    # Foo::Bar && Foo::Bar = baz
-    def visit_constant_path_and_write_node(node)
-      AndNode.new(
-        node.target,
-        ConstantPathWriteNode.new(node.target, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
-    end
-
-    # Foo::Bar ||= baz
-    #
-    # becomes
-    #
-    # Foo::Bar || Foo::Bar = baz
-    def visit_constant_path_or_write_node(node)
-      OrNode.new(
-        node.target,
-        ConstantPathWriteNode.new(node.target, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
-    end
-
-    # Foo::Bar += baz
-    #
-    # becomes
-    #
-    # Foo::Bar = Foo::Bar + baz
-    def visit_constant_path_operator_write_node(node)
-      ConstantPathWriteNode.new(
-        node.target,
-        CallNode.new(
-          node.target,
-          nil,
-          node.operator_loc.copy(length: node.operator_loc.length - 1),
-          nil,
-          ArgumentsNode.new([node.value], node.value.location),
-          nil,
-          nil,
-          0,
-          node.operator_loc.slice.chomp("="),
-          node.location
-        ),
-        node.operator_loc.copy(start_offset: node.operator_loc.end_offset - 1, length: 1),
-        node.location
-      )
+      desugar_operator_write_node(node, ConstantReadNode, ConstantWriteNode, node.name)
     end
 
     # $foo &&= bar
@@ -135,26 +62,16 @@ module YARP
     #
     # $foo && $foo = bar
     def visit_global_variable_and_write_node(node)
-      AndNode.new(
-        GlobalVariableReadNode.new(node.name_loc),
-        GlobalVariableWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_and_write_node(node, GlobalVariableReadNode, GlobalVariableWriteNode, node.name)
     end
 
     # $foo ||= bar
     #
     # becomes
     #
-    # $foo || $foo = bar
+    # defined?($foo) ? $foo : $foo = bar
     def visit_global_variable_or_write_node(node)
-      OrNode.new(
-        GlobalVariableReadNode.new(node.name_loc),
-        GlobalVariableWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_or_write_defined_node(node, GlobalVariableReadNode, GlobalVariableWriteNode, node.name)
     end
 
     # $foo += bar
@@ -163,7 +80,7 @@ module YARP
     #
     # $foo = $foo + bar
     def visit_global_variable_operator_write_node(node)
-      desugar_operator_write_node(node, GlobalVariableWriteNode, GlobalVariableReadNode)
+      desugar_operator_write_node(node, GlobalVariableReadNode, GlobalVariableWriteNode, node.name)
     end
 
     # @foo &&= bar
@@ -172,12 +89,7 @@ module YARP
     #
     # @foo && @foo = bar
     def visit_instance_variable_and_write_node(node)
-      AndNode.new(
-        InstanceVariableReadNode.new(node.name_loc),
-        InstanceVariableWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_and_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, node.name)
     end
 
     # @foo ||= bar
@@ -186,12 +98,7 @@ module YARP
     #
     # @foo || @foo = bar
     def visit_instance_variable_or_write_node(node)
-      OrNode.new(
-        InstanceVariableReadNode.new(node.name_loc),
-        InstanceVariableWriteNode.new(node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_or_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, node.name)
     end
 
     # @foo += bar
@@ -200,7 +107,7 @@ module YARP
     #
     # @foo = @foo + bar
     def visit_instance_variable_operator_write_node(node)
-      desugar_operator_write_node(node, InstanceVariableWriteNode, InstanceVariableReadNode)
+      desugar_operator_write_node(node, InstanceVariableReadNode, InstanceVariableWriteNode, node.name)
     end
 
     # foo &&= bar
@@ -209,12 +116,7 @@ module YARP
     #
     # foo && foo = bar
     def visit_local_variable_and_write_node(node)
-      AndNode.new(
-        LocalVariableReadNode.new(node.constant_id, node.depth, node.name_loc),
-        LocalVariableWriteNode.new(node.constant_id, node.depth, node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_and_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, node.name, node.depth)
     end
 
     # foo ||= bar
@@ -223,12 +125,7 @@ module YARP
     #
     # foo || foo = bar
     def visit_local_variable_or_write_node(node)
-      OrNode.new(
-        LocalVariableReadNode.new(node.constant_id, node.depth, node.name_loc),
-        LocalVariableWriteNode.new(node.constant_id, node.depth, node.name_loc, node.value, node.operator_loc, node.location),
-        node.operator_loc,
-        node.location
-      )
+      desugar_or_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, node.name, node.depth)
     end
 
     # foo += bar
@@ -237,13 +134,23 @@ module YARP
     #
     # foo = foo + bar
     def visit_local_variable_operator_write_node(node)
-      desugar_operator_write_node(node, LocalVariableWriteNode, LocalVariableReadNode, arguments: [node.constant_id, node.depth])
+      desugar_operator_write_node(node, LocalVariableReadNode, LocalVariableWriteNode, node.name, node.depth)
     end
 
     private
 
+    # Desugar `x &&= y` to `x && x = y`
+    def desugar_and_write_node(node, read_class, write_class, *arguments)
+      AndNode.new(
+        read_class.new(*arguments, node.name_loc),
+        write_class.new(*arguments, node.name_loc, node.value, node.operator_loc, node.location),
+        node.operator_loc,
+        node.location
+      )
+    end
+
     # Desugar `x += y` to `x = x + y`
-    def desugar_operator_write_node(node, write_class, read_class, arguments: [])
+    def desugar_operator_write_node(node, read_class, write_class, *arguments)
       write_class.new(
         *arguments,
         node.name_loc,
@@ -263,5 +170,35 @@ module YARP
         node.location
       )
     end
+
+    # Desugar `x ||= y` to `x || x = y`
+    def desugar_or_write_node(node, read_class, write_class, *arguments)
+      OrNode.new(
+        read_class.new(*arguments, node.name_loc),
+        write_class.new(*arguments, node.name_loc, node.value, node.operator_loc, node.location),
+        node.operator_loc,
+        node.location
+      )
+    end
+
+    # Desugar `x ||= y` to `defined?(x) ? x : x = y`
+    def desugar_or_write_defined_node(node, read_class, write_class, *arguments)
+      IfNode.new(
+        node.operator_loc,
+        DefinedNode.new(nil, read_class.new(*arguments, node.name_loc), nil, node.operator_loc, node.name_loc),
+        StatementsNode.new([read_class.new(*arguments, node.name_loc)], node.location),
+        ElseNode.new(
+          node.operator_loc,
+          StatementsNode.new(
+            [write_class.new(*arguments, node.name_loc, node.value, node.operator_loc, node.location)],
+            node.location
+          ),
+          node.operator_loc,
+          node.location
+        ),
+        node.operator_loc,
+        node.location
+      )
+    end
   end
 end

data/lib/yarp/mutation_visitor.rb

@@ -65,6 +65,11 @@ module YARP
       node.copy(expression: visit(node.expression))
     end
 
+    # Copy a BlockLocalVariableNode node
+    def visit_block_local_variable_node(node)
+      node.copy
+    end
+
     # Copy a BlockNode node
     def visit_block_node(node)
       node.copy(parameters: visit(node.parameters), body: visit(node.body))
@@ -77,7 +82,7 @@ module YARP
 
     # Copy a BlockParametersNode node
     def visit_block_parameters_node(node)
-      node.copy(parameters: visit(node.parameters))
+      node.copy(parameters: visit(node.parameters), locals: visit_all(node.locals))
     end
 
     # Copy a BreakNode node
@@ -85,24 +90,24 @@ module YARP
       node.copy(arguments: visit(node.arguments))
     end
 
+    # Copy a CallAndWriteNode node
+    def visit_call_and_write_node(node)
+      node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), value: visit(node.value))
+    end
+
     # Copy a CallNode node
     def visit_call_node(node)
       node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), block: visit(node.block))
     end
 
-    # Copy a CallOperatorAndWriteNode node
-    def visit_call_operator_and_write_node(node)
-      node.copy(target: visit(node.target), value: visit(node.value))
-    end
-
-    # Copy a CallOperatorOrWriteNode node
-    def visit_call_operator_or_write_node(node)
-      node.copy(target: visit(node.target), value: visit(node.value))
-    end
-
     # Copy a CallOperatorWriteNode node
     def visit_call_operator_write_node(node)
-      node.copy(target: visit(node.target), value: visit(node.value))
+      node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), value: visit(node.value))
+    end
+
+    # Copy a CallOrWriteNode node
+    def visit_call_or_write_node(node)
+      node.copy(receiver: visit(node.receiver), arguments: visit(node.arguments), value: visit(node.value))
     end
 
     # Copy a CapturePatternNode node
@@ -460,6 +465,11 @@ module YARP
       node.copy(constant_path: visit(node.constant_path), body: visit(node.body))
     end
 
+    # Copy a MultiTargetNode node
+    def visit_multi_target_node(node)
+      node.copy(targets: visit_all(node.targets))
+    end
+
     # Copy a MultiWriteNode node
     def visit_multi_write_node(node)
       node.copy(targets: visit_all(node.targets), value: visit(node.value))