Replace panic("TODO: ...") with NotImplemented("...")

This produces easier to read stack traces and nicer/more-thought-out
error messages.  In general, it makes the output of the program seem
more professional because it doesn't appear to crash "randomly".

code/ast/ast.go

@@ -38,6 +38,9 @@ var (
 	BuiltinUint32  = BaseTyp("u32")
 	BuiltinUint64  = BaseTyp("u64")
 
+	// Undefined opererator
+	UndefinedOperator = Operator("<undefined>", "<undefined>", "_undefined_", Nullary, NonAssociative, InvalidPrec)
+
 	// Logical operators
 	BuiltinLogicalOr    = Operator("Logical Or", "or", "_or_", BinaryInfix, LeftAssociative, LogicalOrPrec)
 	BuiltinLogicalAnd   = Operator("Logical And", "and", "_and_", BinaryInfix, LeftAssociative, LogicalAndPrec)
@@ -188,6 +191,7 @@ func (l *TextLiteral) GetValue() Value   { return l.Value }
 type Type interface {
 	Node
 	ImplementsType()
+	Print() string
 }
 
 func (t *ArrayType) ImplementsType()     {}
@@ -196,6 +200,12 @@ func (t *NamedType) ImplementsType()     {}
 func (t *PointerType) ImplementsType()   {}
 func (t *BaseType) ImplementsType()      {}
 
+func (t *ArrayType) Print() string     { return "[]" + t.Element.Print() }
+func (t *ProcedureType) Print() string { return "()" /* TODO */ }
+func (t *NamedType) Print() string     { return t.Name.Literal }
+func (t *PointerType) Print() string   { return "^" + t.PointerTo.Print() }
+func (t *BaseType) Print() string      { return t.Name }
+
 type EnumItem interface {
 	Node
 	ImplementsEnumItem()

code/ast/operators.go

@@ -55,6 +55,7 @@ func (asc OpAssociation) String() string {
 }
 
 const (
+	InvalidPrec      OpPrecedence = -1
 	AssignmentPrec   OpPrecedence = 0
 	LogicalOrPrec    OpPrecedence = 10
 	LogicalAndPrec   OpPrecedence = 15

code/ast/section.go

@@ -109,6 +109,7 @@ func flattenTree(node Node, parent Node) []Node {
 		break // nothing to add
 
 	default:
+		utils.Errorf("Unhandled node type '%s' during AST flattening", utils.Typeof(n))
 		utils.InvalidCodePath()
 	}
 

code/bytecode/bytecode.go

@@ -345,7 +345,7 @@ func (p *Procedure) Extend(node ast.Node) {
 			p.Registers[n] = p.PrevResult
 		} else {
 			p.Registers[n] = Rg(p.AssignLocation(), typeFromAst(n.Expr.GetType()))
-			utils.NotImplemented("Bytecode generation for declaration without initialization")
+			utils.NotImplemented("bytecode generation for declaration without initialization")
 		}
 
 	case *ast.EvalStmt:
@@ -373,7 +373,7 @@ func (p *Procedure) Extend(node ast.Node) {
 				p.insertCast(rhs, rightType, expr.Type)
 				p.Instructions = append(p.Instructions, Inst(COPY, Unary(p.PrevResult, lhs)))
 			} else {
-				panic("TODO: Handle non-identifier expressions as the assignee in assignment")
+				utils.NotImplemented("bytecode generation for assignment to a non-identifier expression")
 			}
 
 			return
@@ -399,7 +399,7 @@ func (p *Procedure) Extend(node ast.Node) {
 				p.insertCast(tmps[i], n.Right[i].GetType(), e.Type)
 				p.Instructions = append(p.Instructions, Inst(COPY, Unary(p.PrevResult, lhs)))
 			} else {
-				panic("TODO: Handle non-identifier expressions as the assignee in assignment")
+				utils.NotImplemented("bytecode generation for assignment to a non-identifier expression")
 			}
 		}
 
@@ -470,7 +470,11 @@ func (p *Procedure) Extend(node ast.Node) {
 				op = DIVIDE
 			}
 		default:
-			panic("TODO: Unhandle expression type in bytecode generator")
+			utils.NotImplemented(
+				fmt.Sprintf(`Bytecode generation for infix "%s %s %s"`,
+					n.Left.GetType().Print(),
+					n.Operator.Literal,
+					n.Right.GetType().Print()))
 		}
 
 		out := Rg(p.AssignLocation(), typeFromAst(n.Type))
@@ -523,7 +527,8 @@ func (p *Procedure) Extend(node ast.Node) {
 		endRegister = out
 
 	default:
-		panic("TODO: Unhandled node type in bytecode.Generate")
+		utils.Errorf("Unhandled node type '%s' in bytecode generation", utils.Typeof(n))
+		utils.InvalidCodePath()
 	}
 
 	// set the result of this expression
@@ -548,7 +553,7 @@ func typeFromAst(t ast.Type) Type {
 	case ast.BuiltinText:
 		return Pointer // TODO: eventually text should be a pointer/length struct
 	default:
-		utils.NotImplemented("bytecode generation for for non-numeric/non-builtin types")
+		utils.NotImplemented("Bytecode generation for for non-numeric/non-builtin types")
 		return None
 	}
 }
@@ -580,6 +585,8 @@ func (p *Procedure) insertCast(in Register, from ast.Type, to ast.Type) {
 		p.Instructions = append(p.Instructions, cast)
 		p.PrevResult = out
 	default:
-		panic("TODO: unhandled type in insertCast")
+		utils.NotImplemented(
+			fmt.Sprintf(`Inserting implicit cast of %s to %s during bytecode generation`,
+				from.Print(), to.Print()))
 	}
 }

code/interpreter/interpreter.go

@@ -58,7 +58,7 @@ InstructionLoop:
 					registers[args.Out.Loc] = proc.Program.Data[args.Name]
 				}
 			case bc.UnaryArgs:
-				panic("TODO: Load data from pointer")
+				utils.NotImplemented("Loading data from a non-constant pointer during interpretation")
 				// registers[args.Out] = proc.Program.Constants[args.Left]
 			}
 		case bc.CALL:
@@ -196,7 +196,8 @@ InstructionLoop:
 			}
 
 		default:
-			panic("TODO: Unhandled opcode")
+			utils.Errorf("Unhandled opcode '%s' in interpreter", inst.Op)
+			utils.InvalidCodePath()
 		}
 	}
 

code/parser/parser.go

@@ -8,6 +8,7 @@ import (
 	"github.com/kestred/philomath/code/ast"
 	"github.com/kestred/philomath/code/scanner"
 	"github.com/kestred/philomath/code/token"
+	"github.com/kestred/philomath/code/utils"
 )
 
 // FIXME: The grammar feels like a hack because of the way functions are parsed
@@ -295,7 +296,8 @@ func (p *Parser) parseDeclaration() ast.Decl {
 		// parse mutable decl
 		p.next() // eat ":"
 		if p.tok != token.EQUALS {
-			panic("TODO: Handle typed declarations")
+			utils.NotImplemented("Parsing mutable declarations with explicit types")
+			return nil
 		}
 		p.expect(token.EQUALS)
 		expr := p.parseExpression()
@@ -307,9 +309,11 @@ func (p *Parser) parseDeclaration() ast.Decl {
 	p.expect(token.CONS)
 	switch p.tok {
 	case token.STRUCT:
-		panic("TODO: Handle structs")
+		utils.NotImplemented("Parsing struct declarations")
+		return nil
 	case token.MODULE:
-		panic("TODO: Handle modules")
+		utils.NotImplemented("Parsing module declarations")
+		return nil
 	default:
 		expr := p.parseExpression()
 		if _, isFunc := expr.(*ast.ProcedureExpr); !isFunc {
@@ -323,9 +327,9 @@ func (p *Parser) parseStatement() ast.Stmt {
 	if p.tok.IsKeyword() {
 		switch p.tok {
 		case token.FOR:
-			panic("TODO: Handle if conditions (in parser)")
+			utils.NotImplemented("Parsing for loops")
 		case token.IF:
-			panic("TODO: Handle for loops (in parser)")
+			utils.NotImplemented("Parsing if statements")
 		case token.RETURN:
 			p.next() // eat 'return'
 			var expr ast.Expr
@@ -335,7 +339,8 @@ func (p *Parser) parseStatement() ast.Stmt {
 			p.expect(token.SEMICOLON)
 			return ast.Return(expr)
 		default:
-			panic("TODO: Unhandled keyword: " + p.lit)
+			utils.Errorf("Unhandled keyword '%s' in parse statement", p.lit)
+			utils.InvalidCodePath()
 		}
 	}
 
@@ -351,7 +356,9 @@ func (p *Parser) parseStatement() ast.Stmt {
 		p.expect(token.SEMICOLON)
 		return ast.Eval(exprs[0])
 	} else {
-		panic("TODO: Produce error for expression list w/o assignment, then recover")
+		p.error(p.scanner.Pos(), `An expression list (eg. "a, b, c") is only valid as part of an assignment`)
+		p.expect(token.SEMICOLON)
+		return ast.Eval(exprs[0]) // TODO: return some sort of ast.NoOp
 	}
 }
 
@@ -371,7 +378,8 @@ func (p *Parser) parseExpression() ast.Expr {
 func (p *Parser) parseOperators(precedence ast.OpPrecedence) ast.Expr {
 	lhs := p.parseBaseExpression()
 	if p.tok == token.LEFT_BRACKET {
-		panic("TODO: Hande array subscript")
+		utils.NotImplemented("Parsing array subscripts")
+		return nil
 	} else if p.tok == token.LEFT_PAREN {
 		p.next() // eat '('
 		var args []ast.Expr
@@ -411,7 +419,8 @@ func (p *Parser) parseOperators(precedence ast.OpPrecedence) ast.Expr {
 func (p *Parser) parseBinaryOperator() *ast.OperatorDefn {
 	options, defined := p.operators.Lookup(p.lit)
 	if !defined {
-		panic("TODO: Handle undefined operators")
+		p.error(p.scanner.Pos(), "The operator '"+p.lit+"' has not been defined")
+		return ast.UndefinedOperator
 	}
 
 	var op *ast.OperatorDefn
@@ -423,7 +432,8 @@ func (p *Parser) parseBinaryOperator() *ast.OperatorDefn {
 	}
 
 	if op == nil {
-		panic("TODO: Handle operator is not an infix/postfix operator")
+		p.error(p.scanner.Pos(), "The operator '"+p.lit+"' cannot be used as an infix operator")
+		return ast.UndefinedOperator
 	}
 
 	return op
@@ -450,7 +460,8 @@ func (p *Parser) parseBaseExpression() ast.Expr {
 	if p.tok.IsOperator() {
 		options, defined := p.operators.Lookup(p.lit)
 		if !defined {
-			panic("TODO: Handle undefined operators")
+			p.error(p.scanner.Pos(), "The operator '"+p.lit+"' has not been defined")
+			// it is ok to fallthrough here, we'll just loop over an empty list
 		}
 
 		var op *ast.OperatorDefn
@@ -462,7 +473,8 @@ func (p *Parser) parseBaseExpression() ast.Expr {
 		}
 
 		if op == nil {
-			panic("TODO: Handle operator is not a prefix operator")
+			p.error(p.scanner.Pos(), "The operator '"+p.lit+"' cannot be used as an prefix operator")
+			op = ast.UndefinedOperator
 		}
 
 		p.next() // eat operator
@@ -545,7 +557,8 @@ func (p *Parser) parseType() ast.Type {
 		return ast.ArrTyp(typ, len)
 
 	case token.LEFT_PAREN:
-		panic("TODO: parse function types")
+		utils.NotImplemented("Parsing procedure types")
+		return nil
 
 	case token.IDENT:
 		var typ ast.Type

code/semantics/inference.go

@@ -42,7 +42,8 @@ func inferTypesRecursive(node ast.Node) ast.Type {
 		inferTypesRecursive(n.Expr)
 	case *ast.AssignStmt:
 		if len(n.Left) != len(n.Right) {
-			panic("TODO: Handle unbalanced assignment")
+			utils.Errorf("Found unbalanced assignment during type inference")
+			utils.NotImplemented(`Printing "file:line: message"-style error messages after parsing`)
 		}
 		for i := range n.Left {
 			inferTypesRecursive(n.Left[i])
@@ -129,10 +130,13 @@ func inferPrefixType(op *ast.OperatorDefn, typ ast.Type) ast.Type {
 		case ast.BuiltinUint64:
 			return ast.BuiltinInt64
 		default:
-			panic("TODO: Implement operator overload resolution for prefix -/+")
+			utils.NotImplemented("Operator overloading for prefix +/- (unary negation)")
+			return nil
 		}
 	default:
-		panic("TODO: Unhandled prefix operator in type inference")
+		utils.Errorf("Unhandled prefix operator '%s' in type inference", op.Literal)
+		utils.InvalidCodePath()
+		return nil
 	}
 }
 
@@ -143,7 +147,9 @@ func inferPostfixType(op *ast.OperatorDefn, typ ast.Type) ast.Type {
 
 	switch op {
 	default:
-		panic("TODO: Unhandled postfix operator in type inference")
+		utils.Errorf("Unhandled postfix operator '%s' in type inference", op.Literal)
+		utils.InvalidCodePath()
+		return nil
 	}
 }
 
@@ -159,7 +165,9 @@ func inferInfixType(op *ast.OperatorDefn, left ast.Type, right ast.Type) ast.Typ
 		// TODO: Implement operator overload resolution
 		return castNumbers(left, right)
 	default:
-		panic("TODO: Unhandled infix operator in type inference")
+		utils.Errorf("Unhandled infix operator '%s' in type inference", op.Literal)
+		utils.InvalidCodePath()
+		return nil
 	}
 }
 
@@ -182,28 +190,32 @@ func parseNumber(num string) (ast.Type, interface{}) {
 	if len(num) > 2 && num[0:2] == "0x" {
 		val, err := strconv.ParseUint(num, 16, 0)
 		if err == strconv.ErrRange {
-			panic("TODO: Handle hexadecimal literal can't be represented by uint64")
+			utils.Errorf("Hexadecimal literal can't be represented by a uint64")
+			utils.NotImplemented(`Printing "file:line: message"-style error messages after parsing`)
 		}
 		utils.AssertNil(err, "Failed parsing hexadecimal literal")
 		return ast.InferredUnsigned, val
 	} else if strings.Contains(num, ".") || strings.Contains(num, "e") {
 		val, err := strconv.ParseFloat(num, 0)
 		if err == strconv.ErrRange {
-			panic("TODO: Handle floating point literal can't be represented by float64")
+			utils.Errorf("Floating point literal can't be represented by a float64")
+			utils.NotImplemented(`Printing "file:line: message"-style error messages after parsing`)
 		}
 		utils.AssertNil(err, "Failed parsing float literal")
 		return ast.InferredFloat, val
 	} else if num[0] == '0' {
 		val, err := strconv.ParseUint(num, 8, 0)
 		if err == strconv.ErrRange {
-			panic("TODO: Handle octal literal can't be represented by uint64")
+			utils.Errorf("Octal literal can't be represented by a uint64")
+			utils.NotImplemented(`Printing "file:line: message"-style error messages after parsing`)
 		}
 		utils.AssertNil(err, "Failed parsing octal literal")
 		return ast.InferredUnsigned, val
 	} else {
 		val, err := strconv.ParseUint(num, 10, 0)
 		if err == strconv.ErrRange {
-			panic("TODO: Handle decimal literal can't be represented by uint64")
+			utils.Errorf("Decimal literal can't be represented by a uint64")
+			utils.NotImplemented(`Printing "file:line: message"-style error messages after parsing`)
 		}
 		utils.AssertNil(err, "Failed parsing decimal literal")
 		return ast.InferredNumber, val

code/semantics/resolution.go

@@ -44,7 +44,7 @@ func ResolveNames(cs *ast.Section) {
 					n.Decl = decl
 					break
 				} else if search == nil {
-					utils.NotImplemented("out-of-order declaration lookup")
+					utils.NotImplemented("name resolution for out-of-order declarations")
 				} else {
 					search = FindParentScope(search)
 				}

code/utils/assert.go

@@ -14,6 +14,10 @@ func Puts(value interface{}) {
 	fmt.Printf("%v:%v\n", reflect.ValueOf(value).Type(), value)
 }
 
+func Errorf(msg string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, "Error: "+msg+"\n", args...)
+}
+
 func Assert(truthy bool, msg string, args ...interface{}) {
 	if !truthy {
 		AssertionFailed(msg, args...)
@@ -42,11 +46,11 @@ func InvalidCodePath() {
 }
 
 func AssertionFailed(msg string, args ...interface{}) {
-	fmt.Printf("Assertion: "+msg+"\n", args...)
+	fmt.Fprintf(os.Stderr, "Assertion: "+msg+"\n", args...)
 
 	// print call stack
 	stackEnded := false
-	fmt.Println()
+	fmt.Fprintf(os.Stderr, "\n")
 	for i := 2; i < 30; i++ {
 		pc, file, line, ok := runtime.Caller(i)
 		if !ok {
@@ -62,12 +66,16 @@ func AssertionFailed(msg string, args ...interface{}) {
 
 		callerParts := strings.Split(runtime.FuncForPC(pc).Name(), "/")
 		caller := callerParts[len(callerParts)-1]
-		fmt.Printf("  %16s  %s:%d\n", path, caller, line)
+		fmt.Fprintf(os.Stderr, "  %16s  %s:%d\n", path, caller, line)
 	}
-	fmt.Println()
+	fmt.Fprintf(os.Stderr, "\n")
 
 	if !stackEnded {
-		fmt.Println("\nWhy things fail: your stack is to deep for sanity...")
+		fmt.Fprintf(os.Stderr, "\nWhy things fail: your stack is to deep for sanity...\n")
 	}
 	os.Exit(1)
 }
+
+func Typeof(v interface{}) string {
+	return fmt.Sprintf("%T", v)
+}