feat: add backtrace context for the evaluator (#1200)

Signed-off-by: peefy <xpf6677@163.com>
kcl-lang · Apr 8, 2024 · 00bd13f · 00bd13f
1 parent 6f5cbc9
commit 00bd13f
Show file tree

Hide file tree

Showing 6 changed files with 52 additions and 1 deletion.
diff --git a/kclvm/evaluator/src/context.rs b/kclvm/evaluator/src/context.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 use generational_arena::Index;
 use kclvm_ast::ast;
 use kclvm_error::Handler;
-use kclvm_runtime::MAIN_PKG_PATH;
+use kclvm_runtime::{BacktraceFrame, MAIN_PKG_PATH};
 
 use crate::{
     error as kcl_error,
@@ -229,4 +229,22 @@ impl<'ctx> Evaluator<'ctx> {
             proxy: Proxy::Rule(rule),
         }))
     }
+
+    pub(crate) fn push_backtrace(&self, frame: &Frame) {
+        let ctx = &mut self.runtime_ctx.borrow_mut();
+        if ctx.cfg.debug_mode {
+            let backtrace_frame = BacktraceFrame::from_panic_info(&ctx.panic_info);
+            ctx.backtrace.push(backtrace_frame);
+            ctx.panic_info.kcl_func = frame.proxy.get_name();
+        }
+    }
+
+    pub(crate) fn pop_backtrace(&self) {
+        let ctx = &mut self.runtime_ctx.borrow_mut();
+        if ctx.cfg.debug_mode {
+            if let Some(backtrace_frame) = ctx.backtrace.pop() {
+                ctx.panic_info.kcl_func = backtrace_frame.func;
+            }
+        }
+    }
 }
diff --git a/kclvm/evaluator/src/func.rs b/kclvm/evaluator/src/func.rs
@@ -57,6 +57,7 @@ impl<'ctx> Evaluator<'ctx> {
                 .clone()
         };
         self.push_pkgpath(&frame.pkgpath);
+        self.push_backtrace(&frame);
         let value = match &frame.proxy {
             Proxy::Lambda(lambda) => (lambda.body)(self, &lambda.ctx, args, kwargs),
             Proxy::Schema(schema) => {
@@ -69,6 +70,7 @@ impl<'ctx> Evaluator<'ctx> {
             }
             Proxy::Rule(rule) => (rule.body)(self, &rule.ctx, args, kwargs),
         };
+        self.pop_backtrace();
         self.pop_pkgpath();
         value
     }

