Athena support let syntax for immutable variable binding

athena/README.md

@@ -20,7 +20,7 @@ Both classes live in `namespace athena`, are declared in the same header
 
 * 1.The execution process of the entire program is determined by each statement, with each statement ending with a semicolon ";".
 
-* 2.The format of a statement must be constructed as follows: {ID} = {Expression}, where ID is understood as a variable name and Expression is an expression. Of course, you can also use just an expression without an ID, and it is still valid.
+* 2.The format of a statement must be constructed as follows: {ID} = {Expression}, where ID is understood as a variable name and Expression is an expression. Of course, you can also use just an expression without an ID, and it is still valid. You can also use `let` to declare a constant variable: `let {ID} = {Expression}`. A `let`-declared variable cannot be reassigned later (including inside `when` branches). Attempting to reassign a `let` variable or redeclare an existing variable with `let` will result in a compile-time error.
 
 * 3.In addition to supporting various operations, expressions also support several types of special syntax. Function syntax: {function_name}({arg1}, {arg2}, ...). It also supports switch statements and if statements. Following the principle of simplicity, the syntax for switch and if statements is similar to function syntax: if({condition}, {true_expression}, {false_expression}), switch({case1}, {value1}, {case2}, {value2}..., {default_value}).
 

athena/ast_builder.cc

@@ -36,7 +36,7 @@ Status ProgramAstBuilder::BuildExpression(const std::string& code, std::unique_p
 }
 
 Status ProgramAstBuilder::BuildPipeline(const std::string& code, std::unique_ptr<ExecNode>* result) {
-  std::vector<std::string> names;
+  std::vector<jitfusion::VarInfo> var_infos;
   std::vector<std::unique_ptr<ExecNode>> args;
   statements_.clear();
   var2index_.clear();
@@ -51,13 +51,13 @@ Status ProgramAstBuilder::BuildPipeline(const std::string& code, std::unique_ptr
   if (!custom_error_message_.empty()) {
     return Status::ParseError(custom_error_message_);
   }
-  names.reserve(statements_.size());
+  var_infos.reserve(statements_.size());
   args.reserve(statements_.size());
   for (auto& statement : statements_) {
-    names.emplace_back(std::move(statement.var_name));
+    var_infos.emplace_back(std::move(statement.var_name), statement.is_const);
     args.emplace_back(std::move(statement.expression));
   }
-  auto root = std::unique_ptr<ExecNode>(new NoOPNode(std::move(names), std::move(args)));
+  auto root = std::unique_ptr<ExecNode>(new NoOPNode(std::move(var_infos), std::move(args)));
   *result = std::move(root);
   return Status::OK();
 }
@@ -102,15 +102,15 @@ void ProgramAstBuilder::EnterBlock() {
 }
 
 std::unique_ptr<ExecNode> ProgramAstBuilder::LeaveBlock() {
-  std::vector<std::string> names;
+  std::vector<jitfusion::VarInfo> var_infos;
   std::vector<std::unique_ptr<ExecNode>> args;
-  names.reserve(statements_.size());
+  var_infos.reserve(statements_.size());
   args.reserve(statements_.size());
   for (auto& stmt : statements_) {
-    names.emplace_back(std::move(stmt.var_name));
+    var_infos.emplace_back(std::move(stmt.var_name), stmt.is_const);
     args.emplace_back(std::move(stmt.expression));
   }
-  auto block_node = std::unique_ptr<ExecNode>(new NoOPNode(std::move(names), std::move(args)));
+  auto block_node = std::unique_ptr<ExecNode>(new NoOPNode(std::move(var_infos), std::move(args)));
 
   auto& outer = block_stack_.back();
   statements_ = std::move(outer.statements);

athena/ast_builder.h

@@ -25,13 +25,16 @@ struct Statement {
   Statement() = default;
   Statement(std::string vname, std::unique_ptr<jitfusion::ExecNode> exp)
       : var_name(std::move(vname)), expression(std::move(exp)) {}
+  Statement(std::string vname, std::unique_ptr<jitfusion::ExecNode> exp, bool is_const_var)
+      : var_name(std::move(vname)), expression(std::move(exp)), is_const(is_const_var) {}
   explicit Statement(std::unique_ptr<jitfusion::ExecNode> exp) : expression(std::move(exp)) {}
   ~Statement() = default;
   Statement(Statement&& s) = default;
   Statement& operator=(Statement&& other) = default;
 
   std::string var_name;
   std::unique_ptr<jitfusion::ExecNode> expression;
+  bool is_const{false};
 };
 
 class ProgramAstBuilder {