use std::collections::HashSet;
use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, Mutex};
use serde::{Serialize, Deserialize};
use std::sync::RwLock;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorInfo {
pub error_type: String,
pub message: String,
pub stack_trace: Vec<StackFrame>,
pub context: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StackFrame {
pub file: String,
pub line: u32,
pub function: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Diagnosis {
pub error_type: String,
pub root_cause: RootCause,
pub explanation: String,
pub confidence: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RootCause {
pub description: String,
pub location: String,
pub related_code: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FixSuggestion {
pub title: String,
pub description: String,
pub fix_code: String,
pub confidence: f64,
pub explanation: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BreakpointSuggestion {
pub file: String,
pub line: u32,
pub reason: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DebugPath {
pub optimized_breakpoints: Vec<BreakpointSuggestion>,
pub estimated_time_saved: u32,
}
#[derive(Debug, Clone)]
pub struct SmartDebugger {
knowledge_base: Arc<RwLock<DebugKnowledgeBase>>,
pattern_matcher: Arc<ErrorPatternMatcher>,
fix_generator: Arc<FixGenerator>,
}
#[derive(Debug, Clone)]
pub struct DebugKnowledgeBase {
error_patterns: HashMap<String, ErrorPattern>,
fix_templates: HashMap<String, Vec<FixTemplate>>,
}
#[derive(Debug, Clone)]
pub struct ErrorPattern {
pub pattern: String,
pub error_types: Vec<String>,
pub description: String,
}
#[derive(Debug, Clone)]
pub struct FixTemplate {
pub title: String,
pub template_code: String,
pub explanation: String,
pub confidence: f64,
}
#[derive(Debug, Clone)]
pub struct ErrorPatternMatcher {
patterns: Arc<RwLock<Vec<ErrorPattern>>>,
}
#[derive(Debug, Clone)]
pub struct FixGenerator {
templates: Arc<RwLock<HashMap<String, Vec<FixTemplate>>>,
}
impl SmartDebugger {
pub fn new() -> Self {
let knowledge_base: _ = Arc::new(Mutex::new(DebugKnowledgeBase::new()),;
let pattern_matcher: _ = Arc::new(Mutex::new(ErrorPatternMatcher::new()),;
let fix_generator: _ = Arc::new(Mutex::new(FixGenerator::new()),;
Self {
knowledge_base,
pattern_matcher,
fix_generator,
}
}
/// 诊断错误
pub async fn diagnose_error(&self, error: &ErrorInfo) -> Result<Diagnosis, Box<dyn std::error::Error>> {
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
let diagnosis: _ = match error.error_type.as_str() {
"TypeError" => self.diagnose_type_error(error),
"ReferenceError" => self.diagnose_reference_error(error),
"SyntaxError" => self.diagnose_syntax_error(error),
"RangeError" => self.diagnose_range_error(error),
"EvalError" => self.diagnose_eval_error(error),
_ => self.diagnose_generic_error(error),
};
Ok(diagnosis)
}
/// 根因分析
pub async fn find_root_cause(&self, stack_trace: &[StackFrame]) -> Result<RootCause, Box<dyn std::error::Error>> {
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
if stack_trace.is_empty() {
return Err("栈追踪为空".into());
}
let deepest_frame: _ = &stack_trace[0];
let root_cause: _ = RootCause {
description: format!("错误源于 {}:{} 中的 {}", deepest_frame.file, deepest_frame.line, deepest_frame.function),
location: format!("{}:{}", deepest_frame.file, deepest_frame.line),
related_code: Some("相关代码片段".to_string()),
};
Ok(root_cause)
}
/// 生成修复建议
pub async fn suggest_fix(&self, diagnosis: &Diagnosis) -> Result<Vec<FixSuggestion>, Box<dyn std::error::Error>> {
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
let mut suggestions = Vec::new();
match diagnosis.error_type.as_str() {
"TypeError" => {
suggestions.push(FixSuggestion {
title: "检查变量类型".to_string(),
description: "TypeError 通常由类型不匹配引起".to_string(),
fix_code: "if (typeof variable === 'expectedType') { }".to_string(),
confidence: 0.9,
explanation: "通过添加类型检查可以避免 TypeError".to_string(),
});
}
"ReferenceError" => {
suggestions.push(FixSuggestion {
title: "检查变量声明".to_string(),
description: "ReferenceError 通常由未声明的变量引起".to_string(),
fix_code: "const myVariable = 'value';".to_string(),
confidence: 0.95,
explanation: "确保在使用变量前已正确声明".to_string(),
});
}
"SyntaxError" => {
suggestions.push(FixSuggestion {
title: "修复语法错误".to_string(),
description: "SyntaxError 由代码语法错误引起".to_string(),
fix_code: "// 检查括号、引号、分号等匹配".to_string(),
confidence: 0.98,
explanation: "检查并修复语法错误".to_string(),
});
}
_ => {
suggestions.push(FixSuggestion {
title: "通用调试建议".to_string(),
description: "添加日志和使用调试器".to_string(),
fix_code: "console.log('Debug info:', variable);".to_string(),
confidence: 0.7,
explanation: "添加调试信息帮助定位问题".to_string(),
});
}
}
Ok(suggestions)
}
/// 解释错误
pub async fn explain_error(&self, error: &ErrorInfo) -> Result<String, Box<dyn std::error::Error>> {
tokio::time::sleep(std::time::Duration::from_millis(17)).await;
let explanation: _ = match error.error_type.as_str() {
"TypeError" => format!("TypeError: {}\n\n这个错误表示尝试对错误类型的值进行操作。", error.message),
"ReferenceError" => format!("ReferenceError: {}\n\n这个错误表示尝试访问一个不存在的变量。", error.message),
"SyntaxError" => format!("SyntaxError: {}\n\n这个错误表示代码语法不符合语言规范。", error.message),
_ => format!("{}: {}\n\n这是一个运行时错误，可能的原因包括逻辑错误、数据问题等。", error.error_type, error.message),
};
Ok(explanation)
}
/// 优化调试路径
pub async fn optimize_debug_path(&self, breakpoints: &[BreakpointSuggestion], _execution_path: &[String]) -> Result<DebugPath, Box<dyn std::error::Error>> {
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
let mut optimized = Vec::new();
let mut seen_files = std::collections::HashSet::new();
for bp in breakpoints {
if !seen_files.contains(&bp.file) {
optimized.push(bp.clone());
seen_files.insert(bp.file.clone());
}
}
let time_saved: _ = (breakpoints.len() - optimized.len()) * 10;
Ok(DebugPath {
optimized_breakpoints: optimized,
estimated_time_saved: time_saved as u32,
})
}
/// 建议断点
pub async fn suggest_breakpoints(&self, code: &str) -> Result<Vec<BreakpointSuggestion>, Box<dyn std::error::Error>> {
tokio::time::sleep(std::time::Duration::from_millis(25)).await;
let mut suggestions = Vec::new();
if code.contains("function") {
suggestions.push(BreakpointSuggestion {
file: "script.js".to_string(),
line: 1,
reason: "函数入口".to_string(),
});
}
if code.contains("if") {
suggestions.push(BreakpointSuggestion {
file: "script.js".to_string(),
line: 10,
reason: "条件判断".to_string(),
});
}
if code.contains("for") {
suggestions.push(BreakpointSuggestion {
file: "script.js".to_string(),
line: 20,
reason: "循环开始".to_string(),
});
}
Ok(suggestions)
}
fn diagnose_type_error(&self, error: &ErrorInfo) -> Diagnosis {
Diagnosis {
error_type: "TypeError".to_string(),
root_cause: RootCause {
description: "尝试对错误类型的值进行操作".to_string(),
location: "未知位置".to_string(),
related_code: None,
},
explanation: format!("TypeError: {}", error.message),
confidence: 0.9,
}
}
fn diagnose_reference_error(&self, error: &ErrorInfo) -> Diagnosis {
Diagnosis {
error_type: "ReferenceError".to_string(),
root_cause: RootCause {
description: "访问了不存在的变量".to_string(),
location: "未知位置".to_string(),
related_code: None,
},
explanation: format!("ReferenceError: {}", error.message),
confidence: 0.95,
}
}
fn diagnose_syntax_error(&self, error: &ErrorInfo) -> Diagnosis {
Diagnosis {
error_type: "SyntaxError".to_string(),
root_cause: RootCause {
description: "代码语法不符合规范".to_string(),
location: "未知位置".to_string(),
related_code: None,
},
explanation: format!("SyntaxError: {}", error.message),
confidence: 0.98,
}
}
fn diagnose_range_error(&self, error: &ErrorInfo) -> Diagnosis {
Diagnosis {
error_type: "RangeError".to_string(),
root_cause: RootCause {
description: "值超出允许的范围".to_string(),
location: "未知位置".to_string(),
related_code: None,
},
explanation: format!("RangeError: {}", error.message),
confidence: 0.92,
}
}
fn diagnose_eval_error(&self, error: &ErrorInfo) -> Diagnosis {
Diagnosis {
error_type: "EvalError".to_string(),
root_cause: RootCause {
description: "eval() 函数使用不当".to_string(),
location: "未知位置".to_string(),
related_code: None,
},
explanation: format!("EvalError: {}", error.message),
confidence: 0.88,
}
}
fn diagnose_generic_error(&self, error: &ErrorInfo) -> Diagnosis {
Diagnosis {
error_type: error.error_type.clone(),
root_cause: RootCause {
description: "未知错误类型，需要进一步分析".to_string(),
location: "未知位置".to_string(),
related_code: None,
},
explanation: format!("{}: {}", error.error_type, error.message),
confidence: 0.7,
}
}
}
impl DebugKnowledgeBase {
pub fn new() -> Self {
let mut error_patterns = HashMap::new();
let mut fix_templates = HashMap::new();
error_patterns.insert(
"type_error".to_string(),
ErrorPattern {
pattern: "Cannot read property".to_string(),
error_types: vec!["TypeError".to_string()],
description: "类型错误模式".to_string(),
},
);
fix_templates.insert(
"TypeError".to_string(),
vec![FixTemplate {
title: "类型检查".to_string(),
template_code: "if (typeof variable === 'expectedType') { }".to_string(),
explanation: "添加类型检查".to_string(),
confidence: 0.9,
}],
);
Self {
error_patterns,
fix_templates,
}
}
}
impl ErrorPatternMatcher {
pub fn new() -> Self {
Self {
patterns: Arc::new(Mutex::new(Vec::new()))
}
}
}
impl FixGenerator {
pub fn new() -> Self {
Self {
templates: Arc::new(Mutex::new(HashMap::new()))
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
#[tokio::test]
async fn test_smart_debugger_creation() {
let debugger: _ = SmartDebugger::new();
assert!(debugger.knowledge_base.read().await.error_patterns.len() > 0);
}
#[tokio::test]
async fn test_error_diagnosis() {
let debugger: _ = SmartDebugger::new();
let error: _ = ErrorInfo {
error_type: "TypeError".to_string(),
message: "Cannot read property 'length' of undefined".to_string(),
stack_trace: vec![
StackFrame {
file: "app.js".to_string(),
line: 10,
function: "processData".to_string(),
},
],
context: Some("数据处理函数".to_string()),
};
let diagnosis: _ = debugger.diagnose_error(&error).await.unwrap();
assert_eq!(diagnosis.error_type, "TypeError");
assert!(diagnosis.confidence > 0.8);
assert!(!diagnosis.explanation.is_empty());
}
#[tokio::test]
async fn test_root_cause_analysis() {
let debugger: _ = SmartDebugger::new();
let stack_trace: _ = vec![
StackFrame {
file: "lib.js".to_string(),
line: 25,
function: "deepFunction".to_string(),
},
];
let root_cause: _ = debugger.find_root_cause(&stack_trace).await.unwrap();
assert!(!root_cause.description.is_empty());
assert!(!root_cause.location.is_empty());
assert!(root_cause.related_code.is_some());
}
#[tokio::test]
async fn test_fix_suggestions() {
let debugger: _ = SmartDebugger::new();
let diagnosis: _ = Diagnosis {
error_type: "TypeError".to_string(),
root_cause: RootCause {
description: "类型错误".to_string(),
location: "app.js:10".to_string(),
related_code: None,
},
explanation: "TypeError 示例".to_string(),
confidence: 0.9,
};
let suggestions: _ = debugger.suggest_fix(&diagnosis).await.unwrap();
assert!(!suggestions.is_empty());
let first_suggestion: _ = &suggestions[0];
assert!(!first_suggestion.title.is_empty());
assert!(!first_suggestion.fix_code.is_empty());
}
#[tokio::test]
async fn test_error_explanation() {
let debugger: _ = SmartDebugger::new();
let type_error: _ = ErrorInfo {
error_type: "TypeError".to_string(),
message: "Cannot read property 'map' of undefined".to_string(),
stack_trace: vec![],
context: None,
};
let explanation: _ = debugger.explain_error(&type_error).await.unwrap();
assert!(explanation.contains("TypeError"));
assert!(explanation.contains("类型"));
}
#[tokio::test]
async fn test_empty_stack_trace() {
let debugger: _ = SmartDebugger::new();
let empty_stack: Vec<StackFrame> = vec![];
let result: _ = debugger.find_root_cause(&empty_stack).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_multiple_error_types() {
let debugger: _ = SmartDebugger::new();
let error_types: _ = vec![
("TypeError", "Cannot read property 'x' of undefined"),
("ReferenceError", "x is not defined"),
("SyntaxError", "Unexpected token"),
];
for (error_type, message) in error_types {
let error: _ = ErrorInfo {
error_type: error_type.to_string(),
message: message.to_string(),
stack_trace: vec![StackFrame {
file: "test.js".to_string(),
line: 1,
function: "test".to_string(),
}],
context: None,
};
let diagnosis: _ = debugger.diagnose_error(&error).await.unwrap();
let explanation: _ = debugger.explain_error(&error).await.unwrap();
let suggestions: _ = debugger.suggest_fix(&diagnosis).await.unwrap();
assert_eq!(diagnosis.error_type, error_type);
assert!(!explanation.is_empty());
assert!(!suggestions.is_empty());
}
}
}