Split ir nodes for variable/field access into load/store (elastic#60976)

This change splits the ir nodes for variable/field accesses into two separate nodes, one for load and 
one for store. This removes the need for an assignment node as the store nodes replace it as the root. 
It also means all nodes simply have a write method instead of having separate methods for load and 
store to support the different types of bytecode required for this. This also means that compound 
assignment is no longer specialized on the assignment node which had to be overly coupled with the 
previous version of the variable/field accessor nodes.

Store nodes now have two children. The first child is the prefix chain. The second child is the value to 
store. The prefix chain is the set of nodes that represent a.b in the accessor chain of a.b.c. The value 
node can be any value that is legally castable to type of the store node.

Compound assignments are now setup where the value node of a store node is a binary math node. 
The left side of the binary math node is a dup node with a prefix root node as a child. The right side of 
the binary math node is the value node.

Author: jdconrad

modules/lang-painless/src/main/java/org/elasticsearch/painless/ir/AssignmentNode.java

@@ -20,8 +20,6 @@
 package org.elasticsearch.painless.ir;
 
 import org.elasticsearch.painless.ClassWriter;
-import org.elasticsearch.painless.DefBootstrap;
-import org.elasticsearch.painless.Location;
 import org.elasticsearch.painless.MethodWriter;
 import org.elasticsearch.painless.Operation;
 import org.elasticsearch.painless.WriterConstants;
@@ -40,8 +38,8 @@ public class BinaryMathNode extends BinaryNode {
     private Operation operation;
     private Class<?> binaryType;
     private Class<?> shiftType;
-    private boolean cat; // set to true for a String concatenation
-    private boolean originallyExplicit; // record whether there was originally an explicit cast
+    private boolean cat;
+    private int flags;
 
     public void setOperation(Operation operation) {
         this.operation = operation;
@@ -83,17 +81,12 @@ public boolean getCat() {
         return cat;
     }
 
-    public void setOriginallyExplicit(boolean originallyExplicit) {
-        this.originallyExplicit = originallyExplicit;
+    public void setFlags(int flags) {
+        this.flags = flags;
     }
 
-    public boolean getOriginallyExplicit() {
-        return originallyExplicit;
-    }
-
-    @Override
-    public void setLocation(Location location) {
-        super.setLocation(location);
+    public int getFlags() {
+        return flags;
     }
 
     /* ---- end node data, begin visitor ---- */
@@ -147,12 +140,6 @@ protected void write(ClassWriter classWriter, MethodWriter methodWriter, WriteSc
             getRightNode().write(classWriter, methodWriter, writeScope);
 
             if (binaryType == def.class || (shiftType != null && shiftType == def.class)) {
-                // def calls adopt the wanted return value. if there was a narrowing cast,
-                // we need to flag that so that its done at runtime.
-                int flags = 0;
-                if (originallyExplicit) {
-                    flags |= DefBootstrap.OPERATOR_EXPLICIT_CAST;
-                }
                 methodWriter.writeDynamicBinaryInstruction(location,
                         getExpressionType(), getLeftNode().getExpressionType(), getRightNode().getExpressionType(), operation, flags);
             } else {

modules/lang-painless/src/main/java/org/elasticsearch/painless/ir/BinaryMathNode.java

@@ -19,7 +19,11 @@
 
 package org.elasticsearch.painless.ir;
 
-public abstract class BinaryNode extends ExpressionNode {
+import org.elasticsearch.painless.ClassWriter;
+import org.elasticsearch.painless.MethodWriter;
+import org.elasticsearch.painless.symbol.WriteScope;
+
+public class BinaryNode extends ExpressionNode {
 
     /* ---- begin tree structure ---- */
 
@@ -44,4 +48,9 @@ public ExpressionNode getRightNode() {
 
     /* ---- end tree structure ---- */
 
+    @Override
+    protected void write(ClassWriter classWriter, MethodWriter methodWriter, WriteScope writeScope) {
+        leftNode.write(classWriter, methodWriter, writeScope);
+        rightNode.write(classWriter, methodWriter, writeScope);
+    }
 }

modules/lang-painless/src/main/java/org/elasticsearch/painless/ir/BinaryNode.java

@@ -0,0 +1,64 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.painless.ir;
+
+import org.elasticsearch.painless.ClassWriter;
+import org.elasticsearch.painless.MethodWriter;
+import org.elasticsearch.painless.phase.IRTreeVisitor;
+import org.elasticsearch.painless.symbol.WriteScope;
+
+public class DupNode extends UnaryNode {
+
+    /* ---- begin node data ---- */
+
+    private int size;
+    private int depth;
+
+    public void setSize(int size) {
+        this.size = size;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public void setDepth(int depth) {
+        this.depth = depth;
+    }
+
+    public int getDepth() {
+        return depth;
+    }
+
+    /* ---- end node data, begin visitor ---- */
+
+    @Override
+    public <Input, Output> Output visit(IRTreeVisitor<Input, Output> irTreeVisitor, Input input) {
+        return irTreeVisitor.visitDup(this, input);
+    }
+
+    /* ---- end visitor ---- */
+
+    @Override
+    protected void write(ClassWriter classWriter, MethodWriter methodWriter, WriteScope writeScope) {
+        getChildNode().write(classWriter, methodWriter, writeScope);
+        methodWriter.writeDup(size, depth);
+    }
+}

modules/lang-painless/src/main/java/org/elasticsearch/painless/ir/DupNode.java

@@ -21,15 +21,25 @@
 
 import org.elasticsearch.painless.ClassWriter;
 import org.elasticsearch.painless.MethodWriter;
+import org.elasticsearch.painless.phase.IRTreeVisitor;
 import org.elasticsearch.painless.symbol.WriteScope;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 
-public class FlipArrayIndex extends IndexNode {
+public class FlipArrayIndexNode extends UnaryNode {
+
+    /* ---- begin visitor ---- */
+
+    @Override
+    public <Input, Output> Output visit(IRTreeVisitor<Input, Output> irTreeVisitor, Input input) {
+        return irTreeVisitor.visitFlipArrayIndex(this, input);
+    }
+
+    /* ---- end visitor ---- */
 
     @Override
     protected void write(ClassWriter classWriter, MethodWriter methodWriter, WriteScope writeScope) {
-        getIndexNode().write(classWriter, methodWriter, writeScope);
+        getChildNode().write(classWriter, methodWriter, writeScope);
 
         Label noFlip = new Label();
         methodWriter.dup();