ASTAssign.java

public class ASTAssign implements ASTNode {
    ASTNode lhs, rhs;

    public ASTAssign(ASTNode l, ASTNode r) {
        lhs = l;
        rhs = r;
    }
    
    @Override
    public IValue eval(Environment<IValue> e) throws InterpreterError {
        IValue rval = rhs.eval(e);
        IValue lval = lhs.eval(e);

        // addr(A)
        if (lval instanceof MemoryManager.VAddress addr) {
            try {
                ASTLet.mem.memwrt(addr, rval);
                return rval;
            } catch (MemoryPanicError ex) {
                throw new InterpreterError("addr: " + ex.getMessage());
            }
        }

        // ref(A)
        if (lval instanceof VCell cell) {
            cell.setval(rval);
            return rval;
        }

        // mut
        if (lhs instanceof ASTId astId) {
            IValue raw = astId.evalLValue(e);
            if (raw instanceof VMut mut) {
                try {
                    ASTLet.mem.memwrt(mut.getAddr(), rval);
                    return rval;
                } catch (MemoryPanicError ex) {
                    throw new InterpreterError("mut: " + ex.getMessage());
                }
            }
        }

        throw new InterpreterError("left side of := must be a mutable, addr, or ref");
    }

    @Override
    public ASTType typecheck(Environment<ASTType> e) throws TypeCheckError, InterpreterError {
        ASTType rvalType = rhs.typecheck(e);
        
        ASTType l;
        if (lhs instanceof ASTId astId) {
            l = astId.typecheckLValue(e);
        } else {
            l = lhs.typecheck(e);
        }
        
        ASTType defL = ASTTypeDef.unfold(l, e);

        if (defL instanceof ASTTAddr addr) {
            if (!rvalType.subtypeOf(addr.getType(), e) || !addr.getType().subtypeOf(rvalType, e)) {
                throw new TypeCheckError("Type mismatch in assignment to address: cannot assign " + rvalType.toStr() + " to " + defL.toStr());
            }
            return rvalType;
        }
        
        if (defL instanceof ASTTMut mut) {
            if (!rvalType.subtypeOf(mut.getInner(), e)) {
                throw new TypeCheckError(":=: type mismatch for mut variable - " + rvalType.toStr() + " is not a subtype of " + mut.getInner().toStr());
            }
            return rvalType;
        }
        
        if (defL instanceof ASTTRef ref) {
            if (!rvalType.subtypeOf(ref.getType(), e)) {
                throw new TypeCheckError(":=: type mismatch for ref - " + rvalType.toStr() + " is not a subtype of " + ref.getType().toStr());
            }
            return rvalType; 
        }
            
        throw new TypeCheckError(":=: left side must be a ref or a mut variable");
    }

    @Override
    public boolean isFreeOutsideLambda(String id) {
        return lhs.isFreeOutsideLambda(id) || rhs.isFreeOutsideLambda(id);
    }

}