[GR-45043] Import YARP breaking changes - upgrading the version to 0.6.0

PullRequest: truffleruby/3937

Author: andrykonchin

mx.truffleruby/suite.py

@@ -144,7 +144,7 @@
             "sourceDirs": ["java"],
             "jniHeaders": True,
             "jacoco": "include",
-            "javaCompliance": "17+",
+            "javaCompliance": "8+",
             "workingSets": "TruffleRuby",
             "license": ["MIT"],
         },

src/main/c/yarp/include/yarp/ast.h

@@ -654,7 +654,7 @@ typedef struct yp_constant_path_operator_write_node {
 // ConstantPathWriteNode
 typedef struct yp_constant_path_write_node {
     yp_node_t base;
-    struct yp_node *target;
+    struct yp_constant_path_node *target;
     yp_location_t operator_loc;
     struct yp_node *value;
 } yp_constant_path_write_node_t;

src/main/c/yarp/include/yarp/version.h

@@ -1,5 +1,5 @@
 #define YP_VERSION_MAJOR 0
-#define YP_VERSION_MINOR 4
+#define YP_VERSION_MINOR 6
 #define YP_VERSION_PATCH 0
 
-#define YP_VERSION "0.4.0"
+#define YP_VERSION "0.6.0"

src/main/c/yarp/src/yarp.c

@@ -582,23 +582,20 @@ public RubyNode visitConstantPathOperatorWriteNode(Nodes.ConstantPathOperatorWri
     }
 
     public RubyNode visitConstantPathWriteNode(Nodes.ConstantPathWriteNode node) {
-        assert node.target instanceof Nodes.ConstantPathNode;
-
-        final RubyNode rubyNode;
-        final RubyNode value = translateNodeOrDeadNode(node.value, "YARPTranslator#visitConstantPathWriteNode");
-        final var pathNode = (Nodes.ConstantPathNode) node.target;
-        final String name = toString(pathNode.child);
+        final Nodes.ConstantPathNode constantPathNode = node.target;
         final RubyNode moduleNode;
 
-        if (pathNode.parent != null) {
+        if (constantPathNode.parent != null) {
             // FOO::BAR = 1
-            moduleNode = pathNode.parent.accept(this);
+            moduleNode = constantPathNode.parent.accept(this);
         } else {
             // ::FOO = 1
             moduleNode = new ObjectClassLiteralNode();
         }
 
-        rubyNode = new WriteConstantNode(name, moduleNode, value);
+        final String name = toString(constantPathNode.child);
+        final RubyNode value = translateNodeOrDeadNode(node.value, "YARPTranslator#visitConstantPathWriteNode");
+        final RubyNode rubyNode = new WriteConstantNode(name, moduleNode, value);
 
         assignNodePositionInSource(node, rubyNode);
         return rubyNode;

src/main/java/org/truffleruby/parser/YARPTranslator.java

@@ -64,7 +64,7 @@ private ParseResult load() {
         expect((byte) 'P');
 
         expect((byte) 0);
-        expect((byte) 4);
+        expect((byte) 6);
         expect((byte) 0);
 
         // This loads the name of the encoding. We don't actually do anything
@@ -103,15 +103,15 @@ private byte[] loadString() {
 
     private ParseResult.Error[] loadSyntaxErrors() {
         int count = loadVarInt();
-        var errors = new ParseResult.Error[count];
+        ParseResult.Error[] errors = new ParseResult.Error[count];
 
         // error messages only contain ASCII characters
         for (int i = 0; i < count; i++) {
             byte[] bytes = loadString();
             String message = new String(bytes, StandardCharsets.US_ASCII);
             Nodes.Location location = loadLocation();
 
-            var error = new ParseResult.Error(message, location);
+            ParseResult.Error error = new ParseResult.Error(message, location);
             errors[i] = error;
         }
 
@@ -120,15 +120,15 @@ private ParseResult.Error[] loadSyntaxErrors() {
 
     private ParseResult.Warning[] loadWarnings() {
         int count = loadVarInt();
-        var warnings = new ParseResult.Warning[count];
+        ParseResult.Warning[] warnings = new ParseResult.Warning[count];
 
         // warning messages only contain ASCII characters
         for (int i = 0; i < count; i++) {
             byte[] bytes = loadString();
             String message = new String(bytes, StandardCharsets.US_ASCII);
             Nodes.Location location = loadLocation();
 
-            var warning = new ParseResult.Warning(message, location);
+            ParseResult.Warning warning = new ParseResult.Warning(message, location);
             warnings[i] = warning;
         }
 
@@ -289,7 +289,7 @@ private Nodes.Node loadNode() {
             case 34:
                 return new Nodes.ConstantPathOperatorWriteNode((Nodes.ConstantPathNode) loadNode(), loadLocation(), loadNode(), loadConstant(), startOffset, length);
             case 35:
-                return new Nodes.ConstantPathWriteNode(loadNode(), loadOptionalLocation(), loadOptionalNode(), startOffset, length);
+                return new Nodes.ConstantPathWriteNode((Nodes.ConstantPathNode) loadNode(), loadOptionalLocation(), loadOptionalNode(), startOffset, length);
             case 36:
                 return new Nodes.ConstantReadNode(startOffset, length);
             case 37:

src/yarp/java/org/yarp/Loader.java

@@ -1553,11 +1553,11 @@ public <T> T accept(AbstractNodeVisitor<T> visitor) {
     //     ::Foo::Bar = 1
     //     ^^^^^^^^^^^^^^
     public static final class ConstantPathWriteNode extends Node {
-        public final Node target;
+        public final ConstantPathNode target;
         public final Location operator_loc; // optional
         public final Node value; // optional
 
-        public ConstantPathWriteNode(Node target, Location operator_loc, Node value, int startOffset, int length) {
+        public ConstantPathWriteNode(ConstantPathNode target, Location operator_loc, Node value, int startOffset, int length) {
             super(startOffset, length);
             this.target = target;
             this.operator_loc = operator_loc;