Backport changes in Chapter 5 to previous chapters and update Chapter5 documentation (#34)

* Backport changes from chapter 5 to older chapters (#30)

* Fix wrong indent

* Backport to chapter 4

* Backport to chapter 3

* Backport to chapter 2

* Backport to chapter 1

* Add if statement to comment (#32)

* Update visuals for chapters 1,2 & 3.
Reenable drawing of edges from constants to Start for these chapters.

* Update visuals for chapters 4.
Revise text to explain the labeling of edges in graphs and that we omit edge from Constant to Start nodes from chapter 4.

* Add code snippets for if statement parsing and the duplication and merging of ScopeNodes.
Explain how scopeNodes are duplicated and merged.

* Add constant check to minus node (#31)

* Fix closing root block with } (#33)

* Backport fix closing root block with } to chapter 4 and 3 (#35)

* Show use-def edge from Phi to Region as dotted edge.
Add example of Phi peephole.
Update visuals.
Add more examples.

* Fix visuals in chapter 1 and README in chapter 4.

* Remove subheading

* Adjust spaces

---------

Co-authored-by: XmiliaH <45106915+XmiliaH@users.noreply.github.com>

14 files changed, 224 insertions, 188 deletions

diff --git a/chapter02/src/main/java/com/seaofnodes/simple/GraphVisualizer.java b/chapter02/src/main/java/com/seaofnodes/simple/GraphVisualizer.java
index 1af19d80..df128674 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/GraphVisualizer.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/GraphVisualizer.java
@@ -1,9 +1,6 @@
 package com.seaofnodes.simple;
 
-import com.seaofnodes.simple.node.ConstantNode;
-import com.seaofnodes.simple.node.Control;
-import com.seaofnodes.simple.node.Node;
-import com.seaofnodes.simple.node.StartNode;
+import com.seaofnodes.simple.node.*;
 
 import java.util.*;
 
@@ -21,7 +18,10 @@ public class GraphVisualizer {
         Collection<Node> all = findAll(parser);
         StringBuilder sb = new StringBuilder();
         sb.append("digraph chapter02 {\n");
-
+        sb.append("/*\n");
+        sb.append(parser.src());
+        sb.append("\n*/\n");
+        
         // To keep the Scopes below the graph and pointing up into the graph we
         // need to group the Nodes in a subgraph cluster, and the scopes into a
         // different subgraph cluster.  THEN we can draw edges between the
@@ -29,12 +29,19 @@ public class GraphVisualizer {
         // still making the subgraphs DOT gets confused.
         sb.append("\trankdir=BT;\n"); // Force Nodes before Scopes
 
+        // Preserve node input order
+        sb.append("\tordering=\"in\";\n");
+
+        // Merge multiple edges hitting the same node.  Makes common shared
+        // nodes much prettier to look at.
+        sb.append("\tconcentrate=\"true\";\n");
+        
         // Just the Nodes first, in a cluster no edges
         nodes(sb, all);
 
         // Walk the Node edges
         nodeEdges(sb, all);
-
+        
         sb.append("}\n");
         return sb.toString();
     }
@@ -43,13 +50,14 @@ public class GraphVisualizer {
     private void nodes(StringBuilder sb, Collection<Node> all) {
         // Just the Nodes first, in a cluster no edges
         sb.append("\tsubgraph cluster_Nodes {\n"); // Magic "cluster_" in the subgraph name
-        for (Node n : all) {
+        for( Node n : all ) {
             sb.append("\t\t").append(n.uniqueName()).append(" [ ");
+            String lab = n.glabel();
             // control nodes have box shape
             // other nodes are ellipses, i.e. default shape
-            if (n instanceof Control)
+            if( n.isCFG() )
                 sb.append("shape=box style=filled fillcolor=yellow ");
-            sb.append("label=\"").append(n.label()).append("\" ");
+            sb.append("label=\"").append(lab).append("\" ");
             sb.append("];\n");
         }
         sb.append("\t}\n");     // End Node cluster
@@ -58,25 +66,32 @@ public class GraphVisualizer {
 
     // Walk the node edges
     private void nodeEdges(StringBuilder sb, Collection<Node> all) {
-        for( Node n : all )
-            for( Node out : n._inputs )
-                if( out != null ) {
-                    sb.append('\t').append(n.uniqueName()).append(" -> ").append(out.uniqueName());
-                    // Control edges are colored red
-                    if( n instanceof ConstantNode && out instanceof StartNode )
-                sb.append(" [style=dotted]");
-                    else if( n instanceof Control && out instanceof Control )
-                      sb.append(" [color=red]");
-            sb.append(";\n");
+        // All them edge labels
+        sb.append("\tedge [ fontname=Helvetica, fontsize=8 ];\n");
+        for( Node n : all ) {
+            // In this chapter we do display the Constant->Start edge;
+            int i=0;
+            for( Node def : n._inputs ) {
+                if( def != null ) {
+                    // Most edges land here use->def
+                    sb.append('\t').append(n.uniqueName()).append(" -> ");
+                    sb.append(def.uniqueName());
+                    // Number edges, so we can see how they track
+                    sb.append("[taillabel=").append(i);
+                    if( n instanceof ConstantNode && def instanceof StartNode )
+                        sb.append(" style=dotted");
+                    // control edges are colored red
+                    else if( def.isCFG() )
+                        sb.append(" color=red");
+                    sb.append("];\n");
+                }
+                i++;
+            }
         }
     }
-
+    
     /**
-     * Walks the whole graph, starting from Start.
-     * Since Start is the input to all constants - we look at the outputs for
-     * Start, but for then subsequently we look at the inputs of each node.
-     * During graph construction not all nodes are reachable this way, so we
-     * also scan the symbol tables.
+     * Finds all nodes in the graph.
      */
     private Collection<Node> findAll(Parser parser) {
         final StartNode start = Parser.START;
@@ -91,9 +106,12 @@ public class GraphVisualizer {
      */
     private void walk(HashMap<Integer, Node> all, Node n) {
         if (all.get(n._nid) != null) return; // Been there, done that
-            all.put(n._nid, n);
-            for (Node c : n._inputs)
-                if (c != null)
-                    walk(all, c);
+        all.put(n._nid, n);
+        for (Node c : n._inputs)
+            if (c != null)
+                walk(all, c);
+        for (Node c : n._outputs)
+            if (c != null)
+                walk(all, c);
     }
 }
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/Parser.java b/chapter02/src/main/java/com/seaofnodes/simple/Parser.java
index 3ca13c3f..5422ea66 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/Parser.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/Parser.java
@@ -21,29 +21,34 @@ public class Parser {
      */
     public static StartNode START;
 
+    // The Lexer.  Thin wrapper over a byte[] buffer with a cursor.
     private final Lexer _lexer;
 
-    public Parser( String source ) {
+
+    public Parser(String source) {
         _lexer = new Lexer(source);
         Node.reset();
         START = new StartNode();
     }
 
+    String src() { return new String( _lexer._input ); }
+
     public ReturnNode parse() {
         require("return");
-        return parseReturn();
+        return (ReturnNode) parseReturn();
     }
 
     /**
-     * Parses returnStatement; "return" already parsed
+     * Parses a return statement; "return" already parsed.
      *
      * <pre>
      *     'return' expr ;
      * </pre>
+     * @return an expression {@link Node}, never {@code null}
      */
-    private ReturnNode parseReturn() {
-        var expr = require(parseExpression(),";");
-        return new ReturnNode(START, expr);
+    private Node parseReturn() {
+        var expr = require(parseExpression(), ";");
+        return new ReturnNode(START, expr).peephole();
     }
 
     /**
@@ -52,6 +57,7 @@ public class Parser {
      * <pre>
      *     expr : additiveExpr
      * </pre>
+     * @return an expression {@link Node}, never {@code null}
      */
     private Node parseExpression() { return parseAddition(); }
 
@@ -61,11 +67,12 @@ public class Parser {
      * <pre>
      *     additiveExpr : multiplicativeExpr (('+' | '-') multiplicativeExpr)*
      * </pre>
+     * @return an add expression {@link Node}, never {@code null}
      */
     private Node parseAddition() {
         var lhs = parseMultiplication();
-        if( match("+") ) return new AddNode(lhs, parseAddition()).peephole();
-        if( match("-") ) return new SubNode(lhs, parseAddition()).peephole();
+        if (match("+")) return new AddNode(lhs, parseAddition()).peephole();
+        if (match("-")) return new SubNode(lhs, parseAddition()).peephole();
         return lhs;
     }
 
@@ -75,11 +82,12 @@ public class Parser {
      * <pre>
      *     multiplicativeExpr : unaryExpr (('*' | '/') unaryExpr)*
      * </pre>
+     * @return a multiply expression {@link Node}, never {@code null}
      */
     private Node parseMultiplication() {
         var lhs = parseUnary();
-        if( match("*") ) return new MulNode(lhs, parseMultiplication()).peephole();
-        if( match("/") ) return new DivNode(lhs, parseMultiplication()).peephole();
+        if (match("*")) return new MulNode(lhs, parseMultiplication()).peephole();
+        if (match("/")) return new DivNode(lhs, parseMultiplication()).peephole();
         return lhs;
     }
 
@@ -89,9 +97,10 @@ public class Parser {
      * <pre>
      *     unaryExpr : ('-') unaryExpr | primaryExpr
      * </pre>
+     * @return a unary expression {@link Node}, never {@code null}
      */
     private Node parseUnary() {
-        if( match("-") ) return new MinusNode(parseUnary()).peephole();
+        if (match("-")) return new MinusNode(parseUnary()).peephole();
         return parsePrimary();
     }
 
@@ -99,12 +108,13 @@ public class Parser {
      * Parse a primary expression:
      *
      * <pre>
-     *     primaryExpr : integerLiteral
+     *     primaryExpr : integerLiteral | Identifier | '(' expression ')'
      * </pre>
+     * @return a primary {@link Node}, never {@code null}
      */
     private Node parsePrimary() {
         if( _lexer.isNumber() ) return parseIntegerLiteral();
-        if( match("(") )        return require(parseExpression(),")");
+        if( match("(") ) return require(parseExpression(), ")");
         throw errorSyntax("integer literal");
     }
 
@@ -116,7 +126,7 @@ public class Parser {
      * </pre>
      */
     private ConstantNode parseIntegerLiteral() {
-        return (ConstantNode)new ConstantNode(_lexer.parseNumber()).peephole();
+        return (ConstantNode) new ConstantNode(_lexer.parseNumber()).peephole();
     }
 
     //////////////////////////////////
@@ -126,7 +136,7 @@ public class Parser {
     private boolean match(String syntax) { return _lexer.match(syntax); }
 
     // Require an exact match
-    private void require(String syntax) { require(null,syntax); }
+    private void require(String syntax) { require(null, syntax); }
     private Node require(Node n, String syntax) {
         if (match(syntax)) return n;
         throw errorSyntax(syntax);
@@ -135,7 +145,7 @@ public class Parser {
     RuntimeException errorSyntax(String syntax) {
         return error("Syntax error, expected " + syntax + ": " + _lexer.getAnyNextToken());
     }
-    
+
     static RuntimeException error(String errorMessage) {
         return new RuntimeException(errorMessage);
     }
@@ -167,9 +177,9 @@ public class Parser {
         // Very handy in the debugger, shows the unparsed program
         @Override
         public String toString() {
-            return new String(_input,_position,_input.length-_position);
+            return new String(_input, _position, _input.length - _position);
         }
-        
+
         // True if at EOF
         private boolean isEOF() {
             return _position >= _input.length;
@@ -203,12 +213,12 @@ public class Parser {
         // Return true, if we find "syntax" after skipping white space; also
         // then advance the cursor past syntax.
         // Return false otherwise, and do not advance the cursor.
-        boolean match( String syntax ) {
+        boolean match(String syntax) {
             skipWhiteSpace();
             int len = syntax.length();
-            if( _position + len > _input.length ) return false;
-            for( int i = 0; i < len; i++ )
-                if( (char)_input[_position + i] != syntax.charAt(i) )
+            if (_position + len > _input.length) return false;
+            for (int i = 0; i < len; i++)
+                if ((char) _input[_position + i] != syntax.charAt(i))
                     return false;
             _position += len;
             return true;
@@ -216,14 +226,14 @@ public class Parser {
 
         // Used for errors
         String getAnyNextToken() {
-            if( isEOF() ) return "";
-            if( isIdStart(peek()) ) return parseId();
-            if( isPunctuation(peek()) ) return parsePunctuation();
+            if (isEOF()) return "";
+            if (isIdStart(peek())) return parseId();
+            if (isPunctuation(peek())) return parsePunctuation();
             return String.valueOf(peek());
         }
 
-        boolean isNumber() { return isNumber(peek()); }
-        boolean isNumber(char ch) { return Character.isDigit(ch); }
+        boolean isNumber() {return isNumber(peek());}
+        boolean isNumber(char ch) {return Character.isDigit(ch);}
 
         private Type parseNumber() {
             int start = _position;
@@ -231,7 +241,7 @@ public class Parser {
             String snum = new String(_input, start, --_position - start);
             if (snum.length() > 1 && snum.charAt(0) == '0')
                 throw error("Syntax error: integer values cannot start with '0'");
-            return new TypeInteger(Long.parseLong(snum));
+            return TypeInteger.constant(Long.parseLong(snum));
         }
 
         // First letter of an identifier 
@@ -257,8 +267,7 @@ public class Parser {
 
         private String parsePunctuation() {
             int start = _position;
-            if (isPunctuation(nextChar())) ;
-            return new String(_input, start, --_position - start);
+            return new String(_input, start, 1);
         }
     }
 
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/AddNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/AddNode.java
index 015779dc..6784ad60 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/AddNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/AddNode.java
@@ -3,17 +3,16 @@ package com.seaofnodes.simple.node;
 import com.seaofnodes.simple.type.*;
 
 public class AddNode extends Node {
-    public AddNode(Node lhs, Node rhs) {
-        super(null, lhs, rhs);
-    }
+    public AddNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
 
-    @Override
-    public String label() { return "Add"; }
+    @Override public String label() { return "Add"; }
+    
+    @Override public String glabel() { return "+"; }
 
     @Override
-    StringBuilder _print(StringBuilder sb) {
-        in(1)._print(sb.append("("));
-        in(2)._print(sb.append("+"));
+    StringBuilder _print1(StringBuilder sb) {
+        in(1)._print0(sb.append("("));
+        in(2)._print0(sb.append("+"));
         return sb.append(")");
     }
   
@@ -21,8 +20,9 @@ public class AddNode extends Node {
     @Override
     public Type compute() {
         if( in(1)._type instanceof TypeInteger i0 &&
-            in(2)._type instanceof TypeInteger i1 )
-            return new TypeInteger(i0._con + i1._con);
+            in(2)._type instanceof TypeInteger i1 ) {
+            return TypeInteger.constant(i0.value()+i1.value());
+        }
         return TypeBot.BOTTOM;
     }
 
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/ConstantNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
index 99ccf4b5..ec85bf1f 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/ConstantNode.java
@@ -16,22 +16,25 @@ import com.seaofnodes.simple.type.Type;
  * The Constant's value is the value stored in it.
  */
 public class ConstantNode extends Node {
-
+    Type _con;
     public ConstantNode( Type type ) {
         super(Parser.START);
-        _type = type;
+        _con = type;
     }
     
     @Override
-    public String label() { return "Con" + _type; }
+    public String label() { return "#"+_con; }
+  
+    @Override
+    public String uniqueName() { return "Con_" + _nid; }
 
     @Override
-    StringBuilder _print(StringBuilder sb) {
-        return _type._print(sb);
+    StringBuilder _print1(StringBuilder sb) {
+        return _con._print(sb);
     }
     
     @Override
-    public Type compute() { return _type; }
+    public Type compute() { return _con; }
 
     @Override
     public Node idealize() { return null; }
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/Control.java b/chapter02/src/main/java/com/seaofnodes/simple/node/Control.java
deleted file mode 100644
index 48cf2b7a..00000000
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/Control.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package com.seaofnodes.simple.node;
-
-
-/**
- * Control interface is a marker interface to be implemented
- * by Control nodes.
- */
-public interface Control {
-}
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/DivNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/DivNode.java
index 0056c42d..ca7df79c 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/DivNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/DivNode.java
@@ -5,17 +5,16 @@ import com.seaofnodes.simple.type.TypeBot;
 import com.seaofnodes.simple.type.TypeInteger;
 
 public class DivNode extends Node {
-    public DivNode(Node lhs, Node rhs) {
-        super(null, lhs, rhs);
-    }
+    public DivNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Div"; }
+
+    @Override public String glabel() { return "//"; }
 
     @Override
-    public String label() { return "Div"; }
-  
-    @Override
-    StringBuilder _print(StringBuilder sb) {
-        in(1)._print(sb.append("("));
-        in(2)._print(sb.append("/"));
+    StringBuilder _print1(StringBuilder sb) {
+        in(1)._print0(sb.append("("));
+        in(2)._print0(sb.append("/"));
         return sb.append(")");
     }
   
@@ -23,11 +22,9 @@ public class DivNode extends Node {
     public Type compute() {
         if (in(1)._type instanceof TypeInteger i0 &&
             in(2)._type instanceof TypeInteger i1) {
-            if (i0.isConstant() && i1.isConstant())
-                return i1._con == 0
-                    ? TypeInteger.ZERO
-                    : new TypeInteger(i0._con/i1._con);
-            return new TypeInteger(i0._con / i1._con);
+            return i1.value() == 0
+                ? TypeInteger.ZERO
+                : TypeInteger.constant(i0.value()/i1.value());
         }
         return TypeBot.BOTTOM;
     }
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/MinusNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/MinusNode.java
index 7fab83b0..834f4c11 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/MinusNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/MinusNode.java
@@ -5,23 +5,22 @@ import com.seaofnodes.simple.type.TypeBot;
 import com.seaofnodes.simple.type.TypeInteger;
 
 public class MinusNode extends Node {
-    public MinusNode(Node in) {
-        super(null, in);
-    }
+    public MinusNode(Node in) { super(null, in); }
 
-    @Override
-    public String label() { return "Minus"; }
+    @Override public String label() { return "Minus"; }
+  
+    @Override public String glabel() { return "-"; }
   
     @Override
-    StringBuilder _print(StringBuilder sb) {
-        in(1)._print(sb.append("(-"));
+    StringBuilder _print1(StringBuilder sb) {
+        in(1)._print0(sb.append("(-"));
         return sb.append(")");
     }
   
     @Override
     public Type compute() {
         if (in(1)._type instanceof TypeInteger i0)
-            return new TypeInteger(-i0._con);
+            return TypeInteger.constant(-i0.value());
         return TypeBot.BOTTOM;
     }
 
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/MulNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/MulNode.java
index e1a26858..0fa54966 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/MulNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/MulNode.java
@@ -5,25 +5,25 @@ import com.seaofnodes.simple.type.TypeBot;
 import com.seaofnodes.simple.type.TypeInteger;
 
 public class MulNode extends Node {
-    public MulNode(Node lhs, Node rhs) {
-        super(null, lhs, rhs);
-    }
-  
-    @Override
-    public String label() { return "Mul"; }
+    public MulNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
+
+    @Override public String label() { return "Mul"; }
   
+    @Override public String glabel() { return "*"; }
+
     @Override
-    StringBuilder _print(StringBuilder sb) {
-        in(1)._print(sb.append("("));
-        in(2)._print(sb.append("*"));
+    StringBuilder _print1(StringBuilder sb) {
+        in(1)._print0(sb.append("("));
+        in(2)._print0(sb.append("*"));
         return sb.append(")");
     }
-  
+
     @Override
     public Type compute() {
         if (in(1)._type instanceof TypeInteger i0 &&
-                in(2)._type instanceof TypeInteger i1)
-            return new TypeInteger(i0._con * i1._con);
+            in(2)._type instanceof TypeInteger i1) {
+            return TypeInteger.constant(i0.value()*i1.value());
+        }
         return TypeBot.BOTTOM;
     }
 
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter02/src/main/java/com/seaofnodes/simple/node/Node.java
index 7c39083e..dbef984e 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/Node.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -2,8 +2,7 @@ package com.seaofnodes.simple.node;
 
 import com.seaofnodes.simple.type.Type;
 
-import java.util.ArrayList;
-import java.util.Collections;
+import java.util.*;
 
 /**
  * All Nodes in the Sea of Nodes IR inherit from the Node class.
@@ -24,8 +23,7 @@ public abstract class Node {
      * <p>
      * Generally fixed length, ordered, nulls allowed, no unused trailing space.
      * 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
+     * The first input (offset 0) is often a {@link #isCFG} node.
      */
     public final ArrayList<Node> _inputs;
 
@@ -40,6 +38,13 @@ public abstract class Node {
      */
     public final ArrayList<Node> _outputs;
 
+
+    /**
+     * Current computed type for this Node.  This value changes as the graph
+     * changes and more knowledge is gained about the program.
+     */
+    public Type _type;
+
     /**
      * 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.
@@ -47,7 +52,7 @@ public abstract class Node {
      * */
     private static int UNIQUE_ID = 1;
 
-    protected Node(Node ...inputs) {
+    protected Node(Node... inputs) {
         _nid = UNIQUE_ID++; // allocate unique dense ID
         _inputs = new ArrayList<>();
         Collections.addAll(_inputs,inputs);
@@ -55,26 +60,39 @@ public abstract class Node {
         for( Node n : _inputs )
             if( n != null )
                 n._outputs.add( this );
-        // Do an initial type computation
-        _type = compute();
     }
 
+    // Easy reading label for debugger, e.g. "Add" or "Region" or "EQ"
     public abstract String label();
 
+    // Unique label for graph visualization, e.g. "Add12" or "Region30" or "EQ99"
     public String uniqueName() { return label() + _nid; }
 
+    // Graphical label, e.g. "+" or "Region" or "=="
+    public String glabel() { return label(); }
+    
     @Override
     public final String toString() {
         // TODO: This needs a lot of work
-        return uniqueName();
+        return print();
     }
 
     // This is a *deep* print.  This version will fail on cycles, which we will
-    // correct later when we can parse programs with loops.
+    // correct later when we can parse programs with loops.  We print with a
+    // tik-tok style; the common _print0 calls the per-Node _print1, which
+    // calls back to _print0;
     public final String print() {
-        return _print(new StringBuilder()).toString();
+        return _print0(new StringBuilder()).toString();
+    }
+    // This is the common print: check for DEAD and print "DEAD" else call the
+    // per-Node print1.
+    final StringBuilder _print0(StringBuilder sb) {
+        return isDead()
+            ? sb.append(uniqueName()).append(":DEAD")
+            : _print1(sb);
     }
-    abstract StringBuilder _print(StringBuilder sb);
+    // Every Node implements this.
+    abstract StringBuilder _print1(StringBuilder sb);
 
     
     /**
@@ -86,25 +104,21 @@ public abstract class Node {
 
     public int nIns() { return _inputs.size(); }
 
-    /**
-     * Gets the ith output node
-     * @param i Offset of the output node
-     * @return Output node (not null)
-     */
-    public Node out(int i) { return _outputs.get(i); }
-
     public int nOuts() { return _outputs.size(); }
 
+    public boolean isUnused() { return nOuts() == 0; }
+
+    public boolean isCFG() { return false; }
+  
     /**
      * We allow disabling peephole opt so that we can observe the
      * full graph, vs the optimized graph.
      */
     public static boolean _disablePeephole = false;
 
-
     /**
      * Try to peephole at this node and return a better replacement Node if
-     * possible.  We check and replace:
+     * possible.  We compute a {@link Type} and then check and replace:
      * <ul>
      * <li>if the Type {@link Type#isConstant}, we replace with a {@link ConstantNode}</li>
      * <li>in a future chapter we will look for a
@@ -114,19 +128,21 @@ public abstract class Node {
      * </ul>
      */
     public final Node peephole( ) {
+        // Compute initial or improved Type
+        Type type = _type = compute();
+        
         if (_disablePeephole)
             return this;        // Peephole optimizations turned off
 
         // Replace constant computations from non-constants with a constant node
-        Type type = compute();
         if (!(this instanceof ConstantNode) && type.isConstant()) {
             kill();             // Kill `this` because replacing with a Constant
-            return new ConstantNode(type);
+            return new ConstantNode(type).peephole();
         }
 
         // Future chapter: Global Value Numbering goes here
         
-        // Ask each node for a replacement
+        // Ask each node for a better replacement
         Node n = idealize();
         if( n != null ) return n;
         
@@ -134,27 +150,17 @@ public abstract class Node {
     }
 
     /**
-     * Kill a Node with no <em>uses</em>, by setting all of its <em>defs</em>
-     * to null.  This may recursively kill more Nodes and is basically dead
-     * code elimination.  This function is co-recursive with {@link #set_def}.
-     */
-    void kill( ) {
-        assert nOuts()==0;    // Has no uses, so it is dead
-        for( int i=0; i<nIns(); i++ )
-            set_def(i,null);  // Set all inputs to null, recursively killing unused Nodes
-    }
-
-    /**
      * Change a <em>def</em> into a Node.  Keeps the edges correct, by removing
      * the corresponding <em>use->def</em> edge.  This may make the original
      * <em>def</em> go dead.  This function is co-recursive with {@link #kill}.
      *     
      * @param idx which def to set
      * @param new_def the new definition
+     * @return this for flow coding
      */
-    void set_def(int idx, Node new_def ) {
+    Node set_def(int idx, Node new_def ) {
         Node old_def = in(idx);
-        if( old_def == new_def ) return; // No change
+        if( old_def == new_def ) return this; // No change
         // If new def is not null, add the corresponding def->use edge
         // This needs to happen before removing the old node's def->use edge as
         // the new_def might get killed if the old node kills it recursively.
@@ -174,15 +180,26 @@ public abstract class Node {
         }
         // Set the new_def over the old (killed) edge
         _inputs.set(idx,new_def);
+        // Return self for easy flow-coding
+        return this;
     }
-    
-  
     /**
-     * Current computed type for this Node.  This value changes as the graph
-     * changes and more knowledge is gained about the program.
+     * Kill a Node with no <em>uses</em>, by setting all of its <em>defs</em>
+     * to null.  This may recursively kill more Nodes and is basically dead
+     * code elimination.  This function is co-recursive with {@link #set_def}.
      */
-    public Type _type;
-    
+    public void kill( ) {
+        assert isUnused();      // Has no uses, so it is dead
+        for( int i=0; i<nIns(); i++ )
+            set_def(i,null);  // Set all inputs to null, recursively killing unused Nodes
+        _inputs.clear();
+        _type=null;             // Flag as dead
+        assert isDead();        // Really dead now
+    }
+
+    // Mostly used for asserts and printing.
+    boolean isDead() { return isUnused() && nIns()==0 && _type==null; }
+  
     /**
      * This function needs to be
      * <a href="https://en.wikipedia.org/wiki/Monotonic_function">Monotonic</a>
@@ -208,9 +225,4 @@ public abstract class Node {
      * Node unique id generator, and is done as part of making a new Parser.
      */
     public static void reset() { UNIQUE_ID = 1; }
-  
-    /*
-     * hashCode and equals implementation to be added in later chapter.
-     */
-  
 }
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/ReturnNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
index c188ca79..18f5eed9 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/ReturnNode.java
@@ -1,6 +1,6 @@
 package com.seaofnodes.simple.node;
 
-import com.seaofnodes.simple.type.TypeBot;
+import com.seaofnodes.simple.type.*;
 
 /**
  * The Return node has two inputs.  The first input is a control node and the
@@ -11,7 +11,7 @@ import com.seaofnodes.simple.type.TypeBot;
  * <p>
  * The Return's output is the value from the data node.
  */
-public class ReturnNode extends Node implements Control {
+public class ReturnNode extends Node {
 
     public ReturnNode(Node ctrl, Node data) {
         super(ctrl, data);
@@ -24,10 +24,11 @@ public class ReturnNode extends Node implements Control {
     public String label() { return "Return"; }
 
     @Override
-    StringBuilder _print(StringBuilder sb) {
-        return expr()._print(sb.append("return ")).append(";");
+    StringBuilder _print1(StringBuilder sb) {
+        return expr()._print0(sb.append("return ")).append(";");
     }
 
+    @Override public boolean isCFG() { return true; }
   
     @Override
     public TypeBot compute() {
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/StartNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/StartNode.java
index 8d8031bb..08b8333a 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/StartNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/StartNode.java
@@ -3,11 +3,13 @@ package com.seaofnodes.simple.node;
 import com.seaofnodes.simple.type.TypeBot;
 
 /**
- * The Start node represents the start of the function.  For now, we do not have any inputs to Start because our function does not
- * yet accept parameters.  When we add parameters the value of Start will be a tuple, and will require Projections to extract the values.
- * We discuss this in detail in Chapter 9: Functions and Calls.
+ * The Start node represents the start of the function.  For now, we do not
+ * have any inputs to Start because our function does not yet accept
+ * parameters.  When we add parameters the value of Start will be a tuple, and
+ * will require Projections to extract the values.  We discuss this in detail
+ * in Chapter 9: Functions and Calls.
  */
-public class StartNode extends Node implements Control {
+public class StartNode extends Node {
 
     public StartNode(/*arguments go here*/) {
         super();
@@ -17,10 +19,12 @@ public class StartNode extends Node implements Control {
     public String label() { return "Start"; }
 
     @Override
-    StringBuilder _print(StringBuilder sb) {
+    StringBuilder _print1(StringBuilder sb) {
       return sb.append(label());
     }
-  
+
+    @Override public boolean isCFG() { return true; }
+
     @Override
     public TypeBot compute() {
         return TypeBot.BOTTOM;
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/node/SubNode.java b/chapter02/src/main/java/com/seaofnodes/simple/node/SubNode.java
index 2d7db8d3..71d70fa6 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/node/SubNode.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/node/SubNode.java
@@ -5,25 +5,25 @@ import com.seaofnodes.simple.type.TypeBot;
 import com.seaofnodes.simple.type.TypeInteger;
 
 public class SubNode extends Node {
-    public SubNode(Node lhs, Node rhs) {
-        super(null, lhs, rhs);
-    }
+    public SubNode(Node lhs, Node rhs) { super(null, lhs, rhs); }
 
-    @Override
-    public String label() { return "Sub"; }
+    @Override public String label() { return "Sub"; }
+
+    @Override public String glabel() { return "-"; }
 
     @Override
-    StringBuilder _print(StringBuilder sb) {
-        in(1)._print(sb.append("("));
-        in(2)._print(sb.append("-"));
+    StringBuilder _print1(StringBuilder sb) {
+        in(1)._print0(sb.append("("));
+        in(2)._print0(sb.append("-"));
         return sb.append(")");
     }
   
     @Override
     public Type compute() {
         if (in(1)._type instanceof TypeInteger i0 &&
-                in(2)._type instanceof TypeInteger i1)
-            return new TypeInteger(i0._con - i1._con);
+            in(2)._type instanceof TypeInteger i1) {
+            return TypeInteger.constant(i0.value()-i1.value());
+        }
         return TypeBot.BOTTOM;
     }
 
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/type/TypeBot.java b/chapter02/src/main/java/com/seaofnodes/simple/type/TypeBot.java
index 5284884a..bc191241 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/type/TypeBot.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/type/TypeBot.java
@@ -8,7 +8,7 @@ public class TypeBot extends Type {
   
     @Override
     public String toString() { return "Bottom"; }
-  
-    @Override 
+
+    @Override
     public StringBuilder _print(StringBuilder sb) { return sb.append(toString()); }
 }
diff --git a/chapter02/src/main/java/com/seaofnodes/simple/type/TypeInteger.java b/chapter02/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
index 06cac15e..ff6e865b 100644
--- a/chapter02/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
+++ b/chapter02/src/main/java/com/seaofnodes/simple/type/TypeInteger.java
@@ -14,6 +14,8 @@ public class TypeInteger extends Type {
 
     public TypeInteger(long con) { _con = con; }
 
+    public static TypeInteger constant(long con) { return new TypeInteger(con); }
+
     @Override
     public String toString() {
       return _print(new StringBuilder()).toString();
@@ -25,7 +27,7 @@ public class TypeInteger extends Type {
     @Override
     public boolean isConstant() { return true; }
 
-    public long getConstant() { return _con; }
+    public long value() { return _con; }
 
     @Override
     public boolean equals( Object o ) {