Better error messagesch30

Better error messages.
Buffs to the std lib; getch() to fetch a single character; streaming I/O handles retries, and large sizes, with better error reporting.
Formatted strings.
Default int moved to i32.
TicTacToe, the game.

12 files changed, 315 insertions, 90 deletions

diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Allocations.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Allocations.java
index be68e10e..861f95b6 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Allocations.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Allocations.java
@@ -14,28 +14,30 @@ final class Allocations {
        Parse an allocation
      */
     Node parseNew() {
+        P._lexer.skipWhiteSpace();
+        Lexer site=P.loc();
         Type t = P.types.parseType();
         if( t==null ) {
             String tname = P._lexer.matchId();
             if( tname==null || Parser.KEYWORDS.contains(tname) )
-                throw P.error("Expected a type");
+                throw Parser.error("Expected a type after 'new'",site);
             t = P.types.forwardRefType(tname);
         }
         // Parse ary[ length_expr ]
         if( P.match("[") ) {
             if( !t.makeZero().isa(t) )
-                throw P.error("Cannot allocate a non-nullable, since arrays are always zero/null filled");
+                throw Parser.error("Cannot allocate a non-nullable, since arrays are always zero/null filled",site);
             Node len = P.expressions.parseAssignment().keep();
             P.require("]");
             return allocArray(P.types.typeAry(t,false),len);
         } else {
             if( !(t instanceof TypeMemPtr tmp) )
-                throw P.error("Cannot allocate a "+t.str());
-            return allocStruct(tmp._obj);
+                throw Parser.error("Cannot allocate a "+t.str(),site);
+            return allocStruct(tmp._obj,site);
         }
     }
 
-    private Node allocStruct(TypeStruct ts) {
+    private Node allocStruct(TypeStruct ts, Lexer site) {
         Ary<Node> ctorArgs = constructorArgs();
         // A field declaration can leave a short forward type name in TYPES.
         // Allocation happens in lexical context, so resolve that short name
@@ -45,7 +47,7 @@ final class Allocations {
         if( resolved instanceof TypeStruct rts ) ts = rts;
         TypeStruct clz = (TypeStruct)Parser.TYPES.get(TypeStruct.addClzPrefix(typeName));
         if( clz==null )
-            throw P.error("Unknown struct type '" + ts._name + "'");
+            throw Parser.error("Unknown struct type '" + ts._name + "'",site);
         Field afld = clz.field("<new>");
         Node alloc;
         if( afld != null ) {
@@ -56,7 +58,7 @@ final class Allocations {
                 : new FunPtrNode(tfp,P._code._start,fun.ret()).peephole();
         } else {
             if( !ts._fref )
-                throw P.error("Constructor arguments for '" + ts._name + "' but no constructor is defined");
+                throw Parser.error("Constructor arguments for '" + ts._name + "' but no constructor is defined",site);
             Type[] sig = new Type[ctorArgs._len];
             for( int i = 0; i<ctorArgs._len; i++ )
                 sig[i] = ctorArgs.at(i)._type;
@@ -111,12 +113,12 @@ final class Allocations {
         return self.unkeep();
     }
 
-    Node newString(String s) {
+    Node newString(byte[] s) {
         TypeStruct ts = P.types.typeAry(TypeInteger.U8,true);
         int  lenAlias = ts.field("#" )._alias;
         int elemAlias = ts.field("[]")._alias;
         TypeConAryB body = TypeConAryB.make(s);
-        TypeInteger slen = TypeInteger.constant(s.length());
+        TypeInteger slen = TypeInteger.constant(s.length);
         // Make a TMP, not-null (byte)2, singleton (true) (requires text
         // strings are hash-interned), with a TypeStruct having a constant
         // array body.
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/ControlFlow.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/ControlFlow.java
index caa73076..6c626669 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/ControlFlow.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/ControlFlow.java
@@ -14,6 +14,8 @@ final class ControlFlow {
 
     // Parse a conditional expression, merging results.
     Node conditional( Node pred, String fside ) {
+        Lexer site=P.loc();
+        if( !fside.equals("else") ) site._position-=fside.equals(":") ? 1 : 2;
         // IfNode takes current control and predicate
         pred.keep();
         Node ifNode = new IfNode(P.ctrl(), pred).peephole();
@@ -88,7 +90,7 @@ final class ControlFlow {
         Node ret = P.peep(new PhiNode("",r,lhs.unkeep(),rhs.unkeep()));
         // Immediately fail e.g. `arg ? 7 : ptr`
         ParseException err;
-        if( !fside.equals("else") && (err = ret.err()) !=null ) throw err;
+        if( !fside.equals("else") && (err = ret.err()) !=null ) throw Parser.error(err.getMessage(),site);
         ret.keep();
         r.peephole();
         return ret.unkeep();
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Declarations.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Declarations.java
index 91955197..13fa59b8 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Declarations.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Declarations.java
@@ -47,15 +47,17 @@ final class Declarations {
         boolean inferType = t==Type.TOP || t==Type.BOTTOM;
         boolean xfinal = bindingFinal(t);
         Lexer loc = P.loc();
-        String name = P.requireId();
+        String name = P.requireId(P._scope.klast() instanceof Kind.Func fun && FunNode.isInit(fun._name));
         // Optional initializing expression follows
         boolean fld_final = false; // Field is final, but not deeply final
         boolean uninit = false;    // Required non-null constructor field
         Node expr;
         if( P.match("=") ) {
+            P._lexer.skipWhiteSpace();
+            Lexer initializer=P.loc();
             if( isExternDecl() ) {
                 if( !(t instanceof TypeFunPtr) ) {
-                    Node ptr = externData(name,t);
+                    Node ptr = externData(name,t,loc);
                     // The lexical binding is a fixed address; its contents are mutable.
                     if( !P._scope.define(name,t,true,ptr,loc) )
                         throw Parser.error("Redefining name '"+name+"'",loc);
@@ -72,8 +74,12 @@ final class Declarations {
             // var/val, then type comes from expression
             if( inferType ) {
                 if( expr._type==Type.NIL )
-                    throw P.error("a not-null/non-zero expression");
+                    throw Parser.error("Cannot infer a type from null; declare a nullable type explicitly",initializer);
                 t = expr._type;
+                // A typed expression may still await a forward callee's flow
+                // type (e.g. interpolation while sys.text is parsed). Its
+                // checked conversion already supplies a binding/storage type.
+                if( t==Type.BOTTOM && expr instanceof ConvertNode convert ) t=convert.dst();
                 if( !xfinal ) t = Conversions.mutableInferredType(t);
                 // Instance fields may change until the constructor finishes.
                 // Keep the declared family/access, not the default's constant
@@ -133,8 +139,7 @@ final class Declarations {
     // Just after parsing "type foo = " can parse `"C"`
     private boolean isExternDecl( ) {
         int old = P.pos();
-        String s = P._lexer.parseString();
-        if( "C".equals(s) ) return true;
+        if( P.match("\"C\"") ) return true;
         P.pos(old);
         return false;
     }
@@ -151,14 +156,14 @@ final class Declarations {
 
     // A lexical C binding has a singleton namespace with one external field.
     // The namespace occupies no storage; its field offset supplies the address.
-    private Node externData(String name, Type t) {
+    private Node externData(String name, Type t, Lexer site) {
         if( !(t instanceof TypeInteger) && !(t instanceof TypeFloat) )
-            throw P.error("C data binding requires an integer or float type");
+            throw Parser.error("C data binding requires an integer or float type",site);
         String cname = ("C:"+name).intern();
         TypeStruct ts = TypeStruct.make(cname,false,Field.make(name,t,P._code.externAlias(name),false,true));
         Type old = Parser.TYPES.putIfAbsent(cname,ts);
         if( old!=null && old!=ts )
-            throw P.error("Conflicting types for C data '"+name+"'");
+            throw Parser.error("Conflicting types for C data '"+name+"'",site);
         return P.con(TypeMemPtr.make((byte)2,ts,true));
     }
 }
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Expressions.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Expressions.java
index 93c07d8a..247d974e 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Expressions.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Expressions.java
@@ -15,6 +15,8 @@ final class Expressions {
     /** Parse: [name '='] expr
      */
     Node parseAssignment() {
+        P._lexer.skipWhiteSpace();
+        Lexer site=P.loc();
         int old = P.pos();
         String name = P._lexer.matchId();
         // Just a plain expression, no assignment.
@@ -24,13 +26,16 @@ final class Expressions {
 
         // Find variable to update
         Var def = P._scope.lookup(name);
-        if( def==null )
+        if( def==null ) {
+            P.pos(old);
+            P._lexer.skipWhiteSpace();
             throw P.error("Undefined name '" + name + "'");
+        }
 
         if( def._extern!=0 )    // Parse the C binding as a memory lvalue
             {  P.pos(old);  return parseExpression();  }
 
-        P.references.checkAssignment(def);
+        P.references.checkAssignment(def,site);
         return P.references.assign(def,parseAssignment());
     }
 
@@ -117,6 +122,8 @@ final class Expressions {
         Node cmp = makeCompBool(dir,lhs.unkeep(),rhs).keep(); // Convert to a bool
 
         // Stacked compares?
+        P._lexer.skipWhiteSpace();
+        Lexer operator=P.loc();
         int dir0 = parseCompDir();
         if( dir0 == 0 ) {
             rhs.unkill();
@@ -137,7 +144,7 @@ final class Expressions {
         // compares (LHS:b < RHS:c) then (LHS:c < RHS:d), etc.
         while( dir0 != 0 ) {
             if( Math.abs(dir) != Math.abs(dir0) )
-                throw P.error("Mixing relational directions in a chained relational test");
+                throw Parser.error("Mixing relational directions in a chained relational test",operator);
             // True side parses next arm of test
             P.ctrl(ifT.unkeep());
             lhs = rhs;          // Reuse the previous RHS exactly once
@@ -150,6 +157,8 @@ final class Expressions {
             P.ctrl(ifF);
             fail.mergeScopes(P._scope.dup(), P.loc()).peephole();
             // Check next stacked compare
+            P._lexer.skipWhiteSpace();
+            operator=P.loc();
             dir0 = parseCompDir();
         }
         rhs.unkill();
@@ -185,9 +194,11 @@ final class Expressions {
     private Node parseShift() {
         Node lhs = parseAddition();
         while( true ) {
-            if( P.match("<<") ) lhs = new ShlNode(P.loc(),lhs,null);
-            else if( P.match(">>>")) lhs = new ShrNode(P.loc(),lhs,null);
-            else if( P.match(">>") ) lhs = new SarNode(P.loc(),lhs,null);
+            P._lexer.skipWhiteSpace();
+            Lexer site=P.loc();
+            if( P.match("<<") ) lhs = new ShlNode(site,lhs,null);
+            else if( P.match(">>>")) lhs = new ShrNode(site,lhs,null);
+            else if( P.match(">>") ) lhs = new SarNode(site,lhs,null);
             else break;
             lhs.setDef(2,parseAddition());
             ParseException err;
@@ -251,12 +262,14 @@ final class Expressions {
         int old = P.pos();
         if( P.match("--") || P.match("++") ) {
             int delta = P._lexer.peek(-1)=='+' ? 1 : -1; // Inc vs Dec
+            P._lexer.skipWhiteSpace();
             int start = P.pos();
+            Lexer site=P.loc();
             String name = P._lexer.matchId();
             Var var = name==null ? null : P._scope.lookup(name);
             if( var!=null && !(var.type() instanceof TypeMemPtr) ) {
                 if( var._extern==0 && var._final && !P._scope.canInit(var) )
-                    throw P.error("Cannot reassign final '"+var._name+"'");
+                    throw Parser.error("Cannot reassign final '"+var._name+"'",site);
                 // Resolve fields just as a read or postfix update does. Updating
                 // their declaration's local slot would silently lose the Store.
                 P.pos(start);
@@ -286,7 +299,7 @@ final class Expressions {
     // pre is +/-1 for a prefix update of a known name, zero otherwise.
     private Node parsePrimary(int pre) {
         if( P._lexer.isNumber(P._lexer.peek()) ) return parseLiteral();
-        if( P._lexer.peek('"') ) return parsePostfix(P.allocations.newString(P._lexer.parseString()));
+        if( P._lexer.peek('"') ) return parsePostfix(P.strings.parse());
         if( P.matchx("true" ) ) return P.con(1);
         if( P.matchx("false") ) return P._code.ZERO;
         if( P.matchx("null" ) ) return P.con(Type.NIL);
@@ -298,8 +311,10 @@ final class Expressions {
         int pos = P.pos();
         // Expect an identifier now
         String id = P._lexer.matchId();
-        if( id == null || Parser.KEYWORDS.contains(id) )
+        if( id == null || Parser.KEYWORDS.contains(id) ) {
+            P.pos(pos);
             throw P.errorSyntax("an identifier or expression");
+        }
         int pos2 = P.pos();
         return P.references.parseName(id,pre,pos,pos2);
     }
@@ -366,7 +381,11 @@ final class Expressions {
         P._lexer.skipWhiteSpace();
         Lexer site = P.loc();
         String name;
-        if( P.match(".") )      name = P.requireId();
+        if( P.match(".") ) {
+            P._lexer.skipWhiteSpace();
+            site=P.loc();
+            name = P.requireId(true);
+        }
         else if( P.match("#") ) name = "#";
         else if( P.match("[") ) name = "[]";
         // Can get here without an explicit receiver: "f()" or
@@ -389,6 +408,6 @@ final class Expressions {
 
     // Already parsed "'"
     Node parseChar() {
-        return P.require(P.con(TypeInteger.constant(P._lexer.parseChar())),"'");
+        return P.con(TypeInteger.constant(P._lexer.parseChar()));
     }
 }
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Functions.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Functions.java
index 14dee33b..5175acc6 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Functions.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Functions.java
@@ -73,14 +73,19 @@ final class Functions {
         while( true ) {
             Type t = P.types.parseType();    // Arg type
             if( t==null ) break;
+            P._lexer.skipWhiteSpace();
+            Lexer qualifier=P.loc();
             if( P.match("^") ) {
                 if( !(t instanceof TypeMemPtr ptr) || ptr._obj.isAry() )
-                    throw P.error("'^' requires a struct parameter");
+                    throw Parser.error("'^' requires a struct parameter",qualifier);
                 t = ptr.withPartial(true);
                 P.construction._borrowed = true;
             }
             finals.set(ids.size(),P.declarations.bindingFinal(t));
+            P._lexer.skipWhiteSpace();
+            Lexer nameLoc=P.loc();
             String id = P.requireId();
+            if( ids.find(id)!=-1 ) throw Parser.error("Duplicate parameter '"+id+"'",nameLoc);
             ts .push(t );       // Push type/arg pairs
             ids.push(id);
             P.match(",");
@@ -98,7 +103,7 @@ final class Functions {
         Lexer site = P.loc();
         site._position--; // Opening '('; arguments can contain nested calls.
         if( fcn._type == Type.NIL )
-            throw P.error("Calling a null function pointer");
+            throw Parser.error("Calling a null function pointer",site);
         fcn.keep();            // Keep while parsing args
 
         Ary<Node> args = new Ary<>( Node.class );
@@ -207,6 +212,9 @@ final class Functions {
 
         int oldUID = P._code.UID(); // Used to approximate function size
         FunNode fun = enterFunction(funName,sig,loc,finals,ids);
+        // Guards belong to this function's control flow. Do not inherit an
+        // enclosing function's predicates or leak this body's guards on exit.
+        P._scope.addGuards(fun,null,false);
         Construction.Frame outerConstruction = P.construction.enter(fun,isCtor && !fun.isClz());
         Node rpc = fun.parm(0);
         if( fun.isClz() ) P.structs.beginClassInit(fun,loc);
@@ -260,6 +268,7 @@ final class Functions {
         P._ref.addFun(P._code,fun);
 
         // Unstack parser state
+        P._scope.removeGuards(fun);
         if( _returnScope != null ) _returnScope.kill();
         _returnScope   =   returnScope;
         P.statements._continueScope = continueScope;
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Lexer.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Lexer.java
index ec88738b..5e4b7311 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Lexer.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Lexer.java
@@ -3,10 +3,12 @@ package com.seaofnodes.simple.parser;
 import com.seaofnodes.simple.codegen.CodeGen;
 import com.seaofnodes.simple.codegen.CompUnit;
 import com.seaofnodes.simple.codegen.Serialize;
+import com.seaofnodes.simple.codegen.SourceError;
 import com.seaofnodes.simple.parser.Parser.ParseException;
 import com.seaofnodes.simple.type.*;
 import com.seaofnodes.simple.util.BAOS;
 import java.util.HashMap;
+import java.io.ByteArrayOutputStream;
 
 // Lexer provides low level access to the raw file bytes, peeks and matches
 // short strings, parses numbers, skips comments and whitespace, tracks
@@ -35,6 +37,11 @@ public class Lexer {
     public String position() { return _line_number+":"+(_position-_line_start+1); }
     public int pos() { return _position; }
 
+    public String diagnostic(String message) {
+        return _cu==null ? SourceError.format("<input>",_input,_position,message)
+            : SourceError.format(_cu,_position,message);
+    }
+
     /**
      * Record the source text for lexing
      */
@@ -143,19 +150,21 @@ public class Lexer {
         while( true ) {
             if( isWhiteSpace() ) inc();
             // Skip // to end of line
-            else if( _position+2 < _input.length &&
+            else if( _position+1 < _input.length &&
                      _input[_position  ] == '/' &&
                      _input[_position+1] == '/') {
                 inc(); inc();
                 while( !isEOF() && _input[_position] != '\n' )
                     inc();
-            } else if( _position+2 < _input.length &&
+            } else if( _position+1 < _input.length &&
                      _input[_position  ] == '/' &&
                      _input[_position+1] == '*') {
-                // Skip /*comment*/
-                while( !isEOF() && !(_input[_position-1] == '*' && _input[_position] == '/'))
+                Lexer start=new Lexer(this);
+                inc(); inc();
+                while( !isEOF() && !(peek()=='*' && _position+1<_input.length && peek(1)=='/') )
                     inc();
-                inc();
+                if( isEOF() ) throw Parser.error("Unclosed block comment",start);
+                inc(); inc();
             } else break;
         }
     }
@@ -229,20 +238,27 @@ public class Lexer {
 
     // Return a constant Type, either TypeInteger or TypeFloat
     Type parseNumber() {
+        Lexer start=new Lexer(this);
         int old = _position;
         int len = isLongOrDouble();
         boolean f32 = peek()=='f';
         if( f32 ) nextChar();
         int n = Math.abs(len);
-        if( f32 )
-            return TypeFloat.constant(Float.parseFloat(new String(_input,old,n)));
-        if( len > 0 ) {
-            if( len > 1 && _input[old]=='0' )
-                throw Parser.error("Syntax error: integer values cannot start with '0'",this);
-            long i = Long.parseLong(new String(_input,old,len));
-            return TypeInteger.constant(i);
+        String literal=new String(_input,old,n);
+        try {
+            if( f32 )
+                return TypeFloat.constant(Float.parseFloat(literal));
+            if( len > 0 ) {
+                if( len > 1 && _input[old]=='0' )
+                    throw Parser.error("Syntax error: integer values cannot start with '0'",start);
+                long i = Long.parseLong(literal);
+                return TypeInteger.constant(i);
+            }
+            return TypeFloat.constant(Double.parseDouble(literal));
+        } catch( NumberFormatException ex ) {
+            throw Parser.error(len>0 && !f32 ? "Integer literal is outside the signed 64-bit range"
+                : "Invalid floating-point literal '"+literal+(f32 ? "f" : "")+"'",start);
         }
-        return TypeFloat.constant(Double.parseDouble(new String(_input,old,n)));
     }
     private String parseNumberString() {
         int old = _position;
@@ -319,25 +335,77 @@ public class Lexer {
         return 0;
     }
 
-    String parseString() {
-        if( !peek('"') ) return null;
-        inc();
-        StringBuilder sb = new StringBuilder();
+    record StringPart(byte[] text, boolean end) {}
+
+    // Opening quote has been consumed. Leave a format's '%' unread so both
+    // the expression parser and deferred-body scanner use the same grammar.
+    StringPart stringPart(Lexer start) {
+        ByteArrayOutputStream sb = new ByteArrayOutputStream();
         while( !isEOF() ) {
             char c = nextChar();
-            if( c=='"' ) return sb.toString();
+            if( c=='"' ) return new StringPart(sb.toByteArray(),true);
+            if( c=='%' ) {
+                if( peek()=='%' ) { inc(); sb.write('%'); continue; }
+                _position--;
+                return new StringPart(sb.toByteArray(),false);
+            }
             if( c!='\\' ) {
-                sb.append(c);
+                sb.write(c);
                 continue;
             }
             if( isEOF() )
-                throw error("Unclosed string");
-            sb.append(escapedChar("string"));
+                throw Parser.error("Unclosed string",start);
+            sb.write(escapedChar("string"));
         }
-        throw error("Unclosed string");
+        throw Parser.error("Unclosed string",start);
+    }
+
+    record Format(int kind, int flags, int width, int precision, Lexer site) {}
+
+    Format stringFormat() {
+        Lexer site = new Lexer(this);
+        assert peek()=='%';
+        inc();
+        if( peek()=='(' ) { inc(); return new Format(0,0,0,-1,site); }
+        int flags=0, bit;
+        while( (bit="-+ #0".indexOf(peek()))>=0 ) {
+            int mask=1<<bit;
+            if( (flags&mask)!=0 ) throw Parser.error("Repeated format flag",site);
+            flags |= mask;
+            inc();
+        }
+        int width = formatNumber(site);
+        int precision = -1;
+        if( peek()=='.' ) {
+            inc();
+            precision = formatNumber(site);
+        }
+        char kind=nextChar();
+        if( "diuoxXfFeEgGaAcsb".indexOf(kind)<0 )
+            throw Parser.error("Expected a string format: %(expression), %d(expression), or %%",site);
+        boolean number="diuoxXfFeEgGaA".indexOf(kind)>=0;
+        if( !number && (flags&~1)!=0 || "uoxX".indexOf(kind)>=0 && (flags&6)!=0 ||
+            "diu".indexOf(kind)>=0 && (flags&8)!=0 )
+            throw Parser.error("Invalid flags for %"+kind,site);
+        if( precision>=0 && (kind=='c' || kind=='b') )
+            throw Parser.error("Precision is not supported for %"+kind,site);
+        if( peek()!='(' ) throw Parser.error("Expected '(' after string format %"+kind,site);
+        inc();
+        return new Format(kind,flags,width,precision,site);
+    }
+
+    private int formatNumber(Lexer site) {
+        long n=0;
+        while( peek()>='0' && peek()<='9' ) {
+            n=n*10+nextChar()-'0';
+            if( n>Integer.MAX_VALUE ) throw Parser.error("String format width or precision is too large",site);
+        }
+        return (int)n;
     }
 
     private char escapedChar(String kind) {
+        Lexer start=new Lexer(this);
+        start._position--; // The backslash introducing the escape.
         char esc = nextChar();
         return switch( esc ) {
         case '0'  -> '\u0000';
@@ -347,17 +415,24 @@ public class Lexer {
         case '\\' -> '\\';
         case '"'  -> '"';
         case '\'' -> '\'';
-        default -> throw error("Unknown "+kind+" escape \\\\"+esc);
+        case '%'  -> '%';
+        default -> throw Parser.error("Unknown "+kind+" escape \\"+esc,start);
         };
     }
 
     char parseChar() {
-        if( isEOF() ) throw error("Unclosed character");
+        Lexer start=new Lexer(this);
+        start._position--; // Opening quote was consumed by the caller.
+        if( isEOF() || peek()=='\n' || peek()=='\r' ) throw Parser.error("Unclosed character literal",start);
+        if( peek()=='\'' ) throw Parser.error("Empty character literal",start);
         char c = nextChar();
         if( c=='\\' ) {
-            if( isEOF() ) throw error("Unclosed character");
+            if( isEOF() ) throw Parser.error("Unclosed character literal",start);
             c = escapedChar("character");
         }
+        if( isEOF() || peek()=='\n' || peek()=='\r' ) throw Parser.error("Unclosed character literal",start);
+        if( peek()!='\'' ) throw Parser.error("Character literal must contain exactly one byte",start);
+        inc();
         return c;
     }
 
@@ -372,16 +447,18 @@ public class Lexer {
             if( isEOF() ) throw error("Unclosed "+what);
             char ch = peek();
             if( ch==close && depth==0 ) return;
+            Lexer site=ch=='"' ? new Lexer(this) : null;
             nextChar();
             if( ch==open ) depth++;
             else if( ch==close ) depth--;
-            else if( ch=='"' || ch=='\'' ) {
-                char quote = ch;
-                while( !isEOF() ) {
-                    ch = nextChar();
-                    if( ch=='\\' ) nextChar();
-                    else if( ch==quote ) break;
+            else if( ch=='"' ) {
+                while( !stringPart(site).end() ) {
+                    stringFormat();
+                    skipTo('(',')',"string interpolation");
+                    nextChar();
                 }
+            } else if( ch=='\'' ) {
+                parseChar();
             }
         }
     }
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Parser.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Parser.java
index 4d140e55..0cf3c0e7 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Parser.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Parser.java
@@ -24,6 +24,7 @@ public class Parser {
     final References references = new References(this);
     final Conversions conversions = new Conversions(this);
     final Construction construction = new Construction(this);
+    final Strings strings = new Strings(this);
 
     public void checkConstructionSerializable() { construction.checkSerializable(); }
 
@@ -106,7 +107,7 @@ public class Parser {
             put("i32" ,TypeInteger.I32);
             put("i64" ,TypeInteger.BOT);
             put("i8"  ,TypeInteger.I8 );
-            put("int" ,TypeInteger.BOT);
+            put("int" ,TypeInteger.I32);
             put("u1"  ,TypeInteger.U1 );
             put("u16" ,TypeInteger.U16);
             put("u32" ,TypeInteger.U32);
@@ -117,7 +118,8 @@ public class Parser {
 
     public static class ParseException extends RuntimeException {
         public final Lexer _loc;
-        ParseException( String msg, Lexer loc ) { super(msg);  _loc = loc; }
+        ParseException( String msg, Lexer loc ) { super(msg); _loc = loc==null ? null : new Lexer(loc); }
+        public String diagnostic() { return _loc==null ? getMessage() : _loc.diagnostic(getMessage()); }
     }
 
     public Parser(CodeGen code ) {
@@ -186,9 +188,18 @@ public class Parser {
 
     // Require and return an identifier
     String requireId() {
+        return requireId(false);
+    }
+
+    // Primitive names are useful member names (sys.text.int), but remain
+    // reserved for local variables, parameters and type declarations.
+    String requireId(boolean member) {
+        _lexer.skipWhiteSpace();
+        Lexer site=loc();
         String id = _lexer.matchId();
-        if (id != null && !KEYWORDS.contains(id) ) return id.intern();
-        throw error("Expected an identifier, found '"+id+"'");
+        if (id != null && (!KEYWORDS.contains(id) || member &&
+            (INIT_TYPES.get(id) instanceof TypeInteger || INIT_TYPES.get(id) instanceof TypeFloat)) ) return id.intern();
+        throw error("Expected an identifier, found '"+new Lexer(site).getAnyNextToken()+"'",site);
     }
 
     String matchId() {
@@ -266,7 +277,9 @@ public class Parser {
 
     ParseException errorSyntax(String syntax) { return _errorSyntax("expected `"+syntax+"`");  }
     private ParseException _errorSyntax(String msg) {
-        return error("Syntax error, "+msg+" but found `" + _lexer.getAnyNextToken()+"`");
+        _lexer.skipWhiteSpace();
+        // Reading the token for the message must not advance the error location.
+        return error("Syntax error, "+msg+" but found `" + loc().getAnyNextToken()+"`");
     }
     ParseException error(String msg) { return error(msg,_lexer); }
     public static ParseException error(String msg, Lexer loc) { return new ParseException(msg,loc); }
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/References.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/References.java
index 483bd7a8..6335bad2 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/References.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/References.java
@@ -15,13 +15,36 @@ final class References {
 
     References(Parser P) { this.P = P; }
 
+    // Compiler-generated library references use ordinary module lookup and
+    // forward resolution, without a synthetic token stream.
+    Node classReference(String name, Lexer site) {
+        CompUnit cu=ParseAll.findCompUnit(P._code,P._ref,name);
+        if( cu==null ) throw Parser.error("Cannot find standard library '"+name+"'",site);
+        String clzName=TypeStruct.addClzPrefix(cu._cname);
+        TypeStruct clz=(TypeStruct)Parser.TYPES.computeIfAbsent(clzName,n -> TypeStruct.make(n,true));
+        FRefNode ref=new FRefNode(name,site,TypeMemPtr.make((byte)2,clz,true));
+        _frefs.push(ref);
+        return ref.peephole();
+    }
+
+    // Read a member without consuming a postfix from source text.
+    Node member(Node receiver, String name, Lexer site) {
+        Field fld=receiver._type instanceof TypeMemPtr ptr ? ptr._obj.field(name) : null;
+        return P.peep(new LoadNode(site,name,fld==null ? 1 : fld._alias,
+                                  P.ctrl(),P.mem(),receiver,P.fldoff(receiver,name)));
+    }
+
     // Resolve a primary name, retaining its use site before speculative type lookup.
     Node parseName(String id, int pre, int pos, int pos2) {
+        Lexer site=P.loc();
+        site._position=pos;
+        site.skipWhiteSpace();
         // Attempt a local var lookup first
         Var var = P._scope.lookup(id);
         if( var==null ) {
             // Not a local var, try again as a type name
             P.pos(pos);
+            Lexer nameLoc = P.loc();
             Type t = P.types.parseType();
             if( t!=null ) {
                 // Static <clinit> typename lookup
@@ -52,7 +75,7 @@ final class References {
                 t = TypeMemPtr.make((byte)2,clz,true);
             }
             // Define the FRef
-            var = P._scope.defineFRef(id,t,true,P.loc());
+            var = P._scope.defineFRef(id,t,true,nameLoc);
             P.references._frefs.push((FRefNode)P._scope.in(var));
         }
 
@@ -73,7 +96,7 @@ final class References {
         if( kx < fx && !P.structs.inExplicitConstructor() && // Out of scope
             !(var._final && rvalue._type.isConstant()) ) { // Not a final constant
             if( kx > 0  ) // Global scope is OK, only ever one of these (not one per function invoke)
-                throw P.error("Variable '"+var._name+"' is out of function scope and must be a final constant");
+                throw Parser.error("Variable '"+var._name+"' is out of function scope and must be a final constant",site);
 
             // var.idx==2 is self argument, 3 is args, 4 or more are now static globals
             if( var._idx >= 4 ) {
@@ -98,7 +121,7 @@ final class References {
         }
         // Assign-update direct into Scope
         if( var._final && !P._scope.canInit(var) )
-            throw P.error("Cannot reassign final '"+var._name+"'");
+            throw Parser.error("Cannot reassign final '"+var._name+"'",site);
         checkSharedFunction(var);
         Node op = P.expressions.opAssign(ch,rvalue, var.type() );
         P._scope.update(var,op);
@@ -106,14 +129,14 @@ final class References {
         return pre==0 && Lexer.postfix(ch) ? rvalue : op;
     }
 
-    void checkAssignment(Var def) {
+    void checkAssignment(Var def, Lexer site) {
         String name = def._name;
         // A final field may receive its first value in its constructor.
         if( P._scope.in(def._idx)._type!=Type.TOP && def._final &&
             // Inside an allocation, final assign is OK, outside nope.
             // The parseNew() call added the allocation scope
             !P._scope.canInit(def) )
-            throw P.error("Cannot reassign final '"+name+"'");
+            throw Parser.error("Cannot reassign final '"+name+"'",site);
         checkSharedFunction(def);
 
     }
@@ -201,7 +224,7 @@ final class References {
         if( fld==null && ts!=null )
             fld = P.types.fieldOrOpen(ts,name,false);
         if( fld==null && ts!=null && !P.types.latestStruct(ts)._open )
-            throw P.error("Accessing unknown field '"+name+"' from '*"+ts._name+"'");
+            throw Parser.error("Accessing unknown field '"+name+"' from '*"+ts._name+"'",site);
 
         // We have to record "active touches" of a new class, to track when we
         // need to force class initialization.  Basically, we insert an CLInit,
@@ -233,7 +256,7 @@ final class References {
             // Store to field
             mem.keep();
             if( !P.construction.own(expr) && expr._type instanceof TypeMemPtr view && view._ro && P.ctrl()._type!=Type.XCONTROL )
-                throw P.error("Cannot modify final field '"+name+"'");
+                throw Parser.error("Cannot modify final field '"+name+"'",site);
             Node st = new StoreNode(P.loc(), name, alias, decl, P.ctrl(), mem, expr.unkeep(), off.unkeep(), lift, P.construction.own(expr)).peephole().keep();
             P.construction.store(expr,alias,st,mem);
             st.unkeep();
@@ -250,17 +273,17 @@ final class References {
             decl = conary.elem();
 
         // Load field
-        Node load = P.peep(new LoadNode(P.loc(),name,alias,P.ctrl(),mem,expr,off));
+        Node load = P.peep(new LoadNode(site,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( fld!=null && decl==Type.BOTTOM )
-                throw P.error( "'" + ts._name + "' is not fully initialized, field '" + fld._fname + "' needs to be set in a constructor" );
+                throw Parser.error( "'" + ts._name + "' is not fully initialized, field '" + fld._fname + "' needs to be set in a constructor",site );
             Node op = P.expressions.opAssign(ch,load, decl ).keep();
             mem.keep();
             if( !P.construction.own(expr) && expr._type instanceof TypeMemPtr view && view._ro && P.ctrl()._type!=Type.XCONTROL )
-                throw P.error("Cannot modify final field '"+name+"'");
+                throw Parser.error("Cannot modify final field '"+name+"'",site);
             Node st = new StoreNode(P.loc(), name, alias, decl, P.ctrl(), mem, expr.unkeep(), off.unkeep(), op, P.construction.own(expr)).peephole().keep();
             P.construction.store(expr,alias,st,mem);
             st.unkeep();
@@ -302,7 +325,8 @@ final class References {
         Ary<FRefNode> frefs = new Ary<>(FRefNode.class);
         for( FRefNode fref : _frefs ) {
             if( fref.nIns() != 1 && fref._con == FRefNode.FREF_TYPE ) continue;
-            CompUnit cu = ParseAll.findCompUnitOrThrow(P._code,P._ref,fref._name);
+            CompUnit cu = ParseAll.findCompUnit(P._code,P._ref,fref._name);
+            if( cu==null ) throw fref.err();
             // 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 )
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Statements.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Statements.java
index 4ff4993b..707202ab 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Statements.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Statements.java
@@ -24,12 +24,14 @@ final class Statements {
      * @return a {@link Node} or {@code null}
      */
     Node parseStatement() {
+        P._lexer.skipWhiteSpace();
+        Lexer site=P.loc();
         if(      P.matchx("return")  ) return parseReturn();
         else if (P.matchx("if")      ) return parseIf();
         else if (P.matchx("while")   ) return parseWhile();
         else if (P.matchx("for")     ) return parseFor();
-        else if (P.matchx("break")   ) return parseBreak();
-        else if (P.matchx("continue")) return parseContinue();
+        else if (P.matchx("break")   ) return parseBreak(site);
+        else if (P.matchx("continue")) return parseContinue(site);
         else if (P.matchx("struct")  ) return P.structs.parseStruct();
         else if (P.structs.inStructDeclaration() && P.matchx("new")) return P.structs.parseConstructorDeclaration();
         else if (P.matchx(";")       ) return P._code.ZERO; // Empty statement
@@ -204,7 +206,7 @@ final class Statements {
         if( doFor ) {
             int old = P.pos(nextPos);
             if( !P.peek(')') )
-              P.expressions.parseAssignment();
+              P.expressions.parseAssignment().isKill();
             if( P.pos() != nextEnd )
                 throw P.errorSyntax( "Unexpected code after expression" );
             P.pos(old);
@@ -237,8 +239,8 @@ final class Statements {
         P._scope = exit;
         return P._code.ZERO;
     }
-    private Node parseBreak   () {
-        checkLoopActive();
+    private Node parseBreak(Lexer site) {
+        checkLoopActive(site);
         // At the time of the break, and loop-exit conditions are only valid if
         // they are ALSO valid at the break.  It is the intersection of
         // conditions here, not the union.
@@ -248,15 +250,20 @@ final class Statements {
         return P._code.ZERO;
     }
 
-    private Node parseContinue() { checkLoopActive(); _continueScope = P.require(jumpTo( _continueScope ),";"); return P._code.ZERO; }
+    private Node parseContinue(Lexer site) { checkLoopActive(site); _continueScope = P.require(jumpTo( _continueScope ),";"); return P._code.ZERO; }
 
     private ScopeNode jumpTo(ScopeNode toScope) {
         ScopeNode cur = P._scope.dup();
         P.ctrl(P._code.XCTRL); // Kill current scope
         // Prune nested lexical scopes that have depth > than the loop head
         // We use _breakScope as a proxy for the loop head scope to obtain the depth
+        // The clone shares lexical boundaries and Var records with the active
+        // parser scope. Promoting on the clone would move those boundaries
+        // without moving the active scope's bindings. Drop locals first, then
+        // copy forward references into the jump scope with their own indices.
         while( cur.depth() > _breakScope.depth() )
-            cur.pop();
+            cur._pop();
+        cur.balanceLoopFRefs(P._scope);
         // If this is a continue then first time the target is null
         // So we just use the pruned current scope as the base for the
         // "continue"
@@ -264,9 +271,13 @@ final class Statements {
             return cur;
         // toScope is either the break scope, or a scope that was created here
         assert toScope.depth() <= _breakScope.depth();
+        // A later path can discover forward references after an earlier
+        // break/continue saved its scope. Keep those bindings across the merge.
+        toScope.balanceLoopFRefs(cur);
+        cur.balanceLoopFRefs(toScope);
         toScope.ctrl(toScope.mergeScopes(cur,P.loc()).peephole());
         return toScope;
     }
 
-    private void checkLoopActive() { if (_breakScope == null) throw P.error("No active loop for a break or continue"); }
+    private void checkLoopActive(Lexer site) { if (_breakScope == null) throw Parser.error("No active loop for a break or continue",site); }
 }
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Strings.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Strings.java
new file mode 100644
index 00000000..5bf76585
--- /dev/null
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Strings.java
@@ -0,0 +1,59 @@
+package com.seaofnodes.simple.parser;
+
+import com.seaofnodes.simple.node.*;
+import com.seaofnodes.simple.type.*;
+import com.seaofnodes.simple.util.Ary;
+
+/** Interpolation expands to ordinary sys.text calls. The library itself uses
+ * no interpolation, so it can be compiled from source without staging. */
+final class Strings {
+    private final Parser P;
+    Strings(Parser p) { P=p; }
+
+    Node parse() {
+        Lexer start=P.loc();
+        P.require("\"");
+        Lexer.StringPart part=P._lexer.stringPart(start);
+        if( part.end() ) return P.allocations.newString(part.text());
+        Node text=P.references.classReference("sys.text",P.loc()).keep();
+        P.classInit(P.loc(),text);
+        Node builder=call(text,"begin",P.loc()).keep();
+        while( true ) {
+            if( part.text().length!=0 )
+                call(text,"string",P.loc(),builder,P.allocations.newString(part.text()),P.con('s'),P.con(0),P.con(-1)).isKill();
+            if( part.end() ) break;
+            Lexer.Format fmt=P._lexer.stringFormat();
+            Node value=P.expressions.parseAssignment().keep();
+            P.require(")");
+            Node fptr;
+            if( fmt.kind()==0 ) {
+                Node ints=P.references.member(text,"integer",fmt.site()).keep();
+                Node floats=P.references.member(text,"floating",fmt.site()).keep();
+                Node strings=P.references.member(text,"string",fmt.site()).keep();
+                fptr=new FormatNode(value,ints.unkeep(),floats.unkeep(),strings.unkeep(),fmt.site()).peephole();
+            } else {
+                String family="diuoxXcb".indexOf(fmt.kind())>=0 ? "integer" : fmt.kind()=='s' ? "string" : "floating";
+                fptr=P.references.member(text,family,fmt.site());
+            }
+            call(text,fptr,fmt.site(),builder,value.unkeep(),P.con(fmt.kind() | fmt.flags()<<8),
+                 P.con(fmt.width()),P.con(fmt.precision())).isKill();
+            part=P._lexer.stringPart(start);
+        }
+        // String syntax promises this result type even when sys.text is still
+        // awaiting its source parse. Check/convert through the normal IR.
+        Node result=call(text.unkeep(),"end",P.loc(),builder.unkeep());
+        return P.conversions.convertExpr(result,TypeMemPtr.make(P.types.typeAry(TypeInteger.U8,true)).makeRO());
+    }
+
+    private Node call(Node text, String name, Lexer site, Node... values) {
+        return call(text,P.references.member(text,name,site),site,values);
+    }
+
+    private Node call(Node text, Node fptr, Lexer site, Node... values) {
+        Ary<Node> args=new Ary<>(Node.class);
+        args.push(P.ctrl()); args.push(P.mem()); args.push(text);
+        for( Node value:values ) args.push(value);
+        args.push(fptr);
+        return P.functions.functionCall(args,site);
+    }
+}
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Structs.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Structs.java
index a5262440..3a3d894c 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Structs.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Structs.java
@@ -78,12 +78,14 @@ final class Structs {
     Node parseConstructorDeclaration() {
         TypeStruct self = P._scope.constructorSelf();
         assert self != null;
+        P._lexer.skipWhiteSpace();
+        Lexer site=P.loc();
         String name = P.requireId();
         String expect = initFieldName(self._name);
         if( name != expect )
-            throw P.error("Constructor name '" + name + "' must match type name '" + expect + "'");
+            throw Parser.error("Constructor name '" + name + "' must match type name '" + expect + "'",site);
         P.require("=");
-        if( _pendingCtor!=null ) throw P.error("Redefining constructor '"+name+"'");
+        if( _pendingCtor!=null ) throw Parser.error("Redefining constructor '"+name+"'",site);
         _pendingCtor = new Constructor(name,P.loc());
         // Parse the body after all field declarations are known, so self.x
         // and x resolve the same field even when x is declared below this body.
diff --git a/chapter30/src/main/java/com/seaofnodes/simple/parser/Types.java b/chapter30/src/main/java/com/seaofnodes/simple/parser/Types.java
index ffd3a0f4..827518fd 100644
--- a/chapter30/src/main/java/com/seaofnodes/simple/parser/Types.java
+++ b/chapter30/src/main/java/com/seaofnodes/simple/parser/Types.java
@@ -54,12 +54,14 @@ final class Types {
         // Nest arrays and '?' as needed
         Type t2 = t1;
         while( true ) {
+            P._lexer.skipWhiteSpace();
+            Lexer site=P.loc();
             if( P.match("?") ) {
                 if( t2 instanceof TypeMemPtr tmp ) {
-                    if( tmp.nullable() ) throw P.error("Type "+t2+" already allows null");
+                    if( tmp.nullable() ) throw Parser.error("Type "+t2+" already allows null",site);
                     t2 = tmp.makeNullable();
                 } else
-                    throw P.error("Type "+t0+" cannot be null");
+                    throw Parser.error("Type "+t0+" cannot be null",site);
             } else if( P.match("[~]") ) {
                 t2 = TypeMemPtr.make(typeAry(t2,true)).makeRO();
             } else if( P.match("[]") ) {