Got more tests working with new binder.

Author: waywardgeek

TODO

@@ -37,6 +37,7 @@ Add LLVM compiler hints and optmizations as described at
 Support named parameters, like Python
 
 ## Medium Term
+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.
 Upgrade from lineNum to an object specifying the text of the line, position, and file name.

database/util.c

@@ -509,7 +509,7 @@ char *deBytesToHex(void *bytes, uint32 len, bool littleEndian) {
 // Determine if the identifier conforms to: [-a-zA-Z$._][-a-zA-Z$._0-9]*
 bool deIsLegalIdentifier(char *identifier) {
   uint8 *p = (uint8*)identifier;
-  uint8 len = strlen(identifier);
+  uint8 *end = p +  strlen(identifier);
   uint8 c = *p++;
   if (!isalpha(c) && c != '_' && c != '$' && c < 0xc0) {
     return false;
@@ -518,7 +518,7 @@ bool deIsLegalIdentifier(char *identifier) {
   do {
     c = *p++;
   } while (c >= 0x80 && c <= 0xbf);
-  for (uint32 i = 1; i < len; i++) {
+  while (p < end) {
     if (!isalnum(c) && !isdigit(c) && c != '_' && c != '$' && c < 0xc0) {
       return false;
     }

include/de.h

@@ -110,27 +110,28 @@ static inline deVariable deBlockIndexVariable(deBlock block, uint32 index) {
   utExit("Indexed past end of block variables");
   return deVariableNull;
 }
-static inline uint32 deBlockFindVariableIndex(deBlock block, deVariable variable) {
+static inline uint32 deBlockFindVariableIndex(deBlock block,
+    deVariable variable) {
   deVariable var;
   uint32 i = 0;
   deForeachBlockVariable(block, var) {
     if (var == variable) {
       return i;
     }
     i++;
-  } deEndBlockVariable;
+  }
+  deEndBlockVariable;
   utExit("Varaible not found on block");
   return 0;  // Dummy return.
 }
 
 // Function methods.
 deFunction deFunctionCreate(deFilepath filepath, deBlock block,
-                            deFunctionType type, utSym name, deLinkage linkage,
-                            deLine line);
+    deFunctionType type, utSym name, deLinkage linkage, deLine line);
 deFunction deIteratorFunctionCreate(deBlock block, utSym name, utSym selfName,
-                                    deLinkage linkage, deLine line);
+    deLinkage linkage, deLine line);
 deFunction deOperatorFunctionCreate(deBlock block, deExpressionType opType,
-                                    deLine line);
+    deLine line);
 char *deGetFunctionTypeName(deFunctionType type);
 void deDumpFunction(deFunction function);
 void deDumpFunctionStr(deString string, deFunction function);
@@ -192,8 +193,7 @@ static inline deBlock deGeneratorGetSubBlock(deGenerator generator) {
 
 // Variable methods.
 deVariable deVariableCreate(deBlock block, deVariableType type, bool isConst,
-                            utSym name, deExpression initializer,
-                            bool generated, deLine line);
+    utSym name, deExpression initializer, bool generated, deLine line);
 deVariable deCopyVariable(deVariable variable, deBlock destBlock);
 void deDumpVariable(deVariable variable);
 void deDumpVariableStr(deString str, deVariable variable);
@@ -227,10 +227,8 @@ deExpression deStringExpressionCreate(deString, deLine line);
 deExpression deCStringExpressionCreate(char *text, deLine line);
 deExpression deBoolExpressionCreate(bool value, deLine line);
 deExpression deBinaryExpressionCreate(deExpressionType type,
-                                      deExpression leftExpr,
-                                      deExpression rightExpr, deLine line);
-deExpression deUnaryExpressionCreate(deExpressionType type, deExpression expr,
-                                     deLine line);
+    deExpression leftExpr, deExpression rightExpr, deLine line);
+deExpression deUnaryExpressionCreate(deExpressionType type, deExpression expr, deLine line);
 void deDumpExpression(deExpression expression);
 void deDumpExpressionStr(deString string, deExpression expression);
 deStatement deFindExpressionStatement(deExpression expression);
@@ -332,8 +330,7 @@ deDatatype deNullDatatypeCreate(deTclass tclass);
 deDatatype deFunctionDatatypeCreate(deFunction function);
 deDatatype deFuncptrDatatypeCreate(deDatatype returnType, deDatatypeArray parameterTypes);
 deDatatype deTupleDatatypeCreate(deDatatypeArray types);
-deDatatype deStructDatatypeCreate(deFunction structFunction,
-                                  deDatatypeArray types, deLine line);
+deDatatype deStructDatatypeCreate(deFunction structFunction, deDatatypeArray types, deLine line);
 deDatatype deGetStructTupleDatatype(deDatatype structDatatype);
 deDatatype deEnumClassDatatypeCreate(deFunction enumFunction);
 deDatatype deEnumDatatypeCreate(deFunction enumFunction);
@@ -374,7 +371,7 @@ static inline bool deDatatypeIsNumber(deDatatype datatype) {
 // Signature, SignatureBin, and Paramspec methods.
 deSignature deLookupSignature(deFunction function, deDatatypeArray parameterTypes);
 deSignature deSignatureCreate(deFunction function,
-                              deDatatypeArray parameterTypes, deLine line);
+    deDatatypeArray parameterTypes, deLine line);
 deSignature deResolveConstructorSignature(deSignature signature);
 bool deSignatureIsConstructor(deSignature signature);
 bool deSignatureIsMethod(deSignature signature);
@@ -517,8 +514,7 @@ bool deIsLegalIdentifier(char *identifier);
 char *deSnakeCase(char *camelCase);
 char *deUpperSnakeCase(char *camelCase);
 void deGenerateDummyLLFileAndExit(void);
-char *deGetOldVsNewDatatypeStrings(deDatatype oldDatatype,
-                                   deDatatype newDatatype);
+char *deGetOldVsNewDatatypeStrings(deDatatype oldDatatype, deDatatype newDatatype);
 static inline uint32 deBitsToBytes(uint32 bits) {
   return (bits + 7) / 8;
 }

llvm/genllvm.c

@@ -2327,9 +2327,9 @@ static void generateCallExpression(deExpression expression) {
   deSignature signature = deExpressionGetSignature(expression);
   deDatatype returnType = deExpressionGetDatatype(expression);
   uint32 savedStackPos = llStackPos;
+  bool isMethodCall = deExpressionIsMethodCall(accessExpression);
   if (signature != deSignatureNull) {
-    evaluateParameters(signature, deDatatypeNull, parameters,
-        deExpressionIsMethodCall(accessExpression));
+    evaluateParameters(signature, deDatatypeNull, parameters, isMethodCall);
   } else {
     evaluateIndirectCallParameters(parameters);
   }
@@ -2339,9 +2339,13 @@ static void generateCallExpression(deExpression expression) {
   deDatatypeType accessType = deDatatypeGetType(accessDatatype);
   if (llElementIsDelegate(element)) {
     // If this is a delegate, the self expression is still on the stack, and
-    // needs to be derefed
-    llElement *selfElement = topOfStack();
-    derefElement(selfElement);
+    // needs to be derefed or popped if not used.
+    if (!deSignatureParamInstantiated(signature, 0)) {
+      popElement(false);
+    } else {
+      llElement *selfElement = topOfStack();
+      derefElement(selfElement);
+    }
   }
   llElement returnElement;
   bool returnsValuePassedByReference = llDatatypePassedByReference(returnType);

tests/exteuc.rn newtests/exteuc.rn

@@ -0,0 +1,4 @@
+[5i64, 1i64, -5i64]
+true
+[1i64, 1i64, 0i64]
+[1i64, 34i64, -9i64]

newtests/exteuc.stdout

@@ -0,0 +1 @@
+23 34

tests/factorial.rn newtests/factorial.rn

@@ -0,0 +1 @@
+3628800

tests/factorial.stdout newtests/factorial.stdout

@@ -1,3 +1,18 @@
+#!/bin/bash
+#  Copyright 2022 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 gdb.printing
 
 

tests/gf2.rn newtests/gf2.rn

@@ -185,8 +185,6 @@ static bool instantiateSubExpressions(deExpressionType type) {
   case DE_EXPR_FUNCADDR:
   case DE_EXPR_ARRAYOF:
   case DE_EXPR_TYPEOF:
-  case DE_EXPR_UNSIGNED:
-  case DE_EXPR_SIGNED:
   case DE_EXPR_WIDTHOF:
     return false;
   default:
@@ -234,6 +232,14 @@ static void  postProcessDotExpression(deBinding binding) {
   deStateBindingRemoveBinding(deBindingGetStateBinding(binding), identBinding);
 }
 
+// Remove the identifier to the left of the named parameter expression from the
+// binding queue.  The handler for binding named parameter expressions must bind
+// this once the right hand side is bound.
+static void  postProcessNamedParameterExpression(deBinding binding) {
+  deBinding identBinding = deBindingGetFirstBinding(binding);
+  deStateBindingRemoveBinding(deBindingGetStateBinding(binding), identBinding);
+}
+
 // Queue the expression for binding.
 deBinding deQueueExpression(deSignature scopeSig, deStateBinding statebinding,
     deBinding owningBinding, deExpression expression, bool instantiating) {
@@ -253,6 +259,8 @@ deBinding deQueueExpression(deSignature scopeSig, deStateBinding statebinding,
     postProcessAssignment(binding);
   } else if (type == DE_EXPR_DOT) {
     postProcessDotExpression(binding);
+  } else if (type == DE_EXPR_NAMEDPARAM) {
+    postProcessNamedParameterExpression(binding);
   }
   return binding;
 }

tests/gf2.stdout newtests/gf2.stdout

@@ -84,11 +84,10 @@ static void checkBinaryExpression(deSignature scopeSig, deBinding binding,
   if (compareTypes && !typesAreEquivalent(*leftType, *rightType)) {
     // Try auto-cast.
     if (deBindingAutocast(left) && !deBindingAutocast(right)) {
-      // TODO: Comment in when we test autocast.
-      // coautocastExpression(left, *rightType);
+      autocastExpression(left, *rightType);
       *leftType = deBindingGetDatatype(left);
     } else if (deBindingAutocast(right) && !deBindingAutocast(left)) {
-      // autocastExpression(right, *leftType);
+      autocastExpression(right, *leftType);
       *rightType = deBindingGetDatatype(right);
     }
   }
@@ -152,11 +151,10 @@ static void bindBinaryExpression(deSignature scopeSig, deBinding binding,
   if (compareTypes && !typesAreEquivalent(*leftType, *rightType)) {
     // Try auto-cast.
     if (deBindingAutocast(left) && !deBindingAutocast(right)) {
-      // TODO: Comment in when we test autocast.
-      // autocastExpression(left, *rightType);
+      autocastExpression(left, *rightType);
       *leftType = deBindingGetDatatype(left);
     } else if (deBindingAutocast(right) && !deBindingAutocast(left)) {
-      // autocastExpression(right, *leftType);
+      autocastExpression(right, *leftType);
       *rightType = deBindingGetDatatype(right);
     }
   }
@@ -1293,6 +1291,23 @@ static void bindNamedParameter(deSignature scopeSig, deBinding binding) {
   deBinding right = deBindingGetLastBinding(binding);
   deBindingSetDatatype(binding, deBindingGetDatatype(right));
   deBindingSetIsType(binding, deBindingIsType(right));
+  // Find the variable in the called function so we can bind to it.
+  deBinding call = deBindingGetBinding(deBindingGetBinding(binding));
+  utAssert(deBindingGetType(call) == DE_EXPR_CALL);
+  deBinding callAccess = deBindingGetFirstBinding(call);
+  deFunction function = findCalledFunction(callAccess);
+  deBlock block = deFunctionGetSubBlock(function);
+  deBinding paramNameBinding = deBindingGetFirstBinding(binding);
+  utSym paramName = deExpressionGetName(deBindingGetExpression(paramNameBinding));
+  deIdent ident = deBlockFindIdent(block, paramName);
+  if (ident == deIdentNull || deIdentGetType(ident) != DE_IDENT_VARIABLE) {
+    error(binding, "No parameter named %s found", utSymGetName(paramName));
+  }
+  deVariable var = deIdentGetVariable(ident);
+  if (deVariableGetType(var) != DE_VAR_PARAMETER) {
+    error(binding, "Variable %s is a local variable, not a parameter", utSymGetName(paramName));
+  }
+  deIdentAppendBinding(ident, paramNameBinding);
 }
 
 // Bind the binding's expression.

tests/namedparam.rn newtests/namedparam.rn

@@ -27,7 +27,7 @@ class Element(self, name, age) {
   }
 }
 
-relation HeapList Root Element cascade
+relation HeapqList Root Element cascade
 
 root = Root()
 root.pushElement(Element("Fred", 44))

tests/namedparam.stdout newtests/namedparam.stdout

@@ -0,0 +1,4 @@
+{name = Alice, age = 32}
+{name = Bob, age = 32}
+{name = Fred, age = 44}
+{name = Dave, age = 56}