[bug] Fix assign may lose precision warning & improve related logging

taichi/common/exceptions.h

@@ -26,6 +26,10 @@ struct DebugInfo {
   explicit DebugInfo(const char *tb_) : tb(tb_) {
   }
 
+  std::string get_last_tb() const {
+    return tb;
+  }
+
   std::string const &get_tb() const {
     return tb;
   }
@@ -141,7 +145,7 @@ struct ErrorEmitter {
       // tb here
       error.msg_ = error_msg;
     } else {
-      error.msg_ = p_dbg_info->get_tb() + error_msg;
+      error.msg_ = p_dbg_info->get_last_tb() + error_msg;
     }
 
     if constexpr (std::is_base_of_v<TaichiWarning, std::decay_t<E>>) {

taichi/ir/control_flow_graph.cpp

@@ -3,6 +3,7 @@
 #include <queue>
 #include <unordered_set>
 
+#include "taichi/common/exceptions.h"
 #include "taichi/ir/analysis.h"
 #include "taichi/ir/statements.h"
 #include "taichi/system/profiler.h"
@@ -337,8 +338,11 @@ Stmt *CFGNode::get_store_forwarding_data(Stmt *var, int position) const {
   }
   if (!result) {
     // The UD-chain is empty.
-    TI_WARN("stmt {} loaded in stmt {} before storing.", var->id,
-            block->statements[position]->id);
+    auto offending_load = block->statements[position].get();
+    ErrorEmitter(
+        TaichiIrWarning(), offending_load,
+        fmt::format("Loading variable {} before anything is stored to it.",
+                    var->id));
     return nullptr;
   }
   if (!result_visible) {

taichi/ir/expression.h

@@ -64,6 +64,10 @@ class Expression {
     return stmt;
   }
 
+  std::string get_last_tb() const {
+    return dbg_info.get_last_tb();
+  }
+
   std::string const &get_tb() const {
     return dbg_info.tb;
   }

taichi/ir/ir.cpp

@@ -43,6 +43,14 @@ IRNode *IRNode::get_ir_root() {
   return node;
 }
 
+const IRNode *IRNode::get_ir_root() const {
+  auto node = this;
+  while (node->get_parent()) {
+    node = node->get_parent();
+  }
+  return node;
+}
+
 std::unique_ptr<IRNode> IRNode::clone() {
   std::unique_ptr<IRNode> new_irnode;
   if (is<Block>())
@@ -195,6 +203,34 @@ IRNode *Stmt::get_parent() const {
   return parent;
 }
 
+std::string Stmt::get_last_tb() const {
+  const auto &tb = dbg_info.tb;
+  if (tb.empty()) {
+    // If has no tb, try to find tb from the immediate previous statement
+    if (parent) {
+      auto it_this = std::find_if(
+          parent->statements.rbegin(), parent->statements.rend(),
+          [this](const pStmt &stmt) { return stmt.get() == this; });
+
+      while (it_this != parent->statements.rend()) {
+        const auto &stmt = *it_this;
+        if (!stmt->get_tb().empty()) {
+          return stmt->get_tb();
+        }
+        ++it_this;
+      }
+    }
+
+    const auto stmt_type_name = typeid(*this).name();
+    const auto callable_name = get_callable()->get_name();
+
+    return fmt::format("{}::{} of type {}\n", callable_name, name(),
+                       cpp_demangle(stmt_type_name));
+  }
+
+  return tb;
+}
+
 std::vector<Stmt *> Stmt::get_operands() const {
   std::vector<Stmt *> ret;
   for (int i = 0; i < num_operands(); i++) {

taichi/ir/ir.h

@@ -235,6 +235,7 @@ class IRNode {
   virtual IRNode *get_parent() const = 0;
 
   IRNode *get_ir_root();
+  const IRNode *get_ir_root() const;
 
   virtual ~IRNode() = default;
 
@@ -441,6 +442,8 @@ class Stmt : public IRNode {
     return *operands[i];
   }
 
+  std::string get_last_tb() const;
+
   TI_FORCE_INLINE std::string const &get_tb() const {
     return dbg_info.tb;
   }

taichi/program/program.cpp

@@ -310,6 +310,7 @@ Kernel &Program::get_snode_writer(SNode *snode) {
     ASTBuilder &builder = kernel->context->builder();
     auto expr =
         builder.expr_subscript(Expr(snode_to_fields_.at(snode)), indices);
+    expr.type_check(&this->compile_config());
     auto argload_expr = Expr::make<ArgLoadExpression>(
         std::vector<int>{snode->num_active_indices},
         snode->dt->get_compute_type());

taichi/transforms/ir_printer.cpp

@@ -53,9 +53,9 @@ class IRPrinter : public IRVisitor {
     if (print_ir_dbg_info) {
       dbg_info_printer_ = [this](const Stmt *stmt) {
         auto tb = stmt->get_tb();
-        print_raw(tb.empty() ? "No DebugInfo avaliable.\n"
-                             : tb.substr(0, tb.length()),
-                  "");
+        if (!tb.empty()) {
+          this->print_raw(tb.substr(0, tb.length()), "");
+        }
       };
     }
   }