Remove a bunch of dead or unused code

12 files changed, 35 insertions, 162 deletions

diff --git a/chapter25/src/main/java/com/seaofnodes/simple/Parser.java b/chapter25/src/main/java/com/seaofnodes/simple/Parser.java
index e87fec35..7f02080e 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/Parser.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/Parser.java
@@ -157,7 +157,7 @@ public class Parser {
     // precise alias update.  ScopeNode treats this as one opaque value.
     private Node mergeAlias(Node bulk, int alias, Node precise) {
         assert bulk != null : "Missing bulk memory for alias #"+alias;
-        MemMergeNode merge = new MemMergeNode(false,null,bulk);
+        MemMergeNode merge = new MemMergeNode(null,bulk);
         merge.alias(alias,precise);
         return peep(merge);
     }
@@ -1254,7 +1254,7 @@ public class Parser {
             Field escaped = field._final ? field : Field.make(field._fname,storage,field._alias,true);
             pub.keep();
             Node esc = new EscapeNode(escaped,self,priv,pub).peephole();
-            MemMergeNode merge = new MemMergeNode(false,null,pub);
+            MemMergeNode merge = new MemMergeNode(null,pub);
             merge.alias(field._alias,esc);
             Node next = merge.peephole();
             pub.unkeep();
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java b/chapter25/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
index cab85e44..68f0ecee 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/BulkMemPhiNode.java
@@ -248,7 +248,7 @@ public class BulkMemPhiNode extends PhiNode {
     // which the bulk has already excluded.  The named alias is newly supplied
     // (or replaces its old slice).
     MemMergeNode aggregate(Node bulk, int alias, Node precise) {
-        MemMergeNode mmm = new MemMergeNode(false,null,bulk);
+        MemMergeNode mmm = new MemMergeNode(null,bulk);
         for( int old = _aliases.nextSetBit(0); old >= 0; old = _aliases.nextSetBit(old+1) )
             if( old != alias )
                 mmm.alias(old,precisePhi(old));
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/FunNode.java b/chapter25/src/main/java/com/seaofnodes/simple/node/FunNode.java
index 419cf083..890a23b0 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/FunNode.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/FunNode.java
@@ -33,11 +33,6 @@ public class FunNode extends RegionNode {
         _compunit = compunit;
     }
     public FunNode( Parser.Lexer loc, TypeFunPtr sig, String name, CompUnit compunit, Node... nodes ) { this(loc,nodes,sig,name,compunit,false); }
-    public FunNode( TypeFunPtr sig, String name, boolean ext ) {
-        this(null,null,sig,name,null,ext);
-        assert ext;             // No need for ext
-        throw Utils.TODO();
-    }
     public FunNode( FunNode fun ) {
         super( fun, fun._loc );
         _sig = fun.sig();
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/LoopNode.java b/chapter25/src/main/java/com/seaofnodes/simple/node/LoopNode.java
index 44ca35d8..90544c00 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/LoopNode.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/LoopNode.java
@@ -58,7 +58,7 @@ public class LoopNode extends RegionNode {
         // Now fold control into the exit.  Might have 1 valid exit, or an
         // XCtrl or a bunch of prior NeverNode exits.
         Node top = ConstantNode.make(Type.TOP).peephole();
-        Node memout = new MemMergeNode(false);
+        Node memout = new MemMergeNode();
         memout.addDef(f); // placeholder for control
         memout.addDef(top);
         for( Node u : _outputs )
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java b/chapter25/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java
index aad3e677..87d982f1 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/MemMergeNode.java
@@ -14,30 +14,18 @@ import java.util.*;
  */
 public class MemMergeNode extends Node {
 
-    /*
-     *  In-Progress is the mutable construction form.  No optimizations are
-     *  allowed.  If not "in progress" then normal peeps work.
-     */
-    public final boolean _inProgress;
-
-    public MemMergeNode( boolean inProgress) { _type = TypeMem.BOT; _inProgress = inProgress; }
-    public MemMergeNode( boolean inProgress, Node ...nodes) { super(nodes); _type = TypeMem.BOT; _inProgress = inProgress; }
-    public MemMergeNode(MemMergeNode mem) { super(mem); _inProgress = false; }
+    public MemMergeNode( Node ...nodes) { super(nodes); _type = TypeMem.BOT; }
+    public MemMergeNode(MemMergeNode mem) { super(mem); }
     @Override public Tag serialTag() { return Tag.MemMerge; }
     public void packed( BAOS baos, HashMap<String,Integer> strs, HashMap<Type,Integer> types, IdentityHashMap<Node, Integer> anodes ) { baos.packed1(nIns()); }
-    static Node make( BAOS bais )  { Node mem = new MemMergeNode(false); mem.setDefX(bais.packed1()-1,null); return mem; }
-
-
-    // The mutable construction form is "in progress"; otherwise this is a
-    // graph-semantic memory merge.
-    boolean inProgress() { return _inProgress; }
+    static Node make( BAOS bais )  { Node mem = new MemMergeNode(); mem.setDefX(bais.packed1()-1,null); return mem; }
 
     @Override public String label() { return "ALLMEM"; }
     @Override public boolean isMem() { return true; }
 
     @Override
     public StringBuilder _print1(StringBuilder sb, BitSet visited) {
-        sb.append(_inProgress ? "Merge[" : "MEM[ ");
+        sb.append("MEM[ ");
         for( int j=2; j<nIns(); j++ ) {
             sb.append(j);
             sb.append(":");
@@ -53,18 +41,6 @@ public class MemMergeNode extends Node {
         return sb.append("]");
     }
 
-    // Make a memory merge: no longer a Scope really, tracking memory state but
-    // not related to the parser in any way.
-    public Node merge() {
-        // Force default memory to not be lazy
-        MemMergeNode merge = new MemMergeNode(false);
-        for( Node n : _inputs )
-            merge.addDef(n);
-        for( int i=1; i<nIns(); i++ )
-            merge._mem(i,null);
-        return merge.peephole();
-    }
-
 
     @Override public Type compute() {
         Type tmem = in(1)._type;
@@ -80,18 +56,13 @@ public class MemMergeNode extends Node {
             // independent and stack.
             for( int i=2; i<nIns(); i++ ) {
                 Node in = in(i);
-                while( true ) {
-                    if( in !=null && in._type.isHigh() )
-                        return TypeMem.TOP;
-                    if( in instanceof MemMergeNode mem ) {
-                        in = mem.in(i);
-                    } else break;
-                }
+                if( in !=null && in._type.isHigh() )
+                    return TypeMem.TOP;
                 if( in instanceof StoreNode st ) {
                     Type val = ((TypeMem)st._type)._t;
                     Field old = ts.field(st._name);
                     // Lazy add an expected field for open structs.
-                    if( old == null && ts._open ) {
+                    if( old==null )  { assert ts._open;
                         old = Field.make(st._name,Type.BOTTOM,st._alias,st._init);
                         ts = ts.add(old);
                     }
@@ -102,39 +73,28 @@ public class MemMergeNode extends Node {
             }
             return TypeMem.makePrivate(ts);
 
-        } else {
-            // Default mixed mem is just BOT
-            TypeMem mem = defmem;
-            boolean progress = true;
-            while( progress ) {
-                progress = false;
-                for( int i=2; i<nIns(); i++ ) {
-                    // Has this alias escaped already?
-                    if( XInt.bit(mem._escAs,i) ) {
-                        Node n = in(i);
-                        if( n != null && !n._type.isHigh() ) {
-                            TypeMem nmem2 = ((TypeMem)n._type).makeFrom(mem._escFs, mem._escAs);
-                            TypeMem mem2 = (TypeMem)mem.meet(nmem2);
-                            // More escape aliases
-                            if( mem2 != mem )
-                                { mem = mem2; progress = true; }
-                        }
-                    }
-                }
+        }
+
+        // Normal public memory; meet across escaped inputs
+        TypeMem mem = defmem;
+        for( int i=2; i<nIns(); i++ ) {
+            // Has this alias escaped?
+            if( XInt.bit(mem._escAs,i) &&
+                in(i) != null && !in(i)._type.isHigh() ) {
+                mem = (TypeMem)mem.meet(in(i)._type);
             }
-            return mem;
         }
+        return mem;
     }
 
     @Override public Node idealize() {
-        if( inProgress() ) return null;
-        if( nIns()==0 ) return null;
+        assert nIns() != 0 && in(1)!=null; // Always have a default.  if( nIns()==0 ) return null;
 
         // Fold defaults into the default
         boolean progress=false, allDefault=true;
         for( int i=2; i<nIns(); i++ ) {
-            if( in(1) == in(i) && in(1) != null ) { setDef(i,null); progress=true; }
-            else                                  { allDefault=false; }
+            if( in(1) == in(i) ) { setDef(i,null); progress=true; }
+            else                 { allDefault=false; }
         }
 
         // If not merging any memory (all memory is just the default)
@@ -170,70 +130,6 @@ public class MemMergeNode extends Node {
 
     public Node alias( int alias, Node st ) { return setDefX(alias,st); }
 
-    // Read or update from memory.
-    // A shared implementation allows us to create lazy phis both during
-    // lookups and updates; the lazy phi creation is part of chapter 8.
-    Node _mem( int alias, Node st ) {
-        // Memory projections are made lazily; if one does not exist
-        // then it must be START.proj(1)
-        Node old = alias(alias);
-        assert !(old instanceof ScopeNode); // Parser lazy memory is handled by ScopeNode
-        // Memory projections are made lazily; expand as needed
-        return st==null ? old : alias(alias,st); // Not lazy, so this is the answer
-    }
-
-    // Remove lazy Phis on all aliases
-    public void removeLazyAll() {
-        for( int i = 1; i < nIns(); i++)
-            _mem(i,null);
-    }
-
-    public void _merge( MemMergeNode that, RegionNode r) {
-        assert _inProgress;
-        int len = Math.max(nIns(),that.nIns());
-        for( int i = 1; i < len; i++)
-            if( alias(i) != that.alias(i) ) { // No need for redundant Phis
-                // If we are in lazy phi mode we need to a lookup
-                // by alias as it will trigger a phi creation
-                Node lhs = this._mem(i,null);
-                Node rhs = that._mem(i,null);
-                alias(i, new MemPhiNode(Parser.memName(i), i, r, lhs, rhs).peephole());
-            }
-    }
-
-    // Fill in the backedge of any inserted Phis.  Keep precise aliases for
-    // what is known at the loop head.  For aliases discovered in the loop
-    // body, gather them into a actual (not inProgress) MemMerge and merge into
-    // the default alias.
-    void _endLoopMem( ScopeNode scope, MemMergeNode back, MemMergeNode exit ) {
-        assert _inProgress && back._inProgress && exit._inProgress;
-        Node exit_def = exit.alias(1);
-        MemMergeNode more = null; // Dont often need the "more discovered" merge, make it lazy
-        int len = Math.max(nIns(),back.nIns());
-        for( int i=2; i<len; i++ ) {
-            if( !(i < this.nIns() && this.in(i)!=null) &&  // Alias is not known to loop head
-                 (i < back.nIns() && back.in(i)!=null) ) { // Alias IS     known to loop back
-                // Gather
-                if( more==null ) {
-                    more = new MemMergeNode(false);
-                    more.alias(1,back.in(1));
-                    back.alias(1,more);
-                }
-                more.alias(i,back.in(i));
-                back.setDef(i,null);
-            }
-        }
-
-        for( int i=1; i<nIns(); i++ ) {
-            if( in(i) instanceof PhiNode phi && phi.region()==scope.ctrl() ) {
-                assert phi.in(2)==null;
-                phi.setDef(2,back.alias(i)==scope ? phi : back.alias(i)); // Fill backedge
-            }
-            if( exit_def == scope ) // Replace a lazy-phi on the exit path also
-                exit.alias(i,in(i));
-        }
-    }
-
     // Now one-time do a useless-phi removal
     void _useless( ) {
         for( int i=1; i<nIns(); i++ ) {
@@ -252,6 +148,6 @@ public class MemMergeNode extends Node {
     }
 
     @Override public boolean eq( Node n ) {
-        return this==n || !_inProgress;
+        return this==n;
     }
 }
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter25/src/main/java/com/seaofnodes/simple/node/Node.java
index 27f41cff..873716da 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/Node.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -141,7 +141,7 @@ public abstract class Node implements Cloneable {
             case StopCU ->   StopCUNode.make(bais);
             case Region->    RegionNode.make(bais);
 
-            default -> throw Utils.TODO();
+            default -> throw Utils.TODO("Should not reach here");
             };
         }
     };
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/ScopeNode.java b/chapter25/src/main/java/com/seaofnodes/simple/node/ScopeNode.java
index dd5fa541..3eabac81 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/ScopeNode.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/ScopeNode.java
@@ -52,7 +52,7 @@ public class ScopeNode extends MemMergeNode {
 
     // A new ScopeNode
     public ScopeNode() {
-        super(true);
+        super();
         _vars   = new Ary<>(Var .class);
         _kinds  = new Ary<>(Kind.class);
         _guards = new Ary<>(Node.class);
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/node/StoreNode.java b/chapter25/src/main/java/com/seaofnodes/simple/node/StoreNode.java
index 04fbc781..baf983f3 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/node/StoreNode.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/node/StoreNode.java
@@ -157,7 +157,7 @@ public class StoreNode extends MemOpNode {
             }
             MemMergeNode mmm = mem() instanceof BulkMemPhiNode bulk
                 ? bulk.aggregate(mem(),fld._alias,st)
-                : new MemMergeNode(false,null,mem());
+                : new MemMergeNode(null,mem());
             if( !(mem() instanceof BulkMemPhiNode) )
                 mmm.alias(fld._alias,st);
             return mmm.init();
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/type/Type.java b/chapter25/src/main/java/com/seaofnodes/simple/type/Type.java
index fbbfbada..39203a09 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/type/Type.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/type/Type.java
@@ -343,9 +343,6 @@ public class Type /*implements Cloneable*/ {
     // Make a zero version of this type, 0 for integers and null for pointers.
     public Type makeZero() { return Type.NIL; }
 
-    //// Is forward-reference
-    //public boolean isFRef() { return false; }
-
     // Cap at limits
     public Type oob() { return isHigh() ? TOP : BOTTOM; }
 
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMem.java b/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMem.java
index 106dee49..dbcc9056 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMem.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMem.java
@@ -79,7 +79,6 @@ public class TypeMem extends Type {
     // Make a private memory
     public static TypeMem makePrivate(Type t) { return make(1,t,true,false,false,escapeFIDX(XInt.EMPTY,t), escapeAlias(XInt.EMPTY,t)); }
 
-    public TypeMem makeFrom(Type t) { return make(_alias,t,_one,_clz,_final,_escFs,_escAs); }
     public TypeMem makeFrom(int alias) { return make(alias,_t,_one,_clz,_final,_escFs,_escAs); }
     public TypeMem makeFrom(int[] fidxes, int[] aliases) {
         return make(_alias,_t,_one,_clz,_final,fidxes,aliases);
@@ -92,10 +91,6 @@ public class TypeMem extends Type {
     public TypeMem escapesFrom(Type t) {
         return make(_alias,_t,_one,_clz,_final, escapeFIDX(_escFs,t), escapeAlias(_escAs,t));
     }
-    // Existing escapes plus `t` escapes
-    public TypeMem escapesFrom(int alias, Type t) {
-        return make(alias,t,_one,_clz,_final, escapeFIDX(_escFs,t), escapeAlias(_escAs,t));
-    }
     public TypeMem escapesAliases(Type t) {
         return make(_alias,_t,_one,_clz,_final, _escFs, escapeAlias(_escAs,t));
     }
@@ -146,7 +141,7 @@ public class TypeMem extends Type {
         TypeMem d = malloc(_alias,null,!_one,!_clz,!_final, XInt.dual(_escFs), XInt.dual(_escAs));
         (_dual = d)._dual = this; // Cross link duals
         d._t = _t._terned ? _t.dual() : _t.rdual();
-        if( d._alias==1 && !d._one && !d._t.isHigh() ) d._final = false;
+        if( d._alias==1 && !d._one ) { assert !d._t.isHigh(); d._final = false; }
         return d;
     }
 
@@ -154,8 +149,8 @@ public class TypeMem extends Type {
     @Override public boolean isHigh() { return _t.isHigh(); }
     @Override boolean _isConstant() { return _one && _clz && _alias!= 1 && _t._isConstant(); }
     @Override public int log_size() { throw Utils.TODO("Should not reach here: memory has no scalar storage size"); }
-    @Override boolean _isFinal() { return _t._isFinal(); }
-    @Override TypeMem _makeStorage() { return make(_alias,_t._makeStorage(),_one,_clz,_final,_escFs,_escAs); }
+    @Override boolean _isFinal() { throw Utils.TODO("Should not reach here"); }
+    @Override TypeMem _makeStorage() { throw Utils.TODO("Should not reach here"); /*return make(_alias,_t._makeStorage(),_one,_clz,_final,_escFs,_escAs);*/ }
 
     @Override TypeMem _close( String name, HashMap<String, Type> TYPES ) { return malloc(_alias,_t._close(name, TYPES ),_one,_clz,_final,_escFs,_escAs); }
 
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java b/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
index 5a2693c9..5b9cf7e1 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/type/TypeMemPtr.java
@@ -73,7 +73,6 @@ public class TypeMemPtr extends TypeNil {
     /** Public-memory shape: nullable and non-singleton, preserving the referent. */
     @Override TypeMemPtr _makeStorage() { return make((byte)3,_obj._makeStorage(),false,true); }
     @Override TypeMemPtr makeFrom(byte nil) { return nil==_nil ? this : make(nil, _obj, _one, _pub); }
-    public TypeMemPtr makeHigh(byte nil) { return make(nil,_obj.makeHigh(),false); }
     @Override public Type nonZero() { return makeFrom((byte)(_nil <= 1 ? 1 : 2)); }
 
     // An abstract pointer, pointing to either a Struct or an Array.
diff --git a/chapter25/src/main/java/com/seaofnodes/simple/type/TypeStruct.java b/chapter25/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
index e2011b38..a32e812c 100644
--- a/chapter25/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
+++ b/chapter25/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
@@ -151,18 +151,11 @@ public class TypeStruct extends Type {
                     Field.make("[con]",con       ,bodyAlias,true));
     }
 
-    public TypeStruct makeHigh() {
-        Field[] fs = new Field[_fields.length];
-        for( int i=0; i<_fields.length; i++ )
-            fs[i] = _fields[i].makeFrom(Type.TOP);
-        return make(_name,_open,_fref,fs);
-    }
-
     public TypeStruct makeInit() {
         Field[] fs = new Field[_fields.length];
         for( int i=0; i<_fields.length; i++ ) {
             Type zero = _fields[i]._t.makeZero();
-            fs[i] = _fields[i].makeFrom(_fields[i]._t != Type.BOTTOM && _fields[i]._t != Type.TOP && zero.isa(_fields[i]._t) ? zero : Type.TOP);
+            fs[i] = _fields[i].makeFrom(_fields[i]._t != Type.BOTTOM && zero.isa(_fields[i]._t) ? zero : Type.TOP);
         }
         return make(_name,_open,_fref,fs);
     }
@@ -202,7 +195,7 @@ public class TypeStruct extends Type {
         TypeStruct ts = (TypeStruct)VISIT.get(namePlusFinal);
         if( ts!=null ) return ts;
         TypeStruct base = name==null ? (TypeStruct)TYPES.get(_name) : this;
-        if( base == null ) base = this;
+        assert base != null;
         boolean open = base._fref ? base._open : name != _name && name != null && _open;
         ts = base.recurPre(namePlusFinal, _name, open, base._fref );
         Field[] flds = ts._fields;
@@ -404,11 +397,9 @@ public class TypeStruct extends Type {
     }
 
     @Override boolean _isConstant() {
-        if( VISIT.containsKey(_uid) ) return true; // Cycles assume constant
+        assert !_open; // who is asking about constant open structs? if( _open ) return false; // Infinite BOT fields
+        assert !VISIT.containsKey(_uid); //expect constants to not include self-cycles.  if( VISIT.containsKey(_uid) ) return true; // Cycles assume constant
         VISIT.put(_uid,this);
-        if( _open ) return false; // Infinite BOT fields
-        // Special case for constant arrays
-
         // Check all fields for being constant
         for( Field field : _fields )
             if( !field._isConstant() )