From 8f460340cfe01a4945635251bcd33b257b699bf7 Mon Sep 17 00:00:00 2001
From: Cliff Click <cliffc@acm.org>
Date: Thu, 5 Nov 2026 15:51:41 -0800
Subject: Remove a bunch of extra graph walks pre-Opto

Removed most; moved a few into Opto setup pass.
Lots of modest bug fixes
---
 .../simple/codegen/ClassInitDependencies.java      |  4 +-
 .../com/seaofnodes/simple/codegen/CodeGen.java     | 30 ++++++---
 .../java/com/seaofnodes/simple/codegen/Iter.java   | 60 ++----------------
 .../com/seaofnodes/simple/codegen/IterPeeps.java   |  2 +-
 .../java/com/seaofnodes/simple/codegen/Opto.java   | 73 ++++++++++++++++++----
 .../com/seaofnodes/simple/codegen/ParseAll.java    | 43 -------------
 .../com/seaofnodes/simple/codegen/RegAlloc.java    | 19 +++++-
 .../com/seaofnodes/simple/codegen/TypeCheck.java   | 28 ++++++---
 .../com/seaofnodes/simple/node/CLInitNode.java     |  5 +-
 .../java/com/seaofnodes/simple/node/CallNode.java  | 26 +++-----
 .../com/seaofnodes/simple/node/ConstructNode.java  | 52 +++++++++++++--
 .../com/seaofnodes/simple/node/ConvertNode.java    |  1 +
 .../com/seaofnodes/simple/node/EscapeNode.java     |  8 ++-
 .../java/com/seaofnodes/simple/node/FRefNode.java  |  2 +
 .../com/seaofnodes/simple/node/FldOffNode.java     |  8 +--
 .../java/com/seaofnodes/simple/node/FunNode.java   | 15 +++--
 .../seaofnodes/simple/node/GlobalEscapeNode.java   | 11 +---
 .../java/com/seaofnodes/simple/node/LoadNode.java  | 28 +++++++--
 .../java/com/seaofnodes/simple/node/MulNode.java   |  2 +-
 .../main/java/com/seaofnodes/simple/node/Node.java |  6 +-
 .../java/com/seaofnodes/simple/node/ParmNode.java  | 13 +---
 .../java/com/seaofnodes/simple/node/PhiNode.java   | 43 ++++++++++---
 .../com/seaofnodes/simple/node/PtrToIntNode.java   |  2 +
 .../com/seaofnodes/simple/node/StopCUNode.java     | 52 ++++-----------
 .../java/com/seaofnodes/simple/node/StoreNode.java | 15 +++--
 .../com/seaofnodes/simple/node/ToFloatNode.java    |  2 +
 .../com/seaofnodes/simple/node/ToIntegerNode.java  |  2 +
 .../com/seaofnodes/simple/parser/Allocations.java  | 17 +++--
 .../com/seaofnodes/simple/parser/Construction.java | 69 ++++----------------
 .../com/seaofnodes/simple/parser/Functions.java    |  5 +-
 .../java/com/seaofnodes/simple/parser/Parser.java  |  1 -
 .../java/com/seaofnodes/simple/parser/README.md    |  4 +-
 .../com/seaofnodes/simple/parser/References.java   | 23 +++----
 .../java/com/seaofnodes/simple/parser/Structs.java | 43 ++-----------
 .../java/com/seaofnodes/simple/type/TypeMem.java   | 10 +++
 .../com/seaofnodes/simple/type/TypeStruct.java     | 10 ++-
 36 files changed, 365 insertions(+), 369 deletions(-)

(limited to 'chapter29/src/main/java/com')

diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/ClassInitDependencies.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/ClassInitDependencies.java
index 3547b86c..9c954197 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/ClassInitDependencies.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/ClassInitDependencies.java
@@ -100,7 +100,9 @@ public class ClassInitDependencies {
 
             // CLInit adds a class init requirement to this function
             // (plus all parent classes)
-            if( cfg instanceof CLInitNode init ) {
+            // An invalid receiver can still be Scalar.BOT here. Its Load
+            // reports the error at TypeCheck; it does not name a class to init.
+            if( cfg instanceof CLInitNode init && init.cu()!=null ) {
                 FunNode clz = code.link(init.cu()); // <clinit> referred to
                 iset.put(clz.sig().fidx(),1);       // Add to edge set
                 if( sites!=null && sites.atX(clz.sig().fidx())==null ) sites.setX(clz.sig().fidx(),init._loc);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java
index 6e1c0af5..ba7c0c1d 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/CodeGen.java
@@ -102,11 +102,10 @@ public class CodeGen {
     }
 
     private void gatherPublicFields(TypeStruct clz, boolean classFields) {
-        boolean hasCtor = clz.field("<ctor>") != null;
         for( Field fld : clz._fields ) {
-            // With a user constructor, class:N.N is the private <init>.
+            // Private-memory helpers are reached through their allocator.
             if( fld._fname.charAt(0)=='_' || fld._t==Type.TOP ||
-                (hasCtor && clz.hiddenInit(fld)) ) continue;
+                clz.hiddenInit(fld) ) continue;
             if( classFields ) _publicAliases = XInt.make(_publicAliases,fld._alias);
             if( fld._t instanceof TypeFunPtr tfp )
                 _publicFIDXs = XInt.meet(_publicFIDXs,tfp._fidxs);
@@ -125,14 +124,13 @@ public class CodeGen {
     }
 
     private int[] _publicFIDXs, _publicAliases;
+    private TypeMem _publicEscapes;
 
     /**
-     * Collect every possible public escape - after ParseAll is done - in case
-     * some code calls a generic function.  Example:
-     *     var apply = = { {int->int} f, int x -> f(x); };  // Generic apply() call
-     * The CallEnd from `f(x)` has to use generic TypeMem.BOT, which
-     * immediately escapes *everything* including known private functions.
-     * As weak as this is, its still sharper than "everything".
+     * Snapshot the public interface after ParseAll for interface checks and
+     * the default escapes of opaque external types. This is not an upper
+     * bound on all escapes: a public function can return a private object or
+     * callback. Escape flow preserves those actual values separately.
      */
     void freezePublicInterface() {
         assert _publicFIDXs==null && _publicAliases==null;
@@ -157,12 +155,21 @@ public class CodeGen {
                 fidxs = XInt.make(fidxs,fidx);
         }
         _publicFIDXs = fidxs;
+        _publicEscapes = TypeMem.START.makeFrom(_publicFIDXs,_publicAliases);
     }
 
     public int[] publicFIDXs()  { assert _publicFIDXs !=null; return _publicFIDXs;  }
     public int[] publicAliases(){ assert _publicAliases!=null; return _publicAliases; }
     public boolean publicInterfaceFrozen() { return _publicFIDXs != null; }
 
+    // Before Opto upgrades the IR, a forward reference might still name a
+    // local class. Afterwards, unresolved names describe external objects.
+    public TypeMem publicEscapes() {
+        if( _phase==null || _phase.ordinal()<Phase.Opto.ordinal() ) return TypeMem.BOT;
+        assert _publicEscapes!=null;
+        return _publicEscapes;
+    }
+
     // ---------------------------
 
     // Very common nodes, cached here
@@ -428,7 +435,12 @@ public class CodeGen {
     // being called.
     public void link(FunNode fun) {
         int fidx = fun.sig().fidx();
+        FunNode old = _linker.atX(fidx);
+        if( old!=null && old!=fun ) old.moveDepsToWorklist();
         _linker.setX(fidx,fun);
+        // Calls waiting for an unloaded target depend on Start until there
+        // is a FunNode to depend on. Installing a body lets them retry.
+        if( _start!=null ) _start.moveDepsToWorklist();
         add(_globalEscapes); // A new or replacement summary may expose escapes.
     }
 
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/Iter.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/Iter.java
index 1f53d3e4..35bc62ac 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/Iter.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/Iter.java
@@ -11,57 +11,14 @@ public abstract class Iter {
         assert code._globalEscapes==null;
         code._globalEscapes = new GlobalEscapeNode();
         code._start.setDef(2,code._globalEscapes);
-        // The phase shift closes all parser-in-progress states and freezes
-        // unknown external inputs.  Imported nodes carry post-Opto escape
-        // precision, but Iter is a fresh pessimistic solve: memory escape
-        // summaries must restart at FULL so newly discovered private escapes
-        // can only be removed, never added.  Seed the complete graph once.
-        boolean hasImports = code._externPaths != null;
-        code._start.walk(n -> {
-            // Type import can reconcile a constant's declaration.
-            n._type = n instanceof ConstantNode ? n.compute()
-                : hasImports ? iterImportReset(n._type) : iterEscapeReset(n._type);
-            code.add(n);
-            return null;
-        });
+        // Parsing queues initialized nodes and phase-sensitive peepholes.
+        // Only the new escape summary needs seeding here.
+        code.add(code._globalEscapes);
         code._iter.iterate(code);
         // Expensive assert.
         assert !CodeGen.expensiveAssert() || Opto.fixedPointCheck(code);
     }
 
-    // Stabilize existing node types before releasing source error obligations.
-    // No rewrites: even an unused illegal Load must still be checked here.
-    public static void types(CodeGen code) {
-        // Definite initialization needs the optimistic solution around loops:
-        // an unchanged initialized field must not be stuck at its old BOT seed.
-        Ary<Node> typed = new Ary<>(Node.class);
-        code._start.walk(n -> { typed.add(n); n._type = Type.TOP; code.add(n); return null; });
-        Node n;
-        while( (n = code._iter._work.pop())!=null ) {
-            if( n.isDead() ) continue;
-            Type t = n._type.meet(n.compute());
-            if( t==n._type ) continue;
-            n._type = t;
-            code.addAll(n._outputs);
-            n.moveDepsToWorklist();
-        }
-        code.addAll(typed);
-    }
-
-    private static Type iterEscapeReset(Type t) {
-        if( t instanceof TypeMem mem )
-            return mem._one ? mem : mem.makeFrom(XInt.FULL,XInt.FULL);
-        if( t instanceof TypeTuple tt ) {
-            TypeTuple rez = tt;
-            for( int i=0; i<tt._types.length; i++ ) {
-                Type tx = iterEscapeReset(tt._types[i]);
-                if( tx != tt._types[i] ) rez = rez.makeFrom(i,tx);
-            }
-            return rez;
-        }
-        return t;
-    }
-
     private static Type iterImportReset(Type t) {
         if( t.isHigh() )
             return t.dual();
@@ -88,18 +45,13 @@ public abstract class Iter {
         for( Node n : nodes )
             if( !n.isDead() )
                 n._type = n instanceof ConstantNode ? n.compute() : iterImportReset(n._type);
-        // Stop normalizes unknown memory into the unit's visible escapes.
-        // Do not publish a transient FULL Stop merely because we reset its body.
-        for( Node n : nodes )
-            if( n instanceof StopCUNode && !n.isDead() ) n._type = n.compute();
         code.addAll(nodes);
         repair(code);
     }
 
-    // Repair the monotonicity assert after loading new nodes (from a file via
-    // Serialize).  Only widening types here makes it safe to resume the usual
-    // lifting peeps.  The worklist already contains changed edges and their
-    // neighbors.
+    // Loading a body or linking a call changes the graph and can widen
+    // existing bounds. Repair only queued nodes and affected neighbors before
+    // resuming the usual lifting peeps; this does not walk the graph.
     public static void repair(CodeGen code) {
         // Gather changes for a normal IterPeeps once the graph has its
         // monotonicity property back.
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java
index 543a69df..985cd4d2 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/IterPeeps.java
@@ -165,7 +165,7 @@ public class IterPeeps {
         Node changed = code._stop.walk( n -> {
             // Ignore most in-progress things
             if( n.iskeep() ) return null;
-            // Types must be forwards, even if on the worklist.
+            // Types must lift, even if on the worklist.
             Type nval = n.compute();
             assert nval.isa(n._type) : "Non-monotonic peep: "+n+"#"+n._nid+" old="+n._type+" new="+nval+" inputs="+inputTypes(n)+" peep="+n;
             if( list.on(n) )
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/Opto.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/Opto.java
index aa997204..0c37ce39 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/Opto.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/Opto.java
@@ -1,6 +1,7 @@
 package com.seaofnodes.simple.codegen;
 
 import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.parser.Parser;
 import com.seaofnodes.simple.codegen.IterPeeps.WorkList;
 import com.seaofnodes.simple.type.*;
 import com.seaofnodes.simple.util.Ary;
@@ -30,7 +31,8 @@ abstract public class Opto {
         WorkList<Node> deps = new WorkList<>();
         WorkList<Node> changes = new WorkList<>();
         Ary<Node> modes = new Ary<>(Node.class);
-        resetToTop(code,oldTypes,modes,deps);
+        Ary<ReturnNode> returns = new Ary<>(ReturnNode.class);
+        resetToTop(code,oldTypes,modes,deps,returns);
         unlinkStart(code);
 
         // OPTIMISTIC INTERPROCEDURAL SCCP
@@ -50,24 +52,73 @@ abstract public class Opto {
         // After SCCP add everything changed to the worklist and see if
         // peepholes can make more progress.
         moveChangesToWorklist(code, oldTypes, changes);
+        // Unknown callers and concrete call edges have now been rediscovered.
+        for( ReturnNode ret : returns ) code.add(ret.unkeep());
     }
 
-    // Reset Types before running the worklist algorithm
-    private static void resetToTop(CodeGen code, Ary<Type> oldTypes, Ary<Node> modes, WorkList<Node> deps ) {
+    // Transition from Iter's pessimistic graph to SCCP's optimistic solve in
+    // one walk. Parsing has closed the named types; install them in the IR
+    // and resolve forward references before resetting each value to TOP.
+    // Do not run peepholes here: neighboring nodes may not yet be upgraded or
+    // reset. SCCP sees the completed setup, and IterPostOpto handles rewrites.
+    //
+    // The same walk preserves Returns while call edges are rebuilt, remembers
+    // old types for incremental cleanup, and gathers numeric modes and phase
+    // dependencies. These are setup duties, not separate graph passes.
+    private static void resetToTop(CodeGen code, Ary<Type> oldTypes, Ary<Node> modes, WorkList<Node> deps, Ary<ReturnNode> returns ) {
         code._start.walk( x -> {
+                // A snapshot for change detection, not an upper bound: closing
+                // recursive declarations can change types in either direction.
+                oldTypes.setX(x._nid,x._type);
+                if( x.upgradeType(Parser.TYPES) ) deps.push(x);
+                if( x instanceof FRefNode fref ) resolveForward(code,fref);
+                // Rebuilding call edges must not DCE a temporarily uncalled body.
+                // Type-level function references can rediscover it later in SCCP.
+                if( x instanceof ReturnNode ret ) returns.add(ret.keep());
                 // Opto ends Parm.inProgress(), enabling constant folding even
                 // when a parameter's type was already constant before SCCP.
                 if( x instanceof ParmNode && x._type.isHighOrConst() ) deps.push(x);
+                // Construction identities may fold after the optimistic solve.
+                // Adds may need sorting after imported node IDs were assigned.
+                if( x instanceof ConstructNode || x instanceof AddNode ) deps.push(x);
                 // SCCP adds call edges and default arguments, not numeric
                 // operations. Gather unresolved modes on this required walk.
                 if( x instanceof ModeNode mode && mode.mode()==0 ) modes.push(x);
-                oldTypes.setX(x._nid,x._type); // Compare the final SCCP type with Iter's type
                 x._type = Type.TOP;            // Reset all Nodes to TOP
                 code._iter.add(x); // Visit everybody at least once; most Nodes produce better than TOP
                 return null;
             } );
     }
 
+    private static void resolveForward(CodeGen code, FRefNode fref) {
+        if( fref.nIns()!=1 ) return;
+        boolean alloc = fref._name.endsWith(".<new>");
+        String clzName = alloc
+            ? fref._name.substring(0,fref._name.length()-".<new>".length()).intern()
+            : fref._name;
+        TypeStruct clz = (TypeStruct)Parser.TYPES.get(clzName);
+        if( clz==null ) return;
+        Node con;
+        if( alloc ) {
+            Field ctor = clz.field("<new>");
+            if( ctor==null || !(ctor._t instanceof TypeFunPtr tfp) ) {
+                String name = clzName.startsWith(TypeStruct.CLZ)
+                    ? clzName.substring(TypeStruct.CLZ.length()) : clzName;
+                int dot = name.lastIndexOf('.');
+                throw Parser.error("Unknown struct type '"+(dot==-1 ? name : name.substring(dot+1))+"'",fref._loc);
+            }
+            FunNode fun = code._link(tfp);
+            if( fun==null ) return;
+            con = new FunPtrNode(tfp,code._start,fun.ret());
+            con._type = Type.BOTTOM; // No Iter bound; the Return may already be reset.
+        } else {
+            con = new ConstantNode(TypeMemPtr.make((byte)2,clz,true));
+        }
+        // The new input is visited by the reset walk too. Let SCCP propagate
+        // its value; replacing the FRef is a later peephole.
+        fref.addDef(con);
+    }
+
 
     // Only entry initializers start with unknown callers. Discover every
     // other function through calls or escaping values during SCCP.
@@ -90,8 +141,9 @@ abstract public class Opto {
                     // Unhook from Stop without treating the ReturnNode as
                     // DEAD.  It stays in limbo until Opto links when a caller
                     // is discovered (or not, and the function is really dead).
-                    stop._inputs.del(i--);
-                    ret.delUse(stop);
+                    // The reset walk keeps Returns alive. Use normal edge
+                    // editing so cleanup also revisits an emptied StopCU.
+                    stop.delDef(i--);
                 }
                 // Unlink the existing conservative call linkages.
                 for( int j=1; j<fun.nIns(); j++ )
@@ -133,10 +185,10 @@ abstract public class Opto {
         TypeMem tmem = (TypeMem)tt._types[1];
         int[] fidxs = tmem._escFs;
         if( XInt.isHigh(fidxs) ) {
-            // A scalar BOTTOM can flow into memory while compiling an error
-            // program.  It exposes all public functions, not private fields.
+            // Unknown values can later refine to private callbacks too.
+            // FULL must cover every live target, just like the finite case.
             for( FunNode fun : code._linker )
-                if( fun != null && code.publicFIDX(fun.sig().fidx()) )
+                if( fun != null && !fun.isDead() )
                     linkStart(code,fun);
             return;
         }
@@ -184,8 +236,6 @@ abstract public class Opto {
             if( nval!=oldTypes.atX(n._nid) || n.isUnlocked() ) changes.push(n);
             if( oval == nval ) continue;
             assert oval.isa(nval) : "Non-monotonic SCCP: "+n.getClass().getSimpleName()+"#"+n._nid+" "+n+" old="+oval+" new="+nval;    // Types start high and always fall
-            Type pesiVal = oldTypes.atX(n._nid);
-            assert pesiVal==null || nval.isa(pesiVal) : "SCCP below pessimistic type: "+n.getClass().getSimpleName()+"#"+n._nid+" "+n+" pessimistic="+pesiVal+" new="+nval; // Never fall worse than the pessimistic pass
             n._type = nval;
 
             // Now we have a series of stanzas where we lazily create the Call
@@ -267,7 +317,6 @@ abstract public class Opto {
             if( n.isDead() ) continue;
             assert n.compute() == n._type; // Hit the fixed point.
             Type old = oldTypes.atX(n._nid);
-            assert old==null || n._type.isa(old);
             if( n._type!=old || n.isUnlocked() ) {
                 code.addAll(n);
                 code.addAll(n._outputs);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/ParseAll.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/ParseAll.java
index 2958332b..b77b224c 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/ParseAll.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/ParseAll.java
@@ -119,52 +119,9 @@ public abstract class ParseAll {
             if( cu._ext==null )
                 cu._clz = (TypeStruct)Parser.TYPES.get(TypeStruct.addClzPrefix(cu._cname));
 
-        // Walk over all Nodes, and upgrade the internal constants to the
-        // closed-over types.
-        code._stop.walk( (Node n) -> {
-                n.upgradeType(Parser.TYPES);
-                if( n instanceof FRefNode fref ) {
-                    boolean alloc = fref._name.endsWith(".<new>");
-                    String clzName = alloc
-                        ? fref._name.substring(0,fref._name.length()-".<new>".length()).intern()
-                        : fref._name;
-                    TypeStruct clz = (TypeStruct)Parser.TYPES.get(clzName);
-                    if( clz == null )
-                        return null;
-                    Node con;
-                    if( alloc ) {
-                        Field ctor = clz.field("<new>");
-                        if( ctor == null || !(ctor._t instanceof TypeFunPtr tfp) ) {
-                            String name = clzName.startsWith(TypeStruct.CLZ)
-                                ? clzName.substring(TypeStruct.CLZ.length()) : clzName;
-                            int dot = name.lastIndexOf('.');
-                            throw Parser.error("Unknown struct type '"+(dot==-1 ? name : name.substring(dot+1))+"'",fref._loc);
-                        }
-                        FunNode fun = code.link(tfp);
-                        if( fun == null ) return null;
-                        con = new FunPtrNode(tfp,code._start,fun.ret()).peephole();
-                    } else {
-                        // Class pointer constant:
-                        TypeMemPtr clzptr = TypeMemPtr.make((byte)2,clz,true);
-                        con = code.con(clzptr);
-                    }
-                    // Replace and optimize
-                    fref.addDef(con);
-                    code.add(fref);
-                }
-                // Adds sort by NIDs, which just got shuffled
-                if( n instanceof AddNode add )
-                    code.add(add);
-                // All imported bodies are loaded; link them before Iter checks types.
-                if( n instanceof CallNode call && !NEEDS_LOAD.isEmpty() )
-                    code.add(call).idealize();
-                return null;
-            } );
-
         // The complete public interface is now known.  Keep this independent
         // of later graph/linker liveness so SCCP computations remain local and
         // monotonic.
-        code.P.checkConstruction();
         code.freezePublicInterface();
     }
 
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
index ac792988..f1aa18ef 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/RegAlloc.java
@@ -425,6 +425,21 @@ public class RegAlloc {
         Node[] conflicts = lrg._selfConflicts.keySet().toArray(new Node[0]);
         Arrays.sort(conflicts, (x,y) -> x._nid - y._nid );
 
+        // A commutative two-address tie may join a whole chain to a Phi even
+        // when only the Phi and an earlier def actually overlap. Reuse the
+        // failed-range walk to find those ties before inserting copies.
+        // A Split's single use is artificial: leave earlier splitting intact.
+        findAllLRG(lrg);
+        for( int i = 0; i<_ns._len; i++ ) {
+            Node n = _ns.at(i);
+            if( lrg(n)==lrg && n instanceof MachNode mach && mach.twoAddress()==1 &&
+                mach.commutes() && !(n.in(2) instanceof SplitNode) &&
+                n.in(2).nOuts()==1 && lrg(n.in(2))!=lrg )
+                n.swap12();
+            else _ns.remove(i--);
+        }
+        // Reuse the scratch list to remember just the ties we broke.
+
         // First encounter with a loop Phi: try only cold splits this round.
         // Remember the Phi across rounds so a persistent self-conflict forces
         // the hot def/backedge splits on the next encounter.
@@ -466,7 +481,9 @@ public class RegAlloc {
                         insertBefore(phi,i,"use/self/phi",round,lrg);
             }
             // Split before two-address ops which extend the live range
-            if( def instanceof MachNode mach && mach.twoAddress()!= 0 )
+            // A commuted operand already broke this tie. Rebuild it in the
+            // next normal coloring round instead of copying the old range.
+            if( def instanceof MachNode mach && mach.twoAddress()!=0 && _ns.find(def)==-1 )
                 insertBefore(def,mach.twoAddress(),"use/self/two",round,lrg);
         }
         return true;
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/codegen/TypeCheck.java b/chapter29/src/main/java/com/seaofnodes/simple/codegen/TypeCheck.java
index abd8628d..30e1415e 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/codegen/TypeCheck.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/codegen/TypeCheck.java
@@ -19,10 +19,12 @@ abstract class TypeCheck {
         code._classInitDependencies = deps; // Serialize reuses this checked graph.
 
         Ary<Node> errs = new Ary<>(Node.class);
+        Ary<ConstructNode> constructs = new Ary<>(ConstructNode.class);
         code._stop.walk( n -> {
                 if( n.err() != null )
                     errs.add(n);
                 if( n instanceof CLInitNode ) code.add(n);
+                if( n instanceof ConstructNode con ) constructs.add(con);
                 return null;
             });
 
@@ -30,25 +32,35 @@ abstract class TypeCheck {
             // Prefer an originating error over a secondary error caused by a
             // BOTTOM input.  If all errors are downstream-poisoned, retain
             // the old first-error behavior.
-            Node min = null;
-            for( Node n : errs )
-                if( noBottomInputs(n) )
-                    {  min = n;  break; }
-            if( min==null )
-                min = errs.at(0);
+            Node min = errs.at(0);
             for( Node n : errs )
                 if( n!=min &&
-                    noBottomInputs(n) &&
+                    (errorRank(n)<errorRank(min) || (errorRank(n)==errorRank(min) &&
                     ((n   instanceof MemOpNode nmop &&
                       min instanceof MemOpNode mmop &&
                       nmop._loc.before(mmop._loc)) ||
+                     (n instanceof ConstructNode nc && min instanceof ConstructNode mc &&
+                      nc._loc!=null && nc._loc.before(mc._loc)) ||
                      (n   instanceof CFGNode ncfg &&
                       min instanceof CFGNode mincfg &&
-                      ncfg.idepth() < mincfg.idepth())) )
+                      ncfg.idepth() < mincfg.idepth())))) )
                     min = n;
             if( code._obs != null ) code._obs.error(min, min.err().getMessage());
             throw min.err();
         }
+        // Checked construction boundaries have no runtime behavior. Gathered
+        // above during the existing error walk; no separate graph pass/solve.
+
+        for( ConstructNode con : constructs )
+            if( !con.isDead() ) con.subsume(con.in(1));
+    }
+
+    private static int errorRank(Node n) {
+        // Bad memory access originates the error. Missing construction fields
+        // in turn explain generic-scalar arithmetic further downstream.
+        if( n instanceof MemOpNode && noBottomInputs(n) ) return 0;
+        if( n instanceof ConstructNode ) return 1;
+        return noBottomInputs(n) ? 2 : 3;
     }
 
     private static boolean noBottomInputs(Node n) {
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/CLInitNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/CLInitNode.java
index f510be39..f8c1c925 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/CLInitNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/CLInitNode.java
@@ -75,7 +75,10 @@ public class CLInitNode extends CFGNode implements MultiNode {
     public boolean bypass() { return instance() || ready()._type==TypeInteger.TRUE; }
 
     @Override public Type compute() {
-        if( in(0)._type.isHigh() || ptr()._type.isHigh() )
+        // The pointer family can be known before its object shape during
+        // SCCP. Do not commit to a class flag before it can become an instance.
+        if( in(0)._type.isHigh() || ptr()._type.isHigh() ||
+            (ptr()._type instanceof TypeMemPtr tmp && tmp._obj.isHigh()) )
             return TypeTuple.make(Type.XCONTROL,TypeMem.TOP,TypeMem.TOP,Type.XCONTROL);
         if( instance() )
             return TypeTuple.make(in(0)._type,mem()._type,mem()._type,Type.XCONTROL);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/CallNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/CallNode.java
index fcadd0e4..18be3488 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/CallNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/CallNode.java
@@ -7,6 +7,7 @@ import com.seaofnodes.simple.parser.Parser;
 import com.seaofnodes.simple.codegen.CodeGen;
 import com.seaofnodes.simple.codegen.Iter;
 import com.seaofnodes.simple.type.Type;
+import com.seaofnodes.simple.type.TypeMemPtr;
 import com.seaofnodes.simple.type.TypeFunPtr;
 import com.seaofnodes.simple.type.TypeMem;
 import com.seaofnodes.simple.type.TypeRPC;
@@ -28,6 +29,9 @@ public class CallNode extends CFGNode {
         super(nodes);
         _loc = loc;
         CodeGen.CODE._calls.add(this);
+        // Imported targets may be installed after this call is parsed.
+        // Retry linking when Iter drains the parser's worklist.
+        CodeGen.CODE.add(this);
         CodeGen.CODE.add(CodeGen.CODE._globalEscapes);
     }
     public CallNode(CallNode call) { super(call); _loc = call._loc; }
@@ -82,22 +86,6 @@ public class CallNode extends CFGNode {
         return false;
     }
 
-    // Unknown callers contribute declared argument types to the parameters.
-    // Those broad types can hide a particular private callback supplied here.
-    // Expose actual arguments too, including calls through library summaries.
-    boolean exposesArguments(Node dep) {
-        if( external() ) return true;
-        if( !(fptr()._type instanceof TypeFunPtr tfp) ) return false;
-        for( int fidx = XInt.next(tfp.fidxs(),0); fidx>=0; fidx = XInt.next(tfp.fidxs(),fidx) ) {
-            FunNode fun = CodeGen.CODE._link(fidx);
-            if( fun!=null && !fun.isClz() ) {
-                dep.addDepForwards(fun);
-                if( fun.unknownCallers() ) return true;
-            }
-        }
-        return false;
-    }
-
     // As in the escape chapter, native code may retain an argument even if
     // this path never returns. StopCU reads this independently of CallEnd.
     TypeMem exposed(Node dep) {
@@ -165,7 +153,8 @@ public class CallNode extends CFGNode {
                 // Walk the bits and link
                 for( int fidx = XInt.next(fidxs,0); fidx > 0; fidx = XInt.next(fidxs,fidx) ) {
                     FunNode fun = CodeGen.CODE.link(fidx);
-                    if( fun!=null && !fun._folding && !linked(fun) )
+                    if( fun==null ) addDepForwards(CodeGen.CODE._start);
+                    if( fun!=null && !addDep(fun)._folding && !linked(fun) )
                         progress = link(fun);
                 }
             }
@@ -256,6 +245,9 @@ public class CallNode extends CFGNode {
         // Check for args
         for( int i=0; i<tfp.nargs(); i++ )
             if( !arg(i+2)._type.isa(tfp.arg(i)) || !arg(i+2)._type.accessISA(tfp.arg(i)) ) {
+                if( arg(i+2)._type instanceof TypeMemPtr actual && actual._partial &&
+                    tfp.arg(i) instanceof TypeMemPtr formal && !formal._partial )
+                    return Parser.error("Cannot pass an incomplete object to a parameter without '^' (ordinary function or constructor)",_loc);
                 // Constructors return private memory and carry hidden self and
                 // selfMem arguments ahead of the source-level arguments.
                 int argno = i - (tfp.ret() instanceof TypeMem ? 2 : 0);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/ConstructNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/ConstructNode.java
index 52e3eb54..3984e48f 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/ConstructNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/ConstructNode.java
@@ -1,28 +1,70 @@
 package com.seaofnodes.simple.node;
 
 import com.seaofnodes.simple.codegen.CodeGen;
+import com.seaofnodes.simple.parser.Parser;
+import com.seaofnodes.simple.parser.Lexer;
 import com.seaofnodes.simple.type.*;
 import com.seaofnodes.simple.util.Ary;
 import com.seaofnodes.print.ExprPrinter;
 
 /** The source new boundary. Own fields have been constructed, but an incomplete
  * actual argument keeps this result incomplete. Unlike a callee's merged Return,
- * this transfer describes one allocation site. Erased after source checks. */
+ * this transfer describes one allocation site. The partial-only form gives
+ * constructor self and ^ formals their restricted body view even after
+ * inlining substitutes complete actual arguments. Erased after source checks. */
 public class ConstructNode extends Node {
+    public final Lexer _loc;
+    private final boolean _explicit;
+    public final boolean _partial;
     public ConstructNode(Node value, Ary<Node> args) {
-        super(null,value);
+        super(null,value,null);
+        _loc = null;
+        _explicit = false;
+        _partial = false;
         for( Node arg : args ) addDef(arg);
     }
+    // Inside the allocator: keep the final private memory with the result,
+    // so inlining cannot discard the constructor-completion check.
+    public ConstructNode(Node value, Node mem, Lexer loc, boolean explicit) {
+        super(null,value,mem);
+        _loc = loc;
+        _explicit = explicit;
+        _partial = false;
+    }
+    // The constructor body sees self and ^ formals through this restricted view.
+    public ConstructNode(Node value) {
+        super(null,value,null);
+        _loc = null;
+        _explicit = false;
+        _partial = true;
+    }
     @Override public String label() { return "Construct"; }
     @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) { return p.p("construct(").n(in(1)).p(")"); }
     @Override public Type compute() {
         Type t = in(1)._type;
+        if( in(2)!=null && in(2)._type.isHigh() ) return Type.TOP;
         if( !(t instanceof TypeMemPtr ptr) ) return t;
-        boolean partial = false;
-        for( int i = 2; i<nIns(); i++ ) partial |= TypeMemPtr.mayBePartial(in(i)._type);
+        boolean partial = _partial;
+        for( int i = 3; i<nIns(); i++ ) partial |= TypeMemPtr.mayBePartial(in(i)._type);
         return ptr.withPartial(partial);
     }
     @Override public Node idealize() {
-        return CodeGen.CODE._phase==CodeGen.Phase.Parse ? null : in(1);
+        // Wait for Opto to install closed field types. Afterwards, a proven
+        // identity with initialized fields has no remaining error obligation.
+        return !_partial && CodeGen.CODE._phase.ordinal()>=CodeGen.Phase.Opto.ordinal() && _type==in(1)._type && err()==null ? in(1) : null;
+    }
+    @Override public Parser.ParseException err() {
+        if( in(2)==null || in(2)._type.isHigh() || !(in(1)._type instanceof TypeMemPtr ptr) ) return null;
+        Type mem = in(2)._type;
+        for( Field fld : ptr._obj._fields ) {
+            if( fld._extern ) continue;
+            Field actual = mem instanceof TypeMem tm && tm._t instanceof TypeStruct ts ? ts.field(fld._fname) : null;
+            if( actual==null || actual._t==TypeScalar.BOT || actual._t==Type.BOTTOM )
+                return Parser.error("'"+ptr._obj._name+"' is not fully initialized, field '"+fld._fname+
+                    (_explicit ? "' is only partially set in the constructor" : "' needs to be set in a constructor"),_loc);
+        }
+        return null;
     }
+    @Override public boolean eq(Node n) { return _explicit==((ConstructNode)n)._explicit && _partial==((ConstructNode)n)._partial; }
+    @Override int hash() { return (_explicit ? 1 : 0) | (_partial ? 2 : 0); }
 }
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/ConvertNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/ConvertNode.java
index ee911398..47c8ecbe 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/ConvertNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/ConvertNode.java
@@ -39,6 +39,7 @@ public class ConvertNode extends Node {
     @Override public Type compute() {
         Type src = val()._type;
         if( src.isHigh() ) return Type.TOP;
+        if( src==Type.BOTTOM || src==TypeScalar.BOT ) return src;
         if( _dst instanceof TypeMemPtr ptr ) return ptr.withPartial(TypeMemPtr.mayBePartial(src));
         if( !(_dst instanceof TypeMemPtr) && src.isa(_dst) ) return src;
         return _dst;
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/EscapeNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/EscapeNode.java
index 3e95fffb..02f08c19 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/EscapeNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/EscapeNode.java
@@ -1,6 +1,7 @@
 package com.seaofnodes.simple.node;
 
 import com.seaofnodes.print.ExprPrinter;
+import com.seaofnodes.simple.codegen.CodeGen;
 
 import com.seaofnodes.simple.type.*;
 import com.seaofnodes.simple.util.*;
@@ -75,7 +76,12 @@ public class EscapeNode extends TypeNode {
         Type t = tpriv.meet(tpub).join(fld._t);
         int[] fidxes  = XInt.meet(mpriv._escFs, mpub._escFs);
         int[] aliases = XInt.meet(mpriv._escAs, mpub._escAs);
-        return TypeMem.make(fld._alias, t, false, false, fld._final, fidxes, aliases).escapesFrom(t);
+        // Keep escapes from the actual private value before narrowing it to
+        // the declaration. Selecting its Store from a MemMerge must preserve
+        // this result, including Scalar.BOT's unknown pointer escapes.
+        TypeMem defaults = CodeGen.CODE.publicEscapes();
+        return TypeMem.make(fld._alias, t, false, false, fld._final, fidxes, aliases)
+            .escapesFrom(tpriv,defaults).escapesFrom(t,defaults);
     }
 
     @Override public Node idealize() {
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/FRefNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/FRefNode.java
index 3906f7be..583a4300 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/FRefNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/FRefNode.java
@@ -34,6 +34,8 @@ public class FRefNode extends ConstantNode {
 
     @Override public String label() { return "FRef"+_name; }
 
+    @Override public Type compute() { return nIns()==1 ? _con : in(1)._type; }
+
 
     @Override protected ExprPrinter<Node> _print1(ExprPrinter<Node> p) {
         return p.p("FRef_").p(_name);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/FldOffNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/FldOffNode.java
index 223ca79e..09e5eac8 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/FldOffNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/FldOffNode.java
@@ -13,13 +13,13 @@ import java.util.HashMap;
 /**
  * A field offset.  This becomes a constant *after* other optimizations which
  * determine field sizes - some fields might be dead, or hold only zeros or
- * small values.
+ * small values. The base is data in slot 1; slot 0 is reserved for control.
  */
 
 public class FldOffNode extends TypeNode {
     public final String _fname; // Field name
     public final Lexer _loc;   //
-    public FldOffNode( Node base, String fname, Lexer loc ) { super(TypeInteger.BOT,base); _fname = fname; _loc=loc; }
+    public FldOffNode( Node base, String fname, Lexer loc ) { super(TypeInteger.BOT,null,base); _fname = fname; _loc = loc; }
     @Override public Tag serialTag() { throw Utils.TODO("should not reach here"); }
 
     @Override public String label() {
@@ -36,7 +36,7 @@ public class FldOffNode extends TypeNode {
 
     @Override public Node idealize() {
         // When base() gets typed, this xforms into a ConFldOffNode
-        if( in(0)._type instanceof TypeMemPtr tmp )
+        if( in(1)._type instanceof TypeMemPtr tmp )
             return new ConFldOffNode(tmp._obj,_fname);
         return null;
     }
@@ -48,7 +48,7 @@ public class FldOffNode extends TypeNode {
     @Override int hash() { return super.hash() * _fname.hashCode(); }
 
     @Override public Parser.ParseException err() {
-        if( in(0)._type instanceof TypeMemPtr tmp && tmp._obj._fref )
+        if( in(1)._type instanceof TypeMemPtr tmp && tmp._obj._fref )
             return Parser.error("Unknown struct type '"+tmp._obj._name+"'",null);
         return null;
     }
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/FunNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/FunNode.java
index d76d80b5..de32bea9 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/FunNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/FunNode.java
@@ -170,7 +170,7 @@ public class FunNode extends RegionNode {
         }
 
         // Upgrade inferred or user-written return type to actual
-        if( _ret!=null && _ret._type instanceof TypeTuple tt &&
+        if( _ret!=null && addDep(_ret)._type instanceof TypeTuple tt &&
             tt.ret() != _sig.ret() && tt.ret().isa(_sig.ret()) ) {
             setSig(_sig.makeFrom(tt.ret()));
             return this;
@@ -180,12 +180,19 @@ public class FunNode extends RegionNode {
         // - Must be past pessimistic Iter, which discovers and links calls
         //   through class-field loads and other initially imprecise values.
         // - FIDX is not in the escape set
-        // - Not called anywhere else; post Opto called-not-escaped functions need to still be hooked to start
+        // Concrete callers keep the body alive; FinalizeIR retains surviving
+        // functions for emission without giving them unknown callers.
         if( !isRoot() && in(1) instanceof StartCUNode start ) {
             boolean preOpto = CodeGen.CODE._phase == null ||
                 CodeGen.CODE._phase.ordinal() < CodeGen.Phase.Opto.ordinal();
-            if( !preOpto && !start.escapedFIDX(_sig.fidx()) && nIns()<=2 && _ret!=null ) {
-                _compunit._stop.delDef(_compunit._stop._inputs.find(ret()));
+            if( !preOpto && !start.escapedFIDX(_sig.fidx()) && _ret!=null ) {
+                // CLInit has a call edge but no Return edge. Keep a called
+                // body's Return rooted even after dropping unknown callers.
+                if( !isClz() || nIns()<=2 ) {
+                    StopCUNode stop = _compunit._stop;
+                    CODE.add(stop).delDef(stop._inputs.find(ret()));
+                    CODE.addAll(stop._outputs); // The outer Stop can drop an empty unit.
+                }
                 return removeDeadPath(1);
             } else {
                 addDep(start);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/GlobalEscapeNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/GlobalEscapeNode.java
index dab48530..740b0895 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/GlobalEscapeNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/GlobalEscapeNode.java
@@ -16,19 +16,14 @@ public class GlobalEscapeNode extends Node {
     @Override public Node idealize() { return null; }
 
     @Override public TypeMem compute() {
-        TypeMem xmem = StopCUNode.priorEscapes(_type);
+        TypeMem xmem = TypeMem.START;
         for( CallNode call : CodeGen.CODE._calls )
             if( !call.isDead() ) {
-                xmem = StopCUNode.publicBottom(xmem.escapes(call.exposed(this)),xmem);
-                // FULL memory normalizes to public bits. Preserve precise
-                // private arguments independently of that normalization.
-                if( call._type==Type.CONTROL && call.exposesArguments(this) )
-                    for( int i = 0; i<call.nargs(); i++ )
-                        xmem = StopCUNode.publicBottom(xmem.escapes(addDepForwards(call.arg(i+2))._type),xmem);
+                xmem = xmem.escapes(call.exposed(this));
             }
         for( FunNode fun : CodeGen.CODE._linker )
             if( fun!=null && fun.summary()!=null && !fun.summary().isDead() ) {
-                xmem = StopCUNode.publicBottom(xmem.escapes(fun.summary().exposed(this)),xmem);
+                xmem = xmem.escapes(fun.summary().exposed(this));
                 // A reachable unloaded body can call these targets, including
                 // private initializers. Its arguments are unavailable here.
                 if( fun._type==Type.CONTROL )
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/LoadNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/LoadNode.java
index 4b09d2e9..d62152e5 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/LoadNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/LoadNode.java
@@ -225,7 +225,7 @@ public class LoadNode extends MemOpNode {
     // the unchanged loop memory, or a merge whose every arm folds. Null fails.
     // Register dependencies so a later pointer/offset rewrite retries the query.
     private Node find(Node mem, Node ptr, Node stop, BitSet visit) {
-        if( ptr instanceof ReadOnlyNode ro ) ptr=ro.in(1);
+        ptr = address(ptr);
         Field fld;
         boolean external = ptr._type instanceof TypeMemPtr tmp &&
             (fld=tmp._obj.field(_name))!=null && fld._extern;
@@ -238,13 +238,21 @@ public class LoadNode extends MemOpNode {
                 // Alias 1 is still unresolved, not a proven different field.
                 if( st._alias==1 ) return null;
                 addDep(st.ptr());
-                if( _alias==st._alias && (ptr==st.ptr() || ptr==st.nnptr()) && off()==st.off() ) {
+                if( _alias==st._alias && (ptr==address(st.ptr()) || ptr==address(st.nnptr())) && off()==st.off() ) {
+                    // Forwarding must preserve the pointer type already seen
+                    // by users: completion, read-only view, and recursive shape.
+                    // Open declarations can disagree until Opto upgrades them.
+                    if( _type instanceof TypeMemPtr ) {
+                        Type value = addDep(st.val())._type;
+                        if( ptr()._type.isFinal() || declaredType().isFinal() ) value = value.makeRO();
+                        if( !value.isa(_type) ) return null;
+                    }
                     // A full-width load cannot narrow the forwarded value.
                     if( declaredType() instanceof TypeInteger ti && ti.log_size()==3 &&
                         !addDep(st.val())._type.isa(_type) ) return null;
                     return st;
                 }
-                if( (external || _alias==st._alias) && (external || !neverAlias(ptr,st.ptr())) &&
+                if( (external || _alias==st._alias) && (external || !neverAlias(ptr,address(st.ptr()))) &&
                     !addDep(off())._type.join(addDep(st.off())._type).isHigh() ) return null;
                 mem=st.mem();
                 break;
@@ -256,8 +264,8 @@ public class LoadNode extends MemOpNode {
             case EscapeNode esc:
                 if( external ) return null;
                 addDep(esc.self());
-                if( esc.self()==ptr ) { mem=esc.priv(); break; }
-                if( neverAlias(ptr,esc.self()) ) { mem=esc.pub(); break; }
+                if( address(esc.self())==ptr ) { mem=esc.priv(); break; }
+                if( neverAlias(ptr,address(esc.self())) ) { mem=esc.pub(); break; }
                 return null;
             case PhiNode phi:
                 if( phi instanceof ParmNode || (!(phi instanceof MemPhiNode) && !(phi._type instanceof TypeMem tm && tm._one)) ) return null;
@@ -299,6 +307,16 @@ public class LoadNode extends MemOpNode {
         return ld.peephole();
     }
 
+    // Type views preserve the address. Keep the actual Load pointer qualified
+    // for compute/err; only alias comparisons see through these views.
+    private Node address(Node ptr) {
+        while( ptr instanceof ReadOnlyNode || ptr instanceof ConstructNode con && con._partial ) {
+            addDep(ptr);
+            ptr = ptr.in(1);
+        }
+        return ptr;
+    }
+
     private static boolean neverAlias( Node ptr1, Node ptr2 ) {
         return ptr1.in(0) != ptr2.in(0) &&
             // Unrelated allocations
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/MulNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/MulNode.java
index 04fcf1c2..87141456 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/MulNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/MulNode.java
@@ -29,7 +29,7 @@ public class MulNode extends ArithNode {
 
         // Integer strength reductions require two integer operands. In
         // particular Scalar.BOT * 0 must retain its unresolved input.
-        if( _mode!=1 || !(t1 instanceof TypeInteger && t2 instanceof TypeInteger) )
+        if( _mode==2 || !(t1 instanceof TypeInteger && t2 instanceof TypeInteger) )
             return super.idealize();
 
         // Move constants to RHS: con*arg becomes arg*con
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/Node.java b/chapter29/src/main/java/com/seaofnodes/simple/node/Node.java
index cbd35592..2815dfba 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/Node.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/Node.java
@@ -525,7 +525,7 @@ public abstract class Node extends BaseNode<Node> implements Cloneable {
     }
 
     @SuppressWarnings("unchecked")
-    public <N extends Node> N init() { _type = compute(); return (N)this; }
+    public <N extends Node> N init() { _type = compute(); CODE.add(this); return (N)this; }
 
     /**
      * This function rewrites the current Node into a more "idealized" form.
@@ -753,14 +753,16 @@ public abstract class Node extends BaseNode<Node> implements Cloneable {
 
     // If a Type upgrade happens, put on worklist
     boolean _upgradeType( HashMap<String,Type> TYPES ) { return false; }
-    public final void upgradeType( HashMap<String,Type> TYPES ) {
+    public final boolean upgradeType( HashMap<String,Type> TYPES ) {
         Type old = _type;  _type = _type.upgradeType(TYPES);
         boolean progress = _upgradeType(TYPES);
         if( progress || old != _type ) {
             CODE.add(this);
             CODE.addAll(_outputs);
             if( _deps!=null ) CODE.addAll(_deps);
+            return true;
         }
+        return false;
     }
 
     /**
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/ParmNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/ParmNode.java
index 1d8bd484..9c40c75d 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/ParmNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/ParmNode.java
@@ -67,16 +67,11 @@ public class ParmNode extends PhiNode {
         if( !(region() instanceof RegionNode r) )
             return region()._type==Type.XCONTROL || region()._type==Type.TOP ? (_declaredType instanceof TypeMem ? TypeMem.TOP : Type.TOP) : _type;
         // During parsing Phis have to be computed type pessimistically.
-        boolean privateMem = _idx==3 && _declaredType instanceof TypeMem mem && mem._one && !mem._clz;
-        if( privateMem && fun().unknownCallers() && nIns()==2 && CodeGen.CODE._phase!=CodeGen.Phase.Parse )
-            return TypeMem.TOP;
-        if( (!privateMem && r.inProgress()) || in(nIns()-1)==null || (privateMem && fun().unknownCallers() && nIns()==2) )
+        if( r.inProgress() || in(nIns()-1)==null )
             return _declaredType;
         // Set type to local top of the starting type
         Type t = Type.TOP;
-        // Internal construction memory is supplied by allocation/initializer
-        // calls, not by the fictitious external caller used to keep a body live.
-        for( int i = privateMem && fun().unknownCallers() ? 2 : 1; i < nIns(); i++ ) {
+        for( int i = 1; i < nIns(); i++ ) {
             // If the region's control input is live, add this as a dependency
             // to the control because we can be peeped should it become dead.
             Type ctrl = addDep(r.in(i))._type;
@@ -94,10 +89,6 @@ public class ParmNode extends PhiNode {
         if( t instanceof TypeInteger ti && !ti.isHigh() && !ti.isConstant() )
             t = ti.same_but_slightly_wider_than();
         t = t.join(_declaredType);
-        // ^ is a restriction inside the constructor even if every currently
-        // known caller passes a complete object. Inlining may later remove it.
-        if( t instanceof TypeMemPtr ptr && _declaredType instanceof TypeMemPtr decl && decl._partial )
-            t = ptr.withPartial(true);
         return t==Type.TOP && _declaredType instanceof TypeMem ? TypeMem.TOP : t;
     }
 
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/PhiNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/PhiNode.java
index a4aaaa07..f45c7325 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/PhiNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/PhiNode.java
@@ -200,7 +200,7 @@ public class PhiNode extends Node {
     private Node drop_same_op() {
         Node op = in(1), cp = op.copyEmpty();
         cp._type = null;
-        cp.addDef(null);
+        cp._inputs.add(null);
         for( int j=1; j<op.nIns(); j++ ) {
             Node x = op.in(j);
             boolean different = false;
@@ -217,25 +217,52 @@ public class PhiNode extends Node {
                 // Do not introduce an operand Phi mixing incompatible type families.
                 if( t==Type.BOTTOM || t==TypeScalar.BOT ) {
                     for( int i=1; i<ins.length; i++ ) addDep(ins[i]);
-                    cp.kill();
+                    discardTrial(cp);
                     return null;
                 }
                 PhiNode phi = j==1 && op instanceof MemOpNode mem
-                    ? new MemPhiNode(_label,mem._alias,ins)
-                    : PhiNode.make(_label,t,ins);
-                x = phi.peephole();
+                    ? new MemPhiNode(_label,mem._alias)
+                    : PhiNode.make(_label,t);
+                // Compute the trial without changing any existing use lists.
+                // Rejecting and killing a wired trial would wake our own
+                // dependencies and retry the same unsuccessful fold forever.
+                for( Node in : ins ) phi._inputs.add(in);
+                phi._type = phi.compute();
+                x = phi;
             }
-            cp.addDef(x);
+            cp._inputs.add(x);
         }
         // Factoring must not widen the result (e.g. correlated And operands).
-        if( cp.compute().isa(compute()) ) return cp;
+        if( cp.compute().isa(compute()) ) {
+            for( int j=1; j<cp.nIns(); j++ ) {
+                Node x = cp.in(j);
+                if( x instanceof PhiNode && x.isUnused() ) {
+                    for( Node in : x._inputs )
+                        if( in!=null ) in.addUse(x);
+                    x = x.peephole();
+                    cp._inputs.set(j,x);
+                }
+                if( x!=null ) x.addUse(cp);
+            }
+            return cp;
+        }
         for( int i=1; i<nIns(); i++ )
             for( int j=1; j<in(i).nIns(); j++ )
                 if( in(i).in(j)!=null ) addDep(in(i).in(j));
-        cp.kill();
+        discardTrial(cp);
         return null;
     }
 
+    // Trial inputs have no matching use edges yet, so ordinary kill is wrong.
+    private static void discardTrial(Node cp) {
+        for( Node x : cp._inputs )
+            if( x instanceof PhiNode && x.isUnused() ) {
+                x._inputs.clear();
+                x._type = null;
+            }
+        cp._inputs.clear();
+    }
+
     /**
      * If only single unique input, return it
      */
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/PtrToIntNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/PtrToIntNode.java
index d528b53b..8c2bc069 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/PtrToIntNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/PtrToIntNode.java
@@ -5,6 +5,7 @@ import com.seaofnodes.simple.parser.Parser;
 import com.seaofnodes.simple.type.Type;
 import com.seaofnodes.simple.type.TypeInteger;
 import com.seaofnodes.simple.type.TypeMemPtr;
+import com.seaofnodes.simple.type.TypeScalar;
 
 
 /**
@@ -22,6 +23,7 @@ public class PtrToIntNode extends Node {
     @Override protected String format() { return "(i64*)%1"; }
 
     @Override public Type compute() {
+        if( in(1)._type==Type.BOTTOM || in(1)._type==TypeScalar.BOT ) return in(1)._type;
         return in(1)._type.isHigh() ? TypeInteger.TOP : TypeInteger.BOT;
     }
 
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/StopCUNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/StopCUNode.java
index a6116e93..8a554390 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/StopCUNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/StopCUNode.java
@@ -19,6 +19,10 @@ public class StopCUNode extends StopNode {
         return stop;
     }
 
+    // CompUnit owns this wrapper by identity. Even empty units must not share
+    // a Stop: doing so can merge their Starts and their kept memory projections.
+    @Override public boolean eq(Node n) { return false; }
+
     public StartCUNode start() {
         for( Node use : _outputs )
             if( use instanceof StartCUNode start )
@@ -34,8 +38,10 @@ public class StopCUNode extends StopNode {
             return TypeTuple.STATE;
 
         StartCUNode start = start();
-        // Memory start from all returns
-        TypeMem xmem = priorEscapes(_type instanceof TypeTuple old ? old.mem() : _type);
+        // Recompute from inputs, not our previous result. Unknown values carry
+        // FULL escape sets: restricting them to public names would lose private
+        // objects/functions which a later load-forwarding rewrite can reveal.
+        TypeMem xmem = TypeMem.START;
 
         for( Node def : _inputs ) {
             ReturnNode ret = (ReturnNode)def;
@@ -69,59 +75,23 @@ public class StopCUNode extends StopNode {
             // here as its effects are not visible to the outside world.
             addDepForwards(start); // Check again if function escapes
             if( pub || start.escapedFIDX(sig.fidx()) ) {
-                // External callers already hold their object arguments, so
-                // writes through those arguments expose addresses too.
-                for( Node use : fun._outputs )
-                    if( use instanceof ParmNode p && p._idx>=2 )
-                        xmem = publicBottom(xmem.escapes(addDepForwards(p)._type),xmem);
                 if( tret.ctl().isHigh() ) continue; // Return not reachable
                 // Capture (precisely?) all escaping pointer aliases and fidxs.
                 // Escaped fidxs means the linked world can call that function;
                 // escaped aliases means the linked world can R/W those aliases.
-                xmem = publicBottom(xmem.escapes(tret.ret()),xmem);
-                xmem = (TypeMem)xmem.meet(publicBottom(tret.mem(),xmem));
+                xmem = xmem.escapes(tret.ret());
+                xmem = (TypeMem)xmem.meet(tret.mem());
             }
         }
         // All units share escapes from calls and unloaded bodies, including
         // paths with no Return. Revisit only when that shared result changes.
         GlobalEscapeNode global = CodeGen.CODE._globalEscapes;
         if( global!=null && !global.isDead() )
-            xmem = publicBottom(xmem.escapes(addDepForwards(global)._type),xmem);
+            xmem = xmem.escapes(addDepForwards(global)._type);
         assert xmem._alias==1 && !xmem._one;
         return TypeTuple.make(Type.CONTROL,xmem,Type.BOTTOM);
     }
 
-    // FULL escape sets arise from global BOTTOM.  Across a compilation-unit
-    // boundary global BOTTOM exposes every public field, while retaining any
-    // private escapes already discovered precisely.
-    static TypeMem publicBottom(TypeMem mem, TypeMem prior) {
-        // The pessimistic Iter pass naturally lifts transient FULL inputs to
-        // precise finite sets.  Replacing FULL early there would let a later
-        // input refinement add bits, reversing Iter's monotonic direction.
-        // This normalization is needed only for Opto's optimistic grand cycle.
-        if( CodeGen.CODE._phase.ordinal() < CodeGen.Phase.Opto.ordinal() ||
-            CodeGen.CODE._phase.ordinal() > CodeGen.Phase.Lower.ordinal() ) return mem;
-        int[] escFs = XInt.isHigh(mem._escFs)
-            ? XInt.meet(prior._escFs,CodeGen.CODE.publicFIDXs())
-            : mem._escFs;
-        int[] escAs = XInt.isHigh(mem._escAs)
-            ? XInt.meet(prior._escAs,CodeGen.CODE.publicAliases())
-            : mem._escAs;
-        return escFs==mem._escFs && escAs==mem._escAs ? mem : mem.makeFrom(escFs,escAs);
-    }
-
-    // In Opto, a precise escape set can widen to FULL. Public-only
-    // normalization must retain private bits discovered on an earlier step.
-    static TypeMem priorEscapes(Type old) {
-        TypeMem mem = TypeMem.START;
-        if( CodeGen.CODE._phase.ordinal() >= CodeGen.Phase.Opto.ordinal() &&
-            CodeGen.CODE._phase.ordinal() <= CodeGen.Phase.Lower.ordinal() &&
-            old instanceof TypeMem prior )
-            mem = mem.makeFrom(XInt.meet(mem._escFs,prior._escFs),
-                               XInt.meet(mem._escAs,prior._escAs));
-        return mem;
-    }
-
     @Override
     public Node idealize() {
         int len = nIns();
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/StoreNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/StoreNode.java
index 47984ed6..4114b47c 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/StoreNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/StoreNode.java
@@ -80,7 +80,7 @@ public class StoreNode extends MemOpNode {
         Type mem0 = mem()._type;
         Type ptr0 = ptr()._type;
         // Validate argument types
-        if( ptr0.isHigh() )
+        if( ptr0.isHigh() || mem0.isHigh() )
             return TypeMem.TOP;
         if( !(mem0 instanceof TypeMem    mem) ||
             !(ptr0 instanceof TypeMemPtr ptr) )
@@ -88,16 +88,16 @@ public class StoreNode extends MemOpNode {
 
         // Sharpen memory value; required for narrowing stores where the parser
         // inserts zero/sign masking and somebody reads the TypeMem type.
-        // A source Load of an unwritten field is kept and checked separately;
-        // this declared bound does not excuse that earlier read.
+        // A declared bound must not turn an unwritten value into an
+        // initialized integer, float, or pointer.
         Type decl = declaredType();
         if( decl instanceof TypeMemPtr ptrType ) decl = ptrType.withPartial(TypeMemPtr.mayBePartial(val));
-        if( decl != Type.BOTTOM )
+        if( decl != Type.BOTTOM && val!=Type.BOTTOM && val!=TypeScalar.BOT )
             { assert decl != Type.TOP; val = val.join(decl); }
         // A constructor can itself be a field. Its result memory contains
         // that field again; retain the declared signature instead of unfolding
         // successively sharper copies of its private-memory return type.
-        if( mem._one && decl instanceof TypeFunPtr ) val = decl;
+        if( mem._one && decl instanceof TypeFunPtr && val instanceof TypeFunPtr ) val = decl;
         // A singleton class's final constant field lives in the static image.
         // Its precise memory slice is a constant too; ordinary peepholes can
         // replace this Store before scheduling or instruction selection.
@@ -107,7 +107,10 @@ public class StoreNode extends MemOpNode {
         if( fld==null && off() instanceof ConFldOffNode off ) fld = off._ts.field(_name);
         if( _alias!=1 && ptr._one && TypeStruct.startsClzPrefix(ptr._obj._name) &&
             fld!=null && fld._final && decl.isConstant() )
-            return TypeMem.make(_alias,val,true,true,true,mem._escFs,mem._escAs).escapesFrom(val);
+            // This singleton slice contains just the stored value. Copying
+            // bulk memory's escapes would freeze a transient FULL bound into
+            // the constant, permanently exposing unrelated private functions.
+            return TypeMem.make(_alias,val,true,true,true,null,null).escapesFrom(val);
 
         // Allocation uses a private TypeMem and nothing else does.  This
         // memory is truly private; a temporary singleton until it escapes -
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java
index 151a326e..472fff7b 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/ToFloatNode.java
@@ -4,6 +4,7 @@ package com.seaofnodes.simple.node;
 import com.seaofnodes.simple.type.Type;
 import com.seaofnodes.simple.type.TypeFloat;
 import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeScalar;
 
 
 public class ToFloatNode extends Node {
@@ -15,6 +16,7 @@ public class ToFloatNode extends Node {
     @Override
     public Type compute() {
         if( in(1)._type.isHigh() ) return TypeFloat.F64.dual();
+        if( in(1)._type==Type.BOTTOM || in(1)._type==TypeScalar.BOT ) return in(1)._type;
         if( in(1)._type == Type.NIL ) return TypeFloat.FZERO;
         if( in(1)._type instanceof TypeInteger i0 && i0.isConstant() )
             return TypeFloat.constant(i0.value());
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/node/ToIntegerNode.java b/chapter29/src/main/java/com/seaofnodes/simple/node/ToIntegerNode.java
index 33806300..2ae45740 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/node/ToIntegerNode.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/node/ToIntegerNode.java
@@ -3,6 +3,7 @@ package com.seaofnodes.simple.node;
 import com.seaofnodes.simple.type.Type;
 import com.seaofnodes.simple.type.TypeFloat;
 import com.seaofnodes.simple.type.TypeInteger;
+import com.seaofnodes.simple.type.TypeScalar;
 
 // Truncate toward zero, saturating overflow; NaN converts to zero.
 public class ToIntegerNode extends Node {
@@ -14,6 +15,7 @@ public class ToIntegerNode extends Node {
     @Override public Type compute() {
         Type t = in(1)._type;
         if( t.isHigh() ) return TypeInteger.TOP;
+        if( t==Type.BOTTOM || t==TypeScalar.BOT ) return t;
         if( t instanceof TypeFloat tf && tf.isConstant() )
             return TypeInteger.constant((long)tf.value());
         return TypeInteger.BOT;
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/Allocations.java b/chapter29/src/main/java/com/seaofnodes/simple/parser/Allocations.java
index b8db4f4c..0eda2c62 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/Allocations.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/Allocations.java
@@ -47,13 +47,12 @@ final class Allocations {
         if( clz==null )
             throw P.error("Unknown struct type '" + ts._name + "'");
         Field afld = clz.field("<new>");
-        P.construction.allocation(afld==null ? null : (TypeFunPtr)afld._t,ctorArgs,P.loc());
         Node alloc;
         if( afld != null ) {
             TypeFunPtr tfp = (TypeFunPtr)afld._t;
             FunNode fun = P._code.link(tfp);
             alloc = fun==null
-                ? new FRefNode((TypeStruct.addClzPrefix(typeName)+".<new>").intern(),P.loc())
+                ? new FRefNode((TypeStruct.addClzPrefix(typeName)+".<new>").intern(),P.loc()).init()
                 : new FunPtrNode(tfp,P._code._start,fun.ret()).peephole();
         } else {
             if( !ts._fref )
@@ -62,7 +61,7 @@ final class Allocations {
             for( int i = 0; i<ctorArgs._len; i++ )
                 sig[i] = ctorArgs.at(i)._type;
             alloc = new FRefNode((TypeStruct.addClzPrefix(typeName)+".<new>").intern(),P.loc(),
-                                 TypeFunPtr.make(false,sig,TypeMemPtr.make(ts)));
+                                 TypeFunPtr.make(false,sig,TypeMemPtr.make(ts))).init();
         }
         Ary<Node> args = new Ary<>(Node.class);
         args.add(P.ctrl()); args.add(P.mem());
@@ -175,6 +174,13 @@ final class Allocations {
             priv = new ProjNode(cend,2,"#selfMem").peephole();
         }
 
+        // Hidden construction helpers have only allocator callers.
+        if( initRet.fun().unknownCallers() ) initRet.fun().removeDeadPath(1);
+        if( ctor!=null ) {
+            FunNode cfun = P._code.link(ctor);
+            if( cfun.unknownCallers() ) cfun.removeDeadPath(1);
+        }
+
         priv.keep();
         for( Field field : ts._fields ) {
             Type storage = field._t.makeStorage();
@@ -187,8 +193,9 @@ final class Allocations {
             pub.unkeep();
             pub = next;
         }
-        priv.unkill();
-        ReturnNode ret = (ReturnNode)new ReturnNode(ctl,pub,self,rpc,fun).peephole();
+        Node finished = new ConstructNode(self,priv,P.loc(),ctor!=null).peephole();
+        priv.unkeep();
+        ReturnNode ret = (ReturnNode)new ReturnNode(ctl,pub,finished,rpc,fun).peephole();
         fun.setRet(ret);
         fun._approxUIDs = P._code.UID() - oldUID;
         P._ref.addFun(P._code,fun);
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/Construction.java b/chapter29/src/main/java/com/seaofnodes/simple/parser/Construction.java
index 799ca6fc..2720ad3d 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/Construction.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/Construction.java
@@ -1,9 +1,7 @@
 package com.seaofnodes.simple.parser;
 
-import com.seaofnodes.simple.codegen.Iter;
 import com.seaofnodes.simple.node.*;
 import com.seaofnodes.simple.type.*;
-import com.seaofnodes.simple.util.Ary;
 
 /**
  * Field initialization is ordinary forward typing: New supplies Scalar.BOT
@@ -26,8 +24,8 @@ import com.seaofnodes.simple.util.Ary;
  *
  * Incompleteness lives in TypeMemPtr, not a parser provenance graph. Ordinary
  * Phis carry it around loops, conversions preserve it, and ConstructNode types
- * each allocation result from its actual arguments. Source obligations retain
- * their operands until the type fixed point, but hold no separate flow facts.
+ * each allocation result from its actual arguments. Errors belong to the IR
+ * nodes and are checked at TypeCheck; the parser keeps no source-use lists.
  *
  * The qualifier is a two-point lattice: complete meets incomplete to incomplete.
  * Constructor self and ^ formals seed incomplete; a ^ formal stays restricted
@@ -36,7 +34,7 @@ import com.seaofnodes.simple.util.Ary;
  * while new Child(null) and new Child(oldParent) are complete, even though all
  * three calls share the same constructor Return. The raw allocator result is
  * complete after its own fields have been checked; ConstructNode adds the
- * caller's restriction and disappears after source checking.
+ * caller's restriction and disappears after TypeCheck.
  *
  * Reading a pointer field through a completed receiver gives a completed view
  * of that field too: its object's construction could only retain incomplete
@@ -46,17 +44,20 @@ import com.seaofnodes.simple.util.Ary;
  * Own-self access is identified by the receiver and its private memory, not by
  * the nominal class: a ^ argument of the same class cannot use that exception.
  *
- * Iter.types also solves qualifier cycles optimistically. For p = null followed
+ * The existing SCCP pass solves qualifier cycles optimistically. For p = null followed
  * by p = new Link(p) in a loop, nothing introduces incompleteness, so the loop
  * stays complete. A backedge carrying self makes the Phi and its uses incomplete.
  * Both cases use the ordinary worklist; no recursive Load/Phi/Call query remains.
+ * A partial-only ConstructNode supplies the body view of self and ^ formals.
+ * The Parm itself merges callers normally; inlining cannot erase the view.
+ * Hidden helpers have only allocator callers, while the public constructor
+ * binding denotes the allocator. Private-memory Parms therefore need no
+ * fictitious external default or constructor-specific transfer function.
+ * There is no extra construction pass; see docs/deferred-construction.md.
  */
 final class Construction {
     private final Parser P;
     boolean _borrowed; // Source ^ parameters; separate compilation is still deferred.
-    private final Ary<Node> _kept = new Ary<>(Node.class);
-    private final Ary<Use> _uses = new Ary<>(Use.class);
-    private final Ary<LoadNode> _reads = new Ary<>(LoadNode.class);
     Frame _frame;
 
     Construction(Parser P) { this.P = P; }
@@ -66,7 +67,6 @@ final class Construction {
         final Node _self;
         Frame(boolean owner, Node self) { _owner = owner; _self = self; }
     }
-    private record Use(Node ctrl, Node value, String operation, Lexer loc) {}
 
     Frame enter(FunNode fun, boolean owner) {
         Frame old = _frame;
@@ -74,37 +74,8 @@ final class Construction {
         return old;
     }
 
-    private Node keep(Node n) { _kept.add(n.keep()); return n; }
-
-    void complete(Node value, String operation, Lexer loc) {
-        if( !_frame._owner ) return;
-        _uses.add(new Use(keep(P.ctrl()),keep(value),operation,loc));
-    }
-
-    void ordinaryCall(Ary<Node> args, Lexer loc) {
-        TypeFunPtr sig = args.last()._type instanceof TypeFunPtr tfp ? tfp : null;
-        for( int i = 2; i<args.size()-1; i++ ) {
-            if( i==2 && sig!=null && sig.nargs()>0 && sig.arg(0)==TypePtr.PTR ) continue;
-            complete(args.at(i),"pass to an ordinary function",loc);
-        }
-    }
-
-    Node memory(Node ptr, String field, Lexer loc) {
-        if( own(ptr) ) return selfMem();
-        complete(ptr,"read field '"+field+"'",loc);
-        return P.mem();
-    }
-
-    Node loaded(LoadNode load) {
-        if( _frame._owner ) _reads.add((LoadNode)keep(load));
-        return P.peep(load);
-    }
-
-    void allocation(TypeFunPtr sig, Ary<Node> args, Lexer loc) {
-        if( !_frame._owner ) return;
-        for( int i = 0; i<args.size(); i++ )
-            if( sig==null || i>=sig.nargs() || !(sig.arg(i) instanceof TypeMemPtr ptr && ptr._partial) )
-                complete(args.at(i),"pass to a constructor parameter without '^'",loc);
+    Node memory(Node ptr) {
+        return own(ptr) ? selfMem() : P.mem();
     }
 
     Node selfMem() {
@@ -113,7 +84,7 @@ final class Construction {
     }
 
     boolean own(Node ptr) {
-        while( ptr instanceof ConvertNode || ptr instanceof ReadOnlyNode || ptr instanceof GuardNode ) ptr = ptr.in(1);
+        while( ptr instanceof ConvertNode || ptr instanceof ReadOnlyNode || ptr instanceof GuardNode || (ptr instanceof ConstructNode con && con._partial) ) ptr = ptr.in(1);
         return _frame._owner && ptr==_frame._self;
     }
 
@@ -124,20 +95,6 @@ final class Construction {
         else P.storeMem(st,alias,prior);
     }
 
-    void check() {
-        Iter.types(P._code);
-        for( LoadNode load : _reads )
-            if( load.err()!=null ) throw load.err();
-        for( Use use : _uses )
-            if( !use.ctrl._type.isHigh() && TypeMemPtr.mayBePartial(use.value._type) )
-                throw Parser.error("Cannot "+use.operation+" with an incomplete object",use.loc);
-        P.structs.checkInitFields();
-        for( Node n : _kept ) n.unkeep();
-        _kept.clear();
-        _uses.clear();
-        _reads.clear();
-    }
-
     void checkSerializable() {
         if( _borrowed )
             throw P.error("Separate compilation of constructors with '^' parameters is not supported yet");
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/Functions.java b/chapter29/src/main/java/com/seaofnodes/simple/parser/Functions.java
index 4d597b8d..50775349 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/Functions.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/Functions.java
@@ -114,7 +114,6 @@ final class Functions {
         // Unkeep them all
         for( Node arg : args )
             arg.unkeep();
-        P.construction.ordinaryCall(args,site);
         return functionCall(args,site);
     }
 
@@ -292,7 +291,9 @@ final class Functions {
         for( int i = 0; i<ids.length; i++ ) {
             Type t = sig.arg(i);
             // Args take a default input if called from Start/external-world
-            P._scope.define(ids[i], t, (i==0 && ids[0]=="self") || (finals!=null && finals.get(i)), new ParmNode(ids[i],i+2,t,fun,ConstantNode.seed(t).peephole()).peephole(), loc);
+            Node parm = new ParmNode(ids[i],i+2,t,fun,ConstantNode.seed(t).peephole()).peephole();
+            if( t instanceof TypeMemPtr ptr && ptr._partial ) parm = new ConstructNode(parm).peephole();
+            P._scope.define(ids[i], t, (i==0 && ids[0]=="self") || (finals!=null && finals.get(i)), parm, loc);
         }
 
         return fun;
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/Parser.java b/chapter29/src/main/java/com/seaofnodes/simple/parser/Parser.java
index 93c3932b..4d140e55 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/Parser.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/Parser.java
@@ -25,7 +25,6 @@ public class Parser {
     final Conversions conversions = new Conversions(this);
     final Construction construction = new Construction(this);
 
-    public void checkConstruction() { construction.check(); }
     public void checkConstructionSerializable() { construction.checkSerializable(); }
 
     // Compile driver
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/README.md b/chapter29/src/main/java/com/seaofnodes/simple/parser/README.md
index d1125842..3a8e8e64 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/README.md
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/README.md
@@ -14,8 +14,8 @@ productions to their entry points.
 | `Declarations.java` | Bindings, initializers, mutability modifiers, and native declarations. |
 | `Types.java` | Type syntax, qualified-name lookup, arrays, function types, and forward types. |
 | `Functions.java` | Function expressions, parameters, arguments, calls, and function entry/return graphs. |
-| `Structs.java` | Struct and constructor declarations, field discovery, and initialization checks. |
-| `Construction.java` | Source checks for field initialization and incomplete references; its comment explains BOT fields, the TypeMemPtr qualifier, and allocation boundaries. |
+| `Structs.java` | Struct and constructor declarations, field discovery, and initialization Stores. |
+| `Construction.java` | Selects private self memory during parsing; its comment explains BOT fields, the TypeMemPtr qualifier, and checks deferred to TypeCheck. |
 | `References.java` | Bare-name and field resolution, implicit receivers, assignments, and forward references. |
 | `Allocations.java` | Allocation expressions, strings, and declaration-side allocation helpers. |
 | `ControlFlow.java` | Guarded scope merging shared by `if`, `?:`, `&&`, and `||`. |
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/References.java b/chapter29/src/main/java/com/seaofnodes/simple/parser/References.java
index 4851d8b5..737ba4c9 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/References.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/References.java
@@ -139,13 +139,6 @@ final class References {
         // Update
         P._scope.update(name,lift);
 
-        // Check for storing into an instance field instead of a local var
-        int kx = P._scope.kindx(def); // Declaration scope
-        int fx = P._scope.enclosingFunction(); // Enclosing function scope
-        Kind kk = P._scope._kinds.at(kx);
-        if( kx<fx && !(P.structs.inExplicitConstructor() && kx+1==fx &&
-                       kk instanceof Kind.Func owner && FunNode.isInstance(owner._name)) )
-            P.construction.complete(lift,"store outside the construction group",P.loc());
         lift.unkill();
 
         // Return un-lifted expr
@@ -200,7 +193,7 @@ final class References {
         if( fld==null && ts!=null && !TypeStruct.startsClzPrefix(ts._name) ) {
             Type clz0 = Parser.TYPES.get(TypeStruct.addClzPrefix(ts._name));
             if( clz0 instanceof TypeStruct clz && (fld = P.types.latestStruct(clz).field(name)) != null ) {
-                expr.unkeep();
+                expr.unkill();
                 ts = P.types.latestStruct(clz);
                 expr = P.con(TypeMemPtr.make((byte)2,ts,true)).keep();
             }
@@ -233,10 +226,6 @@ final class References {
         if( pre==0 && P.matchOpx('=','=') ) {
             // Field assignment
             Node val = P.expressions.parseAssignment().keep();
-            if( !P.construction.own(expr) ) {
-                P.construction.complete(expr,"write through an unfinished reference",site);
-                P.construction.complete(val,"store into an ordinary object",site);
-            }
             // Lift value for store
             Node lift = fld==null ? val : new ConvertNode(fld._t,val).peephole();
             // Memory for store, post assignment expression
@@ -254,19 +243,18 @@ final class References {
         }
 
         // Memory for load
-        Node mem = P.construction.memory(expr,name,site);
+        Node mem = P.construction.memory(expr);
         // Loading from a constant array, the declared type is the
         // meet-over-elements and not the array itself.
         if( name=="[]" && decl instanceof TypeConAry conary )
             decl = conary.elem();
 
         // Load field
-        Node load = P.construction.loaded(new LoadNode(P.loc(),name,alias,P.ctrl(),mem,expr,off));
+        Node load = P.peep(new LoadNode(P.loc(),name,alias,P.ctrl(),mem,expr,off));
 
         // Check for assign-update, "ptr.fld += expr" or "ary[idx]++"
         char ch = pre==0 ? P._lexer.matchOperAssign() : (char)pre;
         if( ch!=0 ) {
-            if( !P.construction.own(expr) ) P.construction.complete(expr,"write through an unfinished reference",site);
             if( fld!=null && decl==Type.BOTTOM )
                 throw P.error( "'" + ts._name + "' is not fully initialized, field '" + fld._fname + "' needs to be set in a constructor" );
             Node op = P.expressions.opAssign(ch,load, decl ).keep();
@@ -315,7 +303,10 @@ final class References {
         for( FRefNode fref : _frefs ) {
             if( fref.nIns() != 1 && fref._con == FRefNode.FREF_TYPE ) continue;
             CompUnit cu = ParseAll.findCompUnitOrThrow(P._code,P._ref,fref._name);
-            fref._con = TypeMemPtr.make((byte)2,TypeStruct.make(TypeStruct.addClzPrefix(cu._cname),true),true);
+            // Name lookup may already know this class's fields. Do not replace
+            // that information with an empty placeholder before Iter runs.
+            if( fref._con==FRefNode.FREF_TYPE )
+                fref.liftType(TypeMemPtr.make((byte)2,TypeStruct.make(TypeStruct.addClzPrefix(cu._cname),true),true));
             frefs.push(fref);
         }
 
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/parser/Structs.java b/chapter29/src/main/java/com/seaofnodes/simple/parser/Structs.java
index 3360d85e..a5262440 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/parser/Structs.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/parser/Structs.java
@@ -54,13 +54,16 @@ final class Structs {
             : TypeStruct.make(clzName,false,fld,ctorFld);
         if( flag!=null ) ts = ts.add(flag);
         TypeFunPtr alloc = P.allocations.makeAllocator((TypeStruct)Parser.TYPES.get(fullName),ret,ctorFld);
+        // The visible constructor name denotes allocation, not the hidden initializer.
+        sig = alloc;
+        ts = ts.replace(fld.makeFrom(alloc));
         ts = ts.add(Field.make("<new>",alloc,P._code.alias(P._ref._cname),true));
         Parser.TYPES.put(clzName,ts);
 
         // Insert a field in the containing class with the nested class type.
-        // This is basically sugar for "val CLZNAME = <init>"
+        // This is basically sugar for "val CLZNAME = <new>"
         // and is a nicer version of updateSelfAsFieldsDiscovered.
-        P._scope.define(typeName, sig, true, new FunPtrNode(sig,P._code._start,ret).peephole(), P.loc());
+        P._scope.define(typeName, sig, true, new FunPtrNode(sig,P._code._start,P._code.link(alloc).ret()).peephole(), P.loc());
         Var binding = P._scope.lookup(typeName);
         declareField(binding,P._scope.in(binding),false);
 
@@ -256,42 +259,6 @@ final class Structs {
         P.functions._returnScope.mem(mmm);
     }
 
-    // addReturn already merged every exit. Inspect the completed helpers,
-    // after parsing has discovered all fields and torn down their scopes.
-    void checkInitFields() {
-        P._code._stop.walk(n -> {
-            if( n instanceof ReturnNode ret && ret.fun().isInstance() ) checkInitFields(ret);
-            return null;
-        });
-    }
-
-    private void checkInitFields(ReturnNode init) {
-        if( init.ctrl()._type.isHigh() || init.expr()._type.isHigh() ) return;
-        TypeStruct ts = ((TypeMemPtr)init.fun().sig().arg(0))._obj;
-        TypeStruct clz = (TypeStruct)Parser.TYPES.get(TypeStruct.addClzPrefix(ts._name));
-        Field ctor = clz==null ? null : clz.field("<ctor>");
-        // The older same-named function binding is parsed immediately, so
-        // fields declared after it are supplied by the declaration initializer.
-        Field legacy = ts.field(initFieldName(ts._name));
-        if( ctor!=null ) checkInitFields(ts,init,P._code.link((TypeFunPtr)ctor._t).ret());
-        if( legacy!=null && legacy._t instanceof TypeFunPtr sig )
-            checkInitFields(ts,init,P._code.link(sig).ret());
-        else if( ctor==null ) checkInitFields(ts,init,init);
-    }
-
-    private void checkInitFields(TypeStruct ts, ReturnNode init, ReturnNode ret) {
-        if( ret.ctrl()._type.isHigh() || ret.expr()._type.isHigh() ) return;
-        for( Field fld : ts._fields ) {
-            if( fld._extern ) continue;
-            Type mem = ret.expr()._type;
-            Field actual = mem instanceof TypeMem tm && tm._t instanceof TypeStruct shape ? shape.field(fld._fname) : null;
-            if( actual==null || actual._t==TypeScalar.BOT || actual._t==Type.BOTTOM )
-                throw Parser.error("'"+ts._name+"' is not fully initialized, field '"+fld._fname+
-                                   (ret==init ? "' needs to be set in a constructor" :
-                                                "' is only partially set in the constructor"),ret.fun()._loc);
-        }
-    }
-
     // Instance declarations establish field metadata and emit their default
     // Stores immediately. Required fields emit no Store until assigned.
     void declareField(Var var, Node value, boolean uninit) {
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/type/TypeMem.java b/chapter29/src/main/java/com/seaofnodes/simple/type/TypeMem.java
index c72740a9..79543e56 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/type/TypeMem.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/type/TypeMem.java
@@ -99,6 +99,16 @@ public class TypeMem extends Type {
     public TypeMem escapesFrom(Type t) {
         return make(_alias,_t,_one,_clz,_final, escapeFIDX(_escFs,t), escapeAlias(_escAs,t));
     }
+    // An opaque external object can expose the public interface and whatever
+    // private values have already escaped. It cannot invent access to other
+    // private definitions here. The caller supplies FULL until local forward
+    // types are resolved. Ordinary unknown values still require FULL.
+    public TypeMem escapesFrom(Type t, TypeMem defaults) {
+        TypeStruct ts = t instanceof TypeMemPtr ptr ? ptr._obj : t instanceof TypeStruct obj ? obj : null;
+        if( ts!=null && ts._open && ts._fref && !ts.isAry() )
+            return makeFrom(XInt.meet(_escFs,defaults._escFs),XInt.meet(_escAs,defaults._escAs));
+        return escapesFrom(t);
+    }
     public TypeMem escapesAliases(Type t) {
         return make(_alias,_t,_one,_clz,_final, _escFs, escapeAlias(_escAs,t));
     }
diff --git a/chapter29/src/main/java/com/seaofnodes/simple/type/TypeStruct.java b/chapter29/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
index d0ac55aa..d699e365 100644
--- a/chapter29/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
+++ b/chapter29/src/main/java/com/seaofnodes/simple/type/TypeStruct.java
@@ -123,13 +123,11 @@ public class TypeStruct extends Type {
         return (_fidxs = xs);
     }
 
-    // With a user constructor, the same-named function field is the hidden
-    // default <init> allocation helper, not part of the public class surface.
+    // Hidden initializer/constructor helpers receive private memory. Only the
+    // allocator has a source-callable signature; TypeMem is not a source type.
     public boolean hiddenInit(Field fld) {
-        if( field("<ctor>") == null || !startsClzPrefix(_name) ) return false;
-        int idx = _name.lastIndexOf('.');
-        String name = _name.substring(idx<0 ? CLZ.length() : idx+1);
-        return fld._fname.equals(name);
+        return fld._t instanceof TypeFunPtr tfp && tfp.nargs()>=2 &&
+            tfp.arg(1) instanceof TypeMem;
     }
 
     // New open struct with no fields
-- 
cgit v1.2.3