Mostly work on the bootstrap compiler.

Andrew did a lot of work on the bootstrap compiler, and a few tests were added and bugs fixed in order to aid Andrew.

Author: waywardgeek

Makefile

@@ -143,6 +143,8 @@ clean:
 	for file in tests/*.rn crypto_class/*.rn errortests/*.rn; do exeFile=$$(echo "$$file" | sed 's/.rn$$//'); rm -f "$$exeFile"; done
 	cd runtime ; make clean
 	cd bootstrap/database ; make clean
+	cd bootstrap/cbackend ; make clean
+
 
 obj: include/dedatabase.h llvm/lldatabase.h
 	mkdir -p obj/database obj/llvm obj/parse obj/runtime obj/src obj/util obj/rpc obj/bind obj/transformer

TODO

@@ -40,6 +40,7 @@ Add LLVM compiler hints and optmizations as described at
 Support named parameters, like Python.
 
 ## Medium Term
+Support negative indicies, like Python, in slices to indicate size relative to length of the array.
 Write tests to verify that constant time processing of secrets is achieved.  E.g. if (issecret(foo)...
 Add support for fixed-sized arrays for improved speed.
 Make modular inverse constant time.

bind/bind.c

@@ -550,6 +550,17 @@ void deQueueSignature(deSignature signature) {
   }
 }
 
+// Some variables are never bound, and have no datatype.  Delete them.
+static void removeUnusedVariables(deClass theClass) {
+  deVariable var;
+  deBlock block = deClassGetSubBlock(theClass);
+  deSafeForeachBlockVariable(block, var) {
+    if (deVariableGetDatatype(var) == deDatatypeNull) {
+      deVariableDestroy(var);
+    }
+  } deEndSafeBlockVariable;
+}
+
 // Bind signatures until done.  This can be called multiple times, to bind new
 // statements and functions.
 void deBindAllSignatures(void) {
@@ -567,7 +578,9 @@ void deBindAllSignatures(void) {
           updateSignature(signature);
           checkSignatureReturnType(signature);
           if (deBlockIsConstructor(deSignatureGetBlock(signature))) {
-            deGenerateDefaultMethods(deDatatypeGetClass(deSignatureGetReturnType(signature)));
+            deClass theClass = deDatatypeGetClass(deSignatureGetReturnType(signature));
+            removeUnusedVariables(theClass);
+            deGenerateDefaultMethods(theClass);
           }
         }
       }

bind/bindexpr.c

@@ -1067,6 +1067,13 @@ static deVariable findNamedParam(deBlock block, deExpression param) {
   return var;
 }
 
+// Check that the expression's datatype is not none.
+static void checkNotNone(deExpression expr) {
+  if (deExpressionGetDatatype(expr) == deNoneDatatypeCreate()) {
+    deExprError(expr, "Expression has none type.");
+  }
+}
+
 // Find call datatypes.  For default parameters with default values that are
 // not specified by the caller, use deNullDatatype, as this will be bound when
 // expression the function.
@@ -1097,7 +1104,9 @@ static deDatatypeArray findCallDatatypes(deBlock scopeBlock,
     var = deVariableGetNextBlockVariable(var);
   } else if (isMethodCall(access)) {
     // Add the type of the object on the left of the dot expression as self parameter.
-    deDatatype selfType = deExpressionGetDatatype(deExpressionGetFirstExpression(access));
+    deExpression selfExpr = deExpressionGetFirstExpression(access);
+    checkNotNone(selfExpr);
+    deDatatype selfType = deExpressionGetDatatype(selfExpr);
     if (deDatatypeArrayGetUsedDatatype(paramTypes) == 0) {
       deExprError(access, "Function %s lacks a self parameter, but is called as a method",
           deFunctionGetName(function));
@@ -1109,6 +1118,7 @@ static deDatatypeArray findCallDatatypes(deBlock scopeBlock,
   deExpression param = deExpressionGetFirstExpression(params);
   bool foundNamedParam = false;
   while (param != deExpressionNull) {
+    checkNotNone(param);
     foundNamedParam |= deExpressionGetType(param) == DE_EXPR_NAMEDPARAM;
     if (!foundNamedParam) {
       if (var == deVariableNull || deVariableGetType(var) != DE_VAR_PARAMETER) {
@@ -1222,6 +1232,7 @@ static void markConstructorClassBound(deSignature signature) {
   deSignatureSetBound(signature, true);
   deQueueEventBlockedBindings(deSignatureGetReturnEvent(signature));
   deClassSetBound(theClass, true);
+  deCreateBlockVariables(deClassGetSubBlock(theClass), deFunctionGetSubBlock(function));
 }
 
 // Bind a call expression.
@@ -1859,6 +1870,10 @@ static deBindRes bindExpression(deBlock scopeBlock, deExpression expression, boo
       deExpressionSetIsType(expression, true);
       deExpressionSetDatatype(expression, deBoolDatatypeCreate());
       break;
+    case DE_EXPR_NONETYPE:
+      deExpressionSetIsType(expression, true);
+      deExpressionSetDatatype(expression, deNoneDatatypeCreate());
+      break;
     case DE_EXPR_AS:
       utExit("Unexpected expression type");
       break;
@@ -1942,9 +1957,11 @@ static void postProcessBoundStatement(deBlock scopeBlock, deBinding binding) {
   deStatementSetInstantiated(statement, deBindingInstantiated(binding));
   deStatementType type = deStatementGetType(statement);
   if (type == DE_STATEMENT_RETURN || type == DE_STATEMENT_YIELD) {
+    deExpression expr = deStatementGetExpression(statement);
     deDatatype datatype = deNoneDatatypeCreate();
     if (deStatementGetExpression(statement) != deExpressionNull) {
-      datatype = deExpressionGetDatatype(deStatementGetExpression(statement));
+      checkNotNone(expr);
+      datatype = deExpressionGetDatatype(expr);
     }
     updateSignatureReturnType(deBindingGetSignature(binding), datatype);
   } else if (type == DE_STATEMENT_TYPESWITCH) {
@@ -2023,8 +2040,10 @@ void deBindStatement(deBinding binding) {
       if (datatype != deDatatypeNull &&
           !deDatatypeMatchesTypeExpression(scopeBlock, datatype, typeExpr)) {
         deCurrentSignature = deBindingGetSignature(binding);
-        deError(deExpressionGetLine(typeExpr), "Failed type constraint: %s",
-            deDatatypeGetTypeString(datatype));
+        deSigError(deCurrentSignature, "Failed type constraint: variable %s expected type %s, got: %s",
+                   deVariableGetName(variable),
+                   deEscapeString(deExpressionToString(typeExpr)),
+                   deDatatypeGetTypeString(datatype));
       }
       break;
     }

bind/create_vars.c

@@ -29,39 +29,62 @@ static void createVariableIfMissing(deBlock scopeBlock, deExpression expr) {
   }
 }
 
+// Determine if this is a member access in a constructor.
+static bool isMemberAccessInConstructor(deBlock scopeBlock, deExpression expr) {
+  deClass theClass = deBlockGetOwningClass(scopeBlock);
+  if (theClass == deClassNull || deExpressionGetType(expr) != DE_EXPR_DOT) {
+    return false;
+  }
+  deExpression leftExpr = deExpressionGetFirstExpression(expr);
+  if (deExpressionGetType(leftExpr) != DE_EXPR_IDENT) {
+    return false;
+  }
+  deFunction constructor =  deTemplateGetFunction(deClassGetTemplate(theClass));
+  deVariable selfVar = deBlockGetFirstVariable(deFunctionGetSubBlock(constructor));
+  return deVariableGetSym(selfVar) == deExpressionGetName(leftExpr);
+}
+
 // Create variables when we find assignment expressions that assign to an identifier.
 static void createExpressionVariables(deBlock scopeBlock, deExpression expr) {
   if (deExpressionGetType(expr) == DE_EXPR_EQUALS) {
     deExpression target = deExpressionGetFirstExpression(expr);
     if (deExpressionGetType(target) == DE_EXPR_IDENT) {
       createVariableIfMissing(scopeBlock, target);
     }
+    if (isMemberAccessInConstructor(scopeBlock, target)) {
+      createVariableIfMissing(scopeBlock, deExpressionGetLastExpression(target));
+    }
   }
   deExpression child;
   deForeachExpressionExpression(expr, child) {
     createExpressionVariables(scopeBlock, child);
   } deEndExpressionExpression;
 }
 
+// Create any variables declared by the statement.
+void deCreateStatementVariables(deBlock scopeBlock, deStatement statement) {
+  deExpression expr = deStatementGetExpression(statement);
+  if (expr != deExpressionNull) {
+    createExpressionVariables(scopeBlock, expr);
+  }
+  deBlock subBlock = deStatementGetSubBlock(statement);
+  if (subBlock != deBlockNull) {
+    deCreateBlockVariables(scopeBlock, subBlock);
+  }
+}
+
 // Create variables in the block from assignment expressions of the form:
 //   IDENT = expression
 // Then, recurse into child functions.
-static void createBlockVariables(deBlock scopeBlock, deBlock block) {
+void deCreateBlockVariables(deBlock scopeBlock, deBlock block) {
   deStatement statement;
   deForeachBlockStatement(block, statement) {
-    deExpression expr = deStatementGetExpression(statement);
-    if (expr != deExpressionNull) {
-      createExpressionVariables(scopeBlock, expr);
-    }
-    deBlock subBlock = deStatementGetSubBlock(statement);
-    if (subBlock != deBlockNull) {
-      createBlockVariables(scopeBlock, subBlock);
-    }
+    deCreateStatementVariables(scopeBlock, statement);
   } deEndBlockStatement;
   deFunction func;
   deForeachBlockFunction(block, func) {
     deBlock subBlock = deFunctionGetSubBlock(func);
-    createBlockVariables(subBlock, subBlock);
+    deCreateBlockVariables(subBlock, subBlock);
   } deEndBlockFunction;
 }
 
@@ -70,5 +93,5 @@ static void createBlockVariables(deBlock scopeBlock, deBlock block) {
 // assignment expression that could create a local variable otherwise.
 void deCreateLocalAndGlobalVariables(void) {
   deBlock scopeBlock = deRootGetBlock(deTheRoot);
-  createBlockVariables(scopeBlock, scopeBlock);
+  deCreateBlockVariables(scopeBlock, scopeBlock);
 }

bootstrap/Makefile

@@ -43,6 +43,16 @@ parse/package.rn\
 parse/pegparser.rn\
 parse/rule.rn\
 parse/token.rn\
+cbackend/cbuilder.rn\
+cbackend/cemitter.rn\
+cbackend/clanguageclasses.rn\
+cbackend/cruntime.rn\
+cbackend/escapestring.rn\
+cbackend/float2string.rn\
+cbackend/int2cstring.rn\
+cbackend/package.rn\
+cbackend/stringstream.rn\
+cbackend/stringwriter.rn\
 rune.rn
 
 rune: $(SRC)

bootstrap/cbackend/cbuilder.rn

@@ -0,0 +1,159 @@
+//  Copyright 2024 Google LLC.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import database as db
+
+use clanguageclasses
+use escapestring
+
+relation DoublyLinked CBuilder CBlock cascade
+
+class CBuilder(self) {
+  self.currentParamList = null(CParamList)
+  self.currentExprList = null(CExprList)
+  self.program = CProgram()
+  self.currentBlock = null(CBlock)
+
+  func build(self, module: db.Function) -> CProgram {
+    module.genC(self)
+    return self.program
+  }
+
+  func addDeclaration(self, dec: CDeclaration) {
+    self.program.insertCDeclaration(dec)
+  }
+
+  func openScope(self) {
+  }
+
+  func closeScope(self) {
+  }
+
+  func openBlock(self, location: db.Location?) {
+    self.currentBlock = CBlock(location)
+    //self.cblocks().appendCBlock(block)
+    //self.appendCBlock(block)
+    self.appendCBlock(CBlock(location))
+  }
+
+  func closeBlock(self) -> CBlock {
+    //block = self.currentCBlock
+    block = self.lastCBlock!
+    //self.currentCBlock = block.prevCBlockCBuilder
+    //self.cblocks().removeCBlock(block)
+    self.removeCBlock(block)
+    return block
+  }
+
+  func addStatement(self, statement: CStatement) {
+    if isnull(self.currentBlock) {
+      self.program.addStatementToMain(statement)
+    } else {
+      self.currentBlock.appendCStatement(statement)
+    }
+  }
+
+  func openParamList(self) {
+    assert isnull(self.currentParamList)
+    self.currentParamList = CParamList()
+  }
+
+  func closeParamList(self) -> CParamList {
+    assert !isnull(self.currentParamList)
+    params = self.currentParamList!
+    self.currentParamList = null(CParamList)
+    return params
+  }
+
+  func addParam(self, param: CParameter) {
+    assert !isnull(self.currentParamList)
+    self.currentParamList.appendCParameter(param)
+  }
+
+  func cParameter(self, location: db.Location, name: string, type: CTypeExpr) -> CParameter {
+    return CParameter(location, name, type)
+  }
+
+  func cType(self, type: CType) -> CTypeExpr {
+    return CTypeExpr(type)
+  }
+
+  /* Rune expressions *********************************************************************/
+
+  func openExprList(self) {
+    assert isnull(self.currentExprList)
+    self.currentExprList = CExprList()
+  }
+
+  func closeExprList(self) -> CExpr {
+    assert !isnull(self.currentExprList)
+    list = self.currentExprList!
+    self.currentExprList = null(CExprList)
+    return CExpr(list)
+  }
+
+  func addExpr(self, expr: CExpr) {
+    assert !isnull(self.currentExprList)
+    self.currentExprList.appendCExpr(expr)
+  }
+
+  func cStringLiteral(self, value: string) -> CExpr {
+    return CExpr(CLiteral(escapeString(value)))
+  }
+
+  func cBoolLiteral(self, value: bool) -> CExpr {
+    return CExpr(CLiteral(value))
+  }
+
+  func cIntLiteral(self, value: db.Bigint) -> CExpr {
+    return CExpr(CLiteral(value))
+  }
+
+  func cUintLiteral(self, value: Uint) -> CExpr {
+    return CExpr(CLiteral(value))
+  }
+
+  func cFloatLiteral(self, value: Float) -> CExpr {
+    return CExpr(CLiteral(value))
+  }
+
+  func cUnaryMinus(self, location: db.Location, arg: CExpr) -> CExpr {
+    return CExpr(CPrefixOperator(location, CPrefixOperator.Type.UnaryMinus, arg))
+  }
+
+  func cBinaryOperator(self, location: db.Location, op: CBinaryOperator.Type,
+                       left: CExpr, right: CExpr) -> CExpr {
+    return CExpr(CBinaryOperator(location, op, left, right))
+  }
+
+  func cCall(self, location: db.Location, name: string | CRuntimeFunction, args: CExpr) -> CExpr {
+    return CExpr(CCall(location, name, args))
+  }
+
+
+
+  /* Rune statements *******************************************************************/
+
+  func cPrintlnStatement(self, location: db.Location, args: CExpr) -> CStatement {
+    return CStatement(self.cCall(location, CRuntimeFunction.Printf, args))
+  }
+
+  func cFunDef(self, location: db.Location, name: string, returnType: CTypeExpr,
+               params: CParamList, body: CBlock) -> CDeclaration {
+    return CDeclaration(CFunctionDeclaration(
+       location, name, returnType, params, body))
+  }
+
+}
+