diff --git a/kclvm/evaluator/src/node.rs b/kclvm/evaluator/src/node.rs
@@ -919,22 +919,26 @@ impl<'ctx> TypedResultWalker<'ctx> for Evaluator<'ctx> {
             };
             if let Proxy::Schema(schema) = &frame.proxy {
                 self.push_pkgpath(&frame.pkgpath);
+                self.push_backtrace(&frame);
                 // Set new schema and config
                 {
                     let mut ctx = schema.ctx.borrow_mut();
                     ctx.reset_with_config(config_value, config_meta);
                 }
                 let value = (schema.body)(self, &schema.ctx, &list_value, &dict_value);
+                self.pop_backtrace();
                 self.pop_pkgpath();
                 value
             } else if let Proxy::Rule(rule) = &frame.proxy {
                 self.push_pkgpath(&frame.pkgpath);
+                self.push_backtrace(&frame);
                 // Set new rule and config
                 {
                     let mut ctx = rule.ctx.borrow_mut();
                     ctx.reset_with_config(config_value, config_meta);
                 }
                 let value = (rule.body)(self, &rule.ctx, &list_value, &dict_value);
+                self.pop_backtrace();
                 self.pop_pkgpath();
                 value
             } else {

diff --git a/kclvm/evaluator/src/proxy.rs b/kclvm/evaluator/src/proxy.rs
@@ -21,6 +21,19 @@ pub enum Proxy {
     Rule(RuleCaller),
 }
 
+impl Proxy {
+    /// Get the name of the proxy, if it is an anonymous function, returns "lambda"
+    /// if it is a schema or rule, returns its name.
+    #[inline]
+    pub fn get_name(&self) -> String {
+        match self {
+            Proxy::Lambda(_) => "lambda".to_string(),
+            Proxy::Schema(s) => s.ctx.borrow().node.name.node.to_string(),
+            Proxy::Rule(r) => r.ctx.borrow().node.name.node.to_string(),
+        }
+    }
+}
+
 /// Call the associated schemas including parent schema and mixin schema
 pub(crate) fn call_schema_body(
     s: &Evaluator,
@@ -39,10 +52,12 @@ pub(crate) fn call_schema_body(
         };
         if let Proxy::Schema(schema) = &frame.proxy {
             s.push_pkgpath(&frame.pkgpath);
+            s.push_backtrace(&frame);
             {
                 schema.ctx.borrow_mut().set_info_with_schema(&ctx.borrow())
             }
             let value = (schema.body)(s, &schema.ctx, args, kwargs);
+            s.pop_backtrace();
             s.pop_pkgpath();
             value
         } else {
@@ -71,10 +86,12 @@ pub(crate) fn call_schema_body_from_rule(
         };
         if let Proxy::Schema(schema) = &frame.proxy {
             s.push_pkgpath(&frame.pkgpath);
+            s.push_backtrace(&frame);
             {
                 schema.ctx.borrow_mut().set_info_with_rule(&ctx.borrow())
             }
             let value = (schema.body)(s, &schema.ctx, args, kwargs);
+            s.pop_backtrace();
             s.pop_pkgpath();
             value
         } else {
@@ -102,10 +119,12 @@ pub(crate) fn call_schema_check(
         };
         if let Proxy::Schema(schema) = &frame.proxy {
             s.push_pkgpath(&frame.pkgpath);
+            s.push_backtrace(&frame);
             if let Some(ctx) = ctx {
                 schema.ctx.borrow_mut().set_info_with_schema(&ctx.borrow())
             }
             (schema.check)(s, &schema.ctx, args, kwargs);
+            s.pop_backtrace();
             s.pop_pkgpath();
         }
     }
@@ -122,7 +141,9 @@ pub(crate) fn call_rule_check(s: &Evaluator, func: &ValueRef, args: &ValueRef, k
         };
         if let Proxy::Rule(rule) = &frame.proxy {
             s.push_pkgpath(&frame.pkgpath);
+            s.push_backtrace(&frame);
             (rule.check)(s, &rule.ctx, args, kwargs);
+            s.pop_backtrace();
             s.pop_pkgpath();
         }
     }

diff --git a/kclvm/evaluator/src/schema.rs b/kclvm/evaluator/src/schema.rs
@@ -593,7 +593,9 @@ pub(crate) fn schema_check(
                 };
                 if let Proxy::Schema(schema) = &frame.proxy {
                     s.push_pkgpath(&frame.pkgpath);
+                    s.push_backtrace(&frame);
                     (schema.check)(s, &schema.ctx, args, kwargs);
+                    s.pop_backtrace();
                     s.pop_pkgpath();
                 }
             }

diff --git a/kclvm/evaluator/src/ty.rs b/kclvm/evaluator/src/ty.rs
@@ -36,12 +36,14 @@ pub fn resolve_schema(s: &Evaluator, schema: &ValueRef, keys: &[String]) -> Valu
         };
         let schema = if let Proxy::Schema(caller) = &frame.proxy {
             s.push_pkgpath(&frame.pkgpath);
+            s.push_backtrace(&frame);
             // Set new schema and config
             {
                 let mut ctx = caller.ctx.borrow_mut();
                 ctx.reset_with_config(config_value, config_meta);
             }
             let value = (caller.body)(s, &caller.ctx, &schema_value.args, &schema_value.kwargs);
+            s.pop_backtrace();
             s.pop_pkgpath();
             value
         } else {
@@ -157,12 +159,14 @@ pub fn convert_collection_value(s: &Evaluator, value: &ValueRef, tpe: &str) -> V
                     return value.clone();
                 }
                 s.push_pkgpath(&frame.pkgpath);
+                s.push_backtrace(&frame);
                 // Set new schema and config
                 {
                     let mut ctx = caller.ctx.borrow_mut();
                     ctx.reset_with_config(value.clone(), config_meta);
                 }
                 let value = (caller.body)(s, &caller.ctx, &s.list_value(), &s.dict_value());
+                s.pop_backtrace();
                 s.pop_pkgpath();
                 value
             } else {