More edits to Chpt 1

Add the Evil static global var, with appriopriate comments.  Drop the singleton class, and every place it had to be passed.  Much smaller code now, and will be a LOT smaller as the project grows.

Drop the opcode; minor usages in prior implementations for performance, not needed here.

Use the preview pattern match in test code to simplify.

6 files changed, 47 insertions, 90 deletions

diff --git a/chapter01/src/main/java/com/seaofnodes/simple/Parser.java b/chapter01/src/main/java/com/seaofnodes/simple/Parser.java
index 2feeddf9..4da758b2 100644
--- a/chapter01/src/main/java/com/seaofnodes/simple/Parser.java
+++ b/chapter01/src/main/java/com/seaofnodes/simple/Parser.java
@@ -18,14 +18,8 @@ public class Parser {
      */
     private Token _curTok;
 
-    private final NodeIDGenerator _idGenerator;
-
     private StartNode _startNode;
 
-    public Parser() {
-        _idGenerator = new NodeIDGenerator();
-    }
-
     public StartNode parse(String source) {
         Lexer lexer = new Lexer(source);
         nextToken(lexer);
@@ -33,7 +27,7 @@ public class Parser {
     }
 
     private StartNode parseProgram(Lexer lexer) {
-        _startNode = new StartNode(_idGenerator);
+        _startNode = new StartNode();
         parseReturnStatement(lexer);
         return _startNode;
     }
@@ -49,7 +43,7 @@ public class Parser {
         matchIdentifier(lexer, "return");
         var returnExpr = parseExpression(lexer);
         matchPunctuation(lexer, ";");
-        return new ReturnNode(_idGenerator, _startNode, returnExpr);
+        return new ReturnNode(_startNode, returnExpr);
     }
 
     /**
@@ -109,7 +103,7 @@ public class Parser {
      * </pre>
      */
     private ConstantNode parseIntegerLiteral(Lexer lexer) {
-        var constantNode = new ConstantNode(_idGenerator, _curTok._num.longValue(), _startNode);
+        var constantNode = new ConstantNode(_curTok._num.longValue(), _startNode);
         nextToken(lexer);
         return constantNode;
     }
@@ -159,8 +153,7 @@ public class Parser {
 
         public final Kind _kind;
         /**
-         * String representation of a token - always
-         * populated
+         * String representation of a token - always populated
          */
         public final String _str;
         /**
@@ -189,6 +182,7 @@ public class Parser {
          */
         public static Token EOF = new Token(Kind.EOZ, "", null);
 
+        @Override
         public String toString() {
             return _str;
         }
@@ -236,13 +230,13 @@ public class Parser {
          * Note that EOF is not whitespace!
          */
         private boolean isWhiteSpace(char c) {
-            return c == ' ' ||
-                    c == '\t' ||
-                    c == '\n' ||
-                    c == '\r';
+            return c == ' '  ||
+                   c == '\t' ||
+                   c == '\n' ||
+                   c == '\r';
         }
 
-        private void skipWhitespace() {
+        private void skipWhiteSpace() {
             while (isWhiteSpace(_cur))
                 nextToken();
         }
@@ -296,7 +290,7 @@ public class Parser {
          * Gets the next token
          */
         public Token next() {
-            skipWhitespace();
+            skipWhiteSpace();
             if (_cur == 0)
                 return Token.EOF;
             if (Character.isDigit(_cur))
diff --git a/chapter01/src/main/java/com/seaofnodes/simple/node/ConstantNode.java b/chapter01/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
index 31718a1d..e7a3b3f2 100644
--- a/chapter01/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
+++ b/chapter01/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
@@ -13,8 +13,8 @@ public class ConstantNode extends Node {
 
     public final long _value;
 
-    public ConstantNode(NodeIDGenerator idGenerator, long value, StartNode startNode) {
-        super(idGenerator, OP_CONSTANT, startNode);
+    public ConstantNode(long value, StartNode startNode) {
+        super(startNode);
         _value = value;
     }
 }
diff --git a/chapter01/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter01/src/main/java/com/seaofnodes/simple/node/Node.java
index e78ab19a..bafa58f4 100644
--- a/chapter01/src/main/java/com/seaofnodes/simple/node/Node.java
+++ b/chapter01/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -2,32 +2,14 @@ package com.seaofnodes.simple.node;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
+import java.util.Collections;
 
 /**
  * All Nodes in the Sea of Nodes IR inherit from the Node class.
  * The Node class provides common functionality used by all subtypes.
  * Subtypes of Node specialize by overriding methods.
  */
-public class Node {
-
-    /**
-     * @see StartNode
-     */
-    static final byte OP_START = 1;
-    /**
-     * @see ReturnNode
-     */
-    static final byte OP_RETURN = 2;
-    /**
-     * @see ConstantNode
-     */
-    static final byte OP_CONSTANT = 3;
-
-    /**
-     * The opcode for this node
-     */
-    public final byte _opCode;
+public abstract class Node {
 
     /**
      * Each node has a unique dense Node ID within a compilation context
@@ -40,34 +22,40 @@ public class Node {
      * Inputs to the node. These are use-def references to Nodes.
      * <p>
      * Generally fixed length, ordered, nulls allowed, no unused trailing space.
-     * The first input (offset 0) must be a Control nodes.
+     * Ordering is required because e.g. "a/b" is different from "b/a".
+     * The first input (offset 0) is often a Control node.
      * @see Control
      */
-    public final List<Node> _inputs;
+    public final ArrayList<Node> _inputs;
 
     /**
-     * Outputs reference Nodes that are not null and
-     * have this Node as an input. These nodes are users of this
-     * node, thus these are def-use references to Nodes.
+     * Outputs reference Nodes that are not null and have this Node as an
+     * input.  These nodes are users of this node, thus these are def-use
+     * references to Nodes.
      * <p>
-     * Note that the outputs are derived from inputs, it appears that
-     * outputs are therefore a performance optimization to make it easier to
-     * traverse the graph. The Sea of Nodes documentation in chapter 1 does not
-     * mention these outputs list.
+     
+     * Outputs directly match inputs, making a directed graph that can be
+     * walked in either direction.  These outputs are typically used for
+     * efficient optimizations but otherwise have no semantics meaning.
      */
-    public final List<Node> _outputs;
+    public final ArrayList<Node> _outputs;
+
+    /**
+     * A private Global Static mutable counter, for unique node id generation.
+     * To make the compiler multi-threaded, this field will have to move into a TLS.
+     * Starting with value 1, to avoid bugs confusing node ID 0 with uninitialized values.
+     * */
+    private static int UNIQUE_ID = 1;
 
-    protected Node(NodeIDGenerator idGenerator, byte opCode, Node ...inputs)
-    {
-        _nid = idGenerator.newNodeID(); // allocate unique dense ID
-        _opCode = opCode;
-        _inputs = Arrays.asList(inputs);
+    protected Node(Node ...inputs) {
+        _nid = UNIQUE_ID++; // allocate unique dense ID
+        _inputs = new ArrayList<>();
+        Collections.addAll(_inputs,inputs);
         _outputs = new ArrayList<>();
-        for (int i = 0; i < _inputs.size(); i++) {
-            Node n = _inputs.get(i);
-            if (n != null)
-                n._outputs.add(this);
-        }
+        for( Node n : _inputs ) {
+            if( n != null )
+                n._outputs.add( this );
+      }
     }
 
     /**
@@ -77,17 +65,11 @@ public class Node {
      */
     public Node in(int i) { return _inputs.get(i); }
 
-    public int numInputs() { return _inputs.size(); }
+    public int nIns() { return _inputs.size(); }
 
     public Node out(int i) { return _outputs.get(i); }
 
-    public int numOutputs() { return _outputs.size(); }
-
-    /**
-     * Is this a control node, all control nodes are marked with
-     * the interface Control.
-     */
-    public boolean isControl() { return this instanceof Control; }
+    public int nOuts() { return _outputs.size(); }
 
     /*
      * hashCode and equals implementation to be added in later chapter.
diff --git a/chapter01/src/main/java/com/seaofnodes/simple/node/NodeIDGenerator.java b/chapter01/src/main/java/com/seaofnodes/simple/node/NodeIDGenerator.java
deleted file mode 100644
index 96a292df..00000000
--- a/chapter01/src/main/java/com/seaofnodes/simple/node/NodeIDGenerator.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package com.seaofnodes.simple.node;
-
-/**
- * Nodes are given unique dense ids.
- */
-public class NodeIDGenerator {
-    /**
-     * Counter for node IDs, do not hand out NID 0
-     * (Presumably) because it is used for the control node?
-     */
-    private int nodeIDCounter = 1;
-
-    public int newNodeID() {
-        if (nodeIDCounter > 100000) {
-            throw new RuntimeException("infinite node create loop");
-        }
-        return nodeIDCounter++;
-    }
-}
diff --git a/chapter01/src/main/java/com/seaofnodes/simple/node/ReturnNode.java b/chapter01/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
index 0b62cd4c..eafcab94 100644
--- a/chapter01/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
+++ b/chapter01/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
@@ -10,7 +10,7 @@ package com.seaofnodes.simple.node;
  */
 public class ReturnNode extends Node implements Control {
 
-    public ReturnNode(NodeIDGenerator idGenerator, Node... inputs) {
-        super(idGenerator, OP_RETURN, inputs);
+    public ReturnNode(Node ctrl, Node data) {
+        super(ctrl,data);
     }
 }
diff --git a/chapter01/src/main/java/com/seaofnodes/simple/node/StartNode.java b/chapter01/src/main/java/com/seaofnodes/simple/node/StartNode.java
index 7a9233a8..6944e8fc 100644
--- a/chapter01/src/main/java/com/seaofnodes/simple/node/StartNode.java
+++ b/chapter01/src/main/java/com/seaofnodes/simple/node/StartNode.java
@@ -7,7 +7,7 @@ package com.seaofnodes.simple.node;
  */
 public class StartNode extends Node implements Control {
 
-    public StartNode(NodeIDGenerator idGenerator, Node... inputs) {
-        super(idGenerator, OP_START, inputs);
+    public StartNode(/*arguments go here*/) {
+        super();
     }
 }