Added support for parsing strings with escaped characters in bootstrap.

Also added initial rationale for exception handling in g3docs/design_decisions.md.  This is preliminary, and feedback and edites are welcome.  Note that unit tests can now test for expected thrown exceptions.  Also check out how nice the error reporting is in bootstrap/parsegen/lexer.stdout.

Author: waywardgeek

bind/bindexpr.c

@@ -1950,7 +1950,7 @@ static void postProcessBoundStatement(deBlock scopeBlock, deBinding binding) {
     updateSignatureReturnType(deBindingGetSignature(binding), datatype);
   } else if (type == DE_STATEMENT_TYPESWITCH) {
     selectMatchingCase(scopeBlock, binding);
-  } else if (type == DE_STATEMENT_PRINT || type == DE_STATEMENT_THROW) {
+  } else if (type == DE_STATEMENT_PRINT || type == DE_STATEMENT_THROW || type == DE_STATEMENT_PANIC) {
     dePostProcessPrintStatement(statement);
   } else if (type == DE_STATEMENT_IF) {
     deExpression expression = deStatementGetExpression(statement);

bootstrap/database/block.rn

@@ -17,12 +17,12 @@ use sym
 use root
 use filepath
 use function
-use line
+use location
 use statement
 
 // A liternal block statement.  All statements exist within a block.
-class Block(self, line: Line) {
-  self.line = line
+class Block(self, location: Location) {
+  self.location = location
   // For dead code analysis.
   self.canReturn = false
   self.canContinue = false
@@ -82,7 +82,7 @@ class Block(self, line: Line) {
 
   // Make a copy of the block, without sub-blocks.
   func copy(self) -> Block {
-    newBlock = Block(self.line)
+    newBlock = Block(self.location)
     for statement in self.statements() {
       statement.appendCopy(newBlock)
     }
@@ -106,27 +106,27 @@ unittest {
   use expr
 
   mainFunc = getMainFunc()
-  rootLine = mainFunc.line!
-  rootFilepath = rootLine.filepath!
+  rootLocation = mainFunc.location!
+  rootFilepath = rootLocation.filepath!
 
   func createEmptyBlock() -> Block {
-    line = Line(rootFilepath, "Create empty block", 0u32)
-    return Block(line)
+    location = Location(rootFilepath, 0u32, 0u32, 0u32)
+    return Block(location)
   }
 
   func createPrintlnBlock(text: string) -> Block {
     block = createEmptyBlock()
-    line = Line(rootFilepath, "println \"" + text + "\"", 1u32)
-    statement = Statement(block, StateType.Println, line)
+    location = Location(rootFilepath, 0u32, 0u32, 0u32)
+    statement = Statement(block, StateType.Println, location)
     constString = Value(text)
-    expr = Expr.newConstant(constString, line)
+    expr = Expr.newConstant(constString, location)
     statement.insertExpr(expr)
     return block
   }
 
   func createPrintlnFunction(owningFunc: Function?, name: string, text: string) -> Function {
     block = createPrintlnBlock(text)
-    function = Function(owningFunction, FuncType.Plain, Sym.new(name), Linkage.Module, rootLine)
+    function = Function(owningFunction, FuncType.Plain, Sym.new(name), Linkage.Module, rootLocation)
     function.insertSubBlock(block)
     return function
   }

bootstrap/database/expr.rn

@@ -15,7 +15,7 @@
 use sym
 
 use filepath
-use line
+use location
 use value
 use bigint
 use datatype
@@ -184,9 +184,9 @@ func getExprTypeName(type: ExprType) -> string {
 }
 
 // The expression class represents all expression trees in Rune.
-class Expr(self, type: ExprType, line: Line) {
+class Expr(self, type: ExprType, location: Location) {
   self.type = type
-  self.line = line
+  self.location = location
   self.isType = false
   self.isConst = false
   self.autocast = false  // Set on integer constants without a type suffix.
@@ -195,27 +195,27 @@ class Expr(self, type: ExprType, line: Line) {
   // self.datatype = null(Datatype)
   self.val = null(Value(0u32))
 
-  func newConstant(value: Value, line: Line) -> Expr {
-    expr = Expr(ExprType.Constant, line)
+  func newConstant(value: Value, location: Location) -> Expr {
+    expr = Expr(ExprType.Constant, location)
     expr.val = value
     return expr
   }
 
-  func newBinary(type: ExprType, left: Expr, right: Expr, line: Line) -> Expr {
-    expr = Expr(type, line)
+  func newBinary(type: ExprType, left: Expr, right: Expr, location: Location) -> Expr {
+    expr = Expr(type, location)
     expr.appendChildExpr(left)
     expr.appendChildExpr(right)
     return expr
   }
 
-  func newUnary(type: ExprType, child: Expr, line: Line) -> Expr {
-    expr = Expr(type, line)
+  func newUnary(type: ExprType, child: Expr, location: Location) -> Expr {
+    expr = Expr(type, location)
     expr.appendChildExpr(child)
     return expr
   }
 
-  func newIdent(sym: Sym, line: Line) -> Expr {
-    expr = Expr(ExprType.Ident, line)
+  func newIdent(sym: Sym, location: Location) -> Expr {
+    expr = Expr(ExprType.Ident, location)
     expr.val = Value(sym)
     return expr
   }
@@ -513,7 +513,7 @@ class Expr(self, type: ExprType, line: Line) {
 
   // Make a deep copy of the expression.
   func copy(self: Expr) -> Expr {
-    newExpr = Expr(self.type, self.line)
+    newExpr = Expr(self.type, self.location)
     // TODO: Comment in when we port datatype to Rune.
     // newExpr.datatype = expr.datatype
     newExpr.isType = self.isType
@@ -539,14 +539,14 @@ relation OneToOne Function:"Type" Expr:"Type" cascade
 
 unittest {
   filepath = Filepath.new("test_filepath", null(Filepath), false)
-  line = Line(filepath, "Not a real line", 1u32)
+  location = Location(filepath, 0u32, 0u32, 0u32)
 
   func createBinaryExpr() -> Expr {
-    left = Expr.newConstant(Value("Hello"), line)
+    left = Expr.newConstant(Value("Hello"), location)
     assert left.getPrecedence() == getPrecedence(ExprType.Constant)
-    right = Expr.newConstant(Value("World"), line)
+    right = Expr.newConstant(Value("World"), location)
     assert right.getPrecedence() == getPrecedence(ExprType.Constant)
-    return Expr.newBinary(ExprType.Lt, left, right, line)
+    return Expr.newBinary(ExprType.Lt, left, right, location)
   }
 }
 
@@ -559,11 +559,11 @@ unittest destroyTest {
   use block
 
   filepath = Filepath.new("test_filepath", null(Filepath), false)
-  line = Line(filepath, "Not a real line", 1u32)
-  block = Block(line)
-  statement =  Statement(block, StateType.Print, line)
+  location = Location(filepath, 0u32, 0u32, 0u32)
+  block = Block(location)
+  statement =  Statement(block, StateType.Print, location)
   i = Bigint(0xdeadbeefu32, 256u32)
-  expr = Expr.newConstant(Value(i), line)
+  expr = Expr.newConstant(Value(i), location)
   statement.insertExpr(expr)
   expr.destroy()
   assert isnull(statement.expr)
@@ -578,13 +578,13 @@ unittest copyTest {
 }
 
 unittest unaryTest {
-  valueExpr = Expr.newConstant(Value(123u32), line)
-  expr = Expr.newUnary(ExprType.Negate, valueExpr, line)
+  valueExpr = Expr.newConstant(Value(123u32), location)
+  expr = Expr.newUnary(ExprType.Negate, valueExpr, location)
   expr.dump()
 }
 
 unittest newIdentTest {
-  expr = Expr.newIdent(Sym.new("test"), line)
+  expr = Expr.newIdent(Sym.new("test"), location)
   expr.dump()
 }
 

bootstrap/database/function.rn

@@ -15,7 +15,7 @@
 use sym
 
 use root
-use line
+use location
 use filepath
 use value
 use expr
@@ -70,17 +70,17 @@ func getFuncTypeName(type: FuncType) -> string {
 
 // Create a new function.
 class Function(self, parent: Function?, type: FuncType, sym: Sym,
-    linkage: Linkage, line: Line) {
+    linkage: Linkage, location: Location) {
   self.type = type
   self.sym = sym
   self.linkage = linkage
-  self.line = line
+  self.location = location
   self.isExtern = linkage == Linkage.ExternC || linkage == Linkage.ExternRpc
   if !isnull(parent) {
     parent!.appendChildFunction(self)
-    Ident(parent!, self, sym, line)
+    Ident(parent!, self, sym, location)
   }
-  subBlock = Block(line)
+  subBlock = Block(location)
   // Assume it can return until we learn otherwise.  This is only an issue when
   // evaluating recursive functions.
   subBlock.canReturn = true
@@ -142,7 +142,7 @@ class Function(self, parent: Function?, type: FuncType, sym: Sym,
 
   // Make a copy of the function in |destBlock|.
   func copy(self, destFunc: Function) -> Function {
-    newFunction = Function(destFunc, self.type, self.sym, self.linkage, self.line)
+    newFunction = Function(destFunc, self.type, self.sym, self.linkage, self.location)
     for variable in self.variables() {
       variable.copy(newFunction)
     }
@@ -174,28 +174,27 @@ class Function(self, parent: Function?, type: FuncType, sym: Sym,
   func appendFunctionCall(self, childFunction: Function) -> Statement {
     ident = childFunction.firstNameIdent
     pathExpr = ident!.createPathExpr()
-    text = "%s()\n" % childFunction.name()
     block = self.subBlock!
-    line = Line(block.line.filepath!, text, 0u32)
-    emptyParamsExpr = Expr(ExprType.List, line)
-    callExpr = Expr.newBinary(ExprType.Call, pathExpr, emptyParamsExpr, line)
-    statement = Statement(block, StateType.Call, line)
+    location = Location(block.location.filepath!, 0u32, 0u32, 0u32)
+    emptyParamsExpr = Expr(ExprType.List, location)
+    callExpr = Expr.newBinary(ExprType.Call, pathExpr, emptyParamsExpr, location)
+    statement = Statement(block, StateType.Call, location)
     statement.insertExpr(callExpr)
     return statement
   }
 
   // Declare an iterator.
   func newIterator(owningFunc: Function, name: Sym, selfName: Sym, linkage: Linkage,
-      line: Line) -> Function {
-    iteratorFunc = Function(owningFunc, FuncType.Iterator, name, linkage, line)
-    Variable(iteratorFunc, true, false, selfName, null(Expr), null(Expr), false, line)
+      location: Location) -> Function {
+    iteratorFunc = Function(owningFunc, FuncType.Iterator, name, linkage, location)
+    Variable(iteratorFunc, true, false, selfName, null(Expr), null(Expr), false, location)
     return iteratorFunc
   }
 
   // Create an overloaded operator.
-  func newOperator(owningFunc: Function, opType: ExprType, line: Line) -> Function {
+  func newOperator(owningFunc: Function, opType: ExprType, location: Location) -> Function {
     name = owningFunc.createUniqueSym(Sym.new(getExprTypeName(opType)))
-    function = Function(owningFunc, FuncType.Operator, name, Linkage.Package, line)
+    function = Function(owningFunc, FuncType.Operator, name, Linkage.Package, location)
     root = getRoot()
     return function
   }
@@ -217,27 +216,26 @@ class Function(self, parent: Function?, type: FuncType, sym: Sym,
 
   // Create a path expression to this function.
   func createPathExpr(self) -> Expr {
-    identExpr = Expr.newIdent(self.sym, self.line)
+    identExpr = Expr.newIdent(self.sym, self.location)
     parent = self.parentFunction
     if isnull(parent) {
       return identExpr
     }
     prefixExpr = parent!.createPathExpr()
-    return Expr.newBinary(ExprType.Dot, prefixExpr, identExpr, self.line)
+    return Expr.newBinary(ExprType.Dot, prefixExpr, identExpr, self.location)
   }
 }
 
 // Append a call statement to the module initialization function in the root function.
 func insertModuleInitializationCall(moduleFunc: Function) {
   pathExpr = moduleFunc.createPathExpr()
   block = moduleFunc.subBlock!
-  text = "%s()\n" % moduleFunc.name()
-  line = Line(block.line.filepath!, text, 0u32)
-  emptyParamsExpr = Expr(ExprType.List, line)
-  callExpression = Expr.newBinary(ExprType.Call, pathExpr, emptyParamsExpr, line)
+  location = Location(block.location.filepath!, 0u32, 0u32, 0u32)
+  emptyParamsExpr = Expr(ExprType.List, location)
+  callExpression = Expr.newBinary(ExprType.Call, pathExpr, emptyParamsExpr, location)
   root = getRoot()
   block = getMainFunc().subBlock!
-  statement = Statement(block, StateType.Call, line)
+  statement = Statement(block, StateType.Call, location)
   statement.insertExpr(callExpression)
   // Move the statement to after the last initialization call.
   lastInitializer = root.lastInitializerStatement
@@ -258,24 +256,24 @@ relation OneToOne Filepath:"Module" Function:"Module"
 // Create the main function.
 func createMainFunc() {
   rootFilepath = Filepath("Root filepath", null(Filepath), true)
-  rootLine = Line(rootFilepath, "Create main", 0u32)
+  rootLocation = Location(rootFilepath, 0u32, 0u32, 0u32)
   mainFunc = Function(null(Function), FuncType.Package,
-        Sym.new("main"), Linkage.Package, rootLine)
-  typeExpr = Expr(ExprType.IntType, rootLine)
+        Sym.new("main"), Linkage.Package, rootLocation)
+  typeExpr = Expr(ExprType.IntType, rootLocation)
   typeExpr.width = 32u32
   mainFunc.insertTypeExpr(typeExpr)
   getRoot().insertMainFunction(mainFunc)
   rootBlock = mainFunc.subBlock!
   rootFilepath.insertModuleFunction(mainFunc)
-  nullExpr = null(Expr(ExprType.Add, rootLine))
-  u32TypeExpr = Expr(ExprType.UintType, rootLine)
-  stringTypeExpr = Expr(ExprType.StringType, rootLine)
+  nullExpr = null(Expr(ExprType.Add, rootLocation))
+  u32TypeExpr = Expr(ExprType.UintType, rootLocation)
+  stringTypeExpr = Expr(ExprType.StringType, rootLocation)
   u32TypeExpr.width = 32u32
-  argcVar = Variable(mainFunc, true, true, Sym.new("argc"), nullExpr, u32TypeExpr, true, rootLine)
+  argcVar = Variable(mainFunc, true, true, Sym.new("argc"), nullExpr, u32TypeExpr, true, rootLocation)
   argvVar = Variable(mainFunc, true, true, Sym.new("argv"), nullExpr,
-      stringTypeExpr, true, rootLine)
-  statement = Statement(mainFunc.subBlock!, StateType.Return, rootLine)
-  retVal = Expr.newConstant(Value(0i32), rootLine)
+      stringTypeExpr, true, rootLocation)
+  statement = Statement(mainFunc.subBlock!, StateType.Return, rootLocation)
+  retVal = Expr.newConstant(Value(0i32), rootLocation)
   statement.insertExpr(retVal)
 }
 
@@ -285,19 +283,19 @@ unittest {
   use statement
 
   mainFunc = getMainFunc()
-  rootLine = mainFunc.line
-  rootFilepath = rootLine.filepath
+  rootLocation = mainFunc.location
+  rootFilepath = rootLocation.filepath
   argcVar = mainFunc.firstVariable!
   argvVar = argcVar.nextFunctionVariable!
 
   func createEmptyFunction(owningFunc: Function?, name: string) -> Function {
-    return Function(owningFunc, FuncType.Plain, Sym.new(name), Linkage.Module, rootLine)
+    return Function(owningFunc, FuncType.Plain, Sym.new(name), Linkage.Module, rootLocation)
   }
 
   func createPrintlnFunction(owningFunc: Function?, name: string, text: string) {
     function = createEmptyFunction(owningFunc, name);
     block = function.subBlock!
-    Statement(block, StateType.Println, rootLine)
+    Statement(block, StateType.Println, rootLocation)
     return function
   }
 }
@@ -328,8 +326,8 @@ unittest prependAndAppendFunctionCallTest {
 
 unittest newIteratorAndOperatorTest {
   itr = Function.newIterator(mainFunc, Sym.new("testItr"), Sym.new("self"),
-      Linkage.Module, rootLine)
-  op = Function.newOperator(mainFunc, ExprType.Add, rootLine)
+      Linkage.Module, rootLocation)
+  op = Function.newOperator(mainFunc, ExprType.Add, rootLocation)
   itr.dump()
   op.dump()
   itr.destroy()