opt: allow a bound function to opt out of constant folding

The folder evaluates a builtin call at compile time when the callee is pure,
returns a foldable type and every argument is constant. That is wrong when
the body is not really there: an AOT compiler build (DAS_AOT_COMPILER)
replaces C++ bound bodies with an asserting stub, so folding such a call runs
the stub and aborts the compiler. dagor hit this on

    rel_hp_float_to_fixed_floor(1.0)

which only became constant after a small wrapper was inlined at a constant
call site.

Add BuiltInFunction::noFolding with a chainable noFold(), and test it at the
four builtin fold gates, so a binding that must not run at compile time can
say so:

    DAS_ADD_FUN_BIND("rel_hp_float_to_fixed_floor", none, ...)->noFold();

Nothing is marked here. Folding stays on by default for every function.

The flag sits on BuiltInFunction because both Function flag words are full,
and builtins are registered by the host in every process, so nothing has to
be serialized. Mark at the binding rather than under DAS_AOT_COMPILER: the
same TU is compiled into both the AOT compiler and the runtime, so both fold
the same way and the AOT hashes keep matching.

Author: aleksisch

include/daScript/ast/ast.h

@@ -1038,6 +1038,11 @@ namespace das
     class DAS_API BuiltInFunction : public Function {
     public:
         BuiltInFunction ( const char *fn, const char * fnCpp );
+        // Opt out of constant folding for this function, even when it is pure and every argument is
+        // constant. For bindings whose body may not be callable where the compiler runs: an AOT
+        // compiler build replaces C++ bound bodies with an asserting stub. Off by default.
+        bool        noFolding = false;
+        FunctionPtr noFold () { noFolding = true; return this; }
         virtual string getAotBasicName() const override {
             return cppName.empty() ? name : cppName;
         }

src/ast/ast_const_folding.cpp

@@ -7,6 +7,13 @@
 #include "daScript/simulate/debug_print.h"
 
 namespace das {
+    // A C++-bound function must not be folded: see BuiltInFunction::noFolding.
+    static bool foldableBuiltin ( const Function * fn ) {
+        if ( !fn || !fn->builtIn ) return false;
+        return !static_cast<const BuiltInFunction *>(fn)->noFolding;
+    }
+
+
 
     void PassVisitor::preVisitProgram ( Program * prog ) {
         Visitor::preVisitProgram(prog);
@@ -829,7 +836,7 @@ namespace das {
             if (expr->func->sideEffectFlags) {
                 return Visitor::visit(expr);
             }
-            if ( expr->subexpr->constexpression && expr->func->builtIn ) {
+            if ( expr->subexpr->constexpression && foldableBuiltin(expr->func) ) {
                 if ( expr->type->isFoldable() && expr->subexpr->type->isFoldable() ) {
                     return evalAndFold(expr);
                 }
@@ -880,7 +887,7 @@ namespace das {
             if (expr->func->sideEffectFlags) {
                 return Visitor::visit(expr);
             }
-            if ( expr->left->constexpression && expr->right->constexpression && expr->func->builtIn ) {
+            if ( expr->left->constexpression && expr->right->constexpression && foldableBuiltin(expr->func) ) {
                 if ( expr->type->isFoldable() && expr->left->type->isFoldable() && expr->right->type->isFoldable() ) {
                     return evalAndFold(expr);
                 }
@@ -1089,7 +1096,7 @@ namespace das {
     // op3
         virtual ExpressionPtr visit ( ExprOp3 * expr ) override {
             if ( expr->type->isFoldable() && expr->subexpr->constexpression && expr->left->constexpression && expr->right->constexpression &&
-                (expr->func && expr->func->builtIn) ) {
+                foldableBuiltin(expr->func) ) {
                 return evalAndFold(expr);
             } else if ( expr->type->isFoldable() && expr->subexpr->noSideEffects && expr->left->constexpression && expr->right->constexpression ) {
                 bool failed;
@@ -1308,7 +1315,7 @@ namespace das {
                     }
                 }
                 if ( allConst && canFold ) {
-                    if ( expr->func->builtIn ) {
+                    if ( foldableBuiltin(expr->func) ) {
                         return evalAndFold(expr);
                     } else {
                         needRun.push_back(expr->func);