1007 lines
35 KiB
Rust
1007 lines
35 KiB
Rust
|
/*!
|
||
|
|
* Nyash Rust Implementation - Everything is Box in Memory Safe Rust
|
||
|
|
*
|
||
|
|
* This is the main entry point for the Rust implementation of Nyash,
|
||
|
|
* demonstrating the "Everything is Box" philosophy with Rust's ownership system.
|
||
|
|
*/
|
||
|
|
|
||
|
|
pub mod box_trait;
|
||
|
|
pub mod boxes;
|
||
|
|
pub mod environment;
|
||
|
|
pub mod tokenizer;
|
||
|
|
pub mod ast;
|
||
|
|
pub mod parser;
|
||
|
|
pub mod interpreter;
|
||
|
|
pub mod instance;
|
||
|
|
pub mod channel_box;
|
||
|
|
pub mod finalization;
|
||
|
|
pub mod exception_box;
|
||
|
|
pub mod method_box;
|
||
|
|
|
||
|
|
use box_trait::{NyashBox, StringBox, IntegerBox, BoolBox, VoidBox, AddBox};
|
||
|
|
use environment::{Environment, PythonCompatEnvironment};
|
||
|
|
use tokenizer::{NyashTokenizer, TokenType};
|
||
|
|
use ast::ASTNode;
|
||
|
|
use parser::NyashParser;
|
||
|
|
use interpreter::NyashInterpreter;
|
||
|
|
use std::env;
|
||
|
|
use std::fs;
|
||
|
|
use std::process;
|
||
|
|
|
||
|
|
fn main() {
|
||
|
|
let args: Vec<String> = env::args().collect();
|
||
|
|
|
||
|
|
if args.len() > 1 {
|
||
|
|
// File mode: parse and execute the provided .nyash file
|
||
|
|
let filename = &args[1];
|
||
|
|
println!("🦀 Nyash Rust Implementation - Executing file: {} 🦀", filename);
|
||
|
|
println!("====================================================");
|
||
|
|
|
||
|
|
execute_nyash_file(filename);
|
||
|
|
} else {
|
||
|
|
// Demo mode: run built-in demonstrations
|
||
|
|
println!("🦀 Nyash Rust Implementation - Everything is Box! 🦀");
|
||
|
|
println!("====================================================");
|
||
|
|
|
||
|
|
// Demonstrate basic Box creation and operations
|
||
|
|
demo_basic_boxes();
|
||
|
|
|
||
|
|
// Demonstrate Box operations
|
||
|
|
demo_box_operations();
|
||
|
|
|
||
|
|
// Demonstrate Box collections
|
||
|
|
demo_box_collections();
|
||
|
|
|
||
|
|
// Demonstrate Environment & Scope management
|
||
|
|
demo_environment_system();
|
||
|
|
|
||
|
|
// Demonstrate Tokenizer system
|
||
|
|
demo_tokenizer_system();
|
||
|
|
|
||
|
|
// Demonstrate Parser system
|
||
|
|
demo_parser_system();
|
||
|
|
|
||
|
|
// Demonstrate Interpreter system
|
||
|
|
demo_interpreter_system();
|
||
|
|
|
||
|
|
println!("\n🎉 All Box operations completed successfully!");
|
||
|
|
println!("Memory safety guaranteed by Rust's borrow checker! 🛡️");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn execute_nyash_file(filename: &str) {
|
||
|
|
// Read the file
|
||
|
|
let code = match fs::read_to_string(filename) {
|
||
|
|
Ok(content) => content,
|
||
|
|
Err(e) => {
|
||
|
|
eprintln!("❌ Error reading file {}: {}", filename, e);
|
||
|
|
process::exit(1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
println!("📝 File contents:\n{}", code);
|
||
|
|
println!("\n🚀 Parsing and executing...\n");
|
||
|
|
|
||
|
|
// Parse the code
|
||
|
|
let ast = match NyashParser::parse_from_string(&code) {
|
||
|
|
Ok(ast) => ast,
|
||
|
|
Err(e) => {
|
||
|
|
eprintln!("❌ Parse error: {}", e);
|
||
|
|
process::exit(1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
println!("✅ Parse successful!");
|
||
|
|
|
||
|
|
// Execute the AST
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(result) => {
|
||
|
|
println!("✅ Execution completed successfully!");
|
||
|
|
println!("Result: {}", result.to_string_box().value);
|
||
|
|
},
|
||
|
|
Err(e) => {
|
||
|
|
// 🔥 Use enhanced error reporting with source context
|
||
|
|
eprintln!("❌ Runtime error:\n{}", e.detailed_message(Some(&code)));
|
||
|
|
process::exit(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_basic_boxes() {
|
||
|
|
println!("\n📦 1. Basic Box Creation:");
|
||
|
|
|
||
|
|
// Create basic boxes
|
||
|
|
let string_box = StringBox::new("Hello from Rust!");
|
||
|
|
let integer_box = IntegerBox::new(42);
|
||
|
|
let bool_box = BoolBox::new(true);
|
||
|
|
let void_box = VoidBox::new();
|
||
|
|
|
||
|
|
println!(" StringBox: {} (ID: {})", string_box, string_box.box_id());
|
||
|
|
println!(" IntegerBox: {} (ID: {})", integer_box, integer_box.box_id());
|
||
|
|
println!(" BoolBox: {} (ID: {})", bool_box, bool_box.box_id());
|
||
|
|
println!(" VoidBox: {} (ID: {})", void_box, void_box.box_id());
|
||
|
|
|
||
|
|
// Test type identification
|
||
|
|
println!("\n🔍 Type Information:");
|
||
|
|
println!(" StringBox type: {}", string_box.type_name());
|
||
|
|
println!(" IntegerBox type: {}", integer_box.type_name());
|
||
|
|
println!(" BoolBox type: {}", bool_box.type_name());
|
||
|
|
println!(" VoidBox type: {}", void_box.type_name());
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_box_operations() {
|
||
|
|
println!("\n⚡ 2. Box Operations:");
|
||
|
|
|
||
|
|
// Integer addition
|
||
|
|
let left_int = Box::new(IntegerBox::new(10)) as Box<dyn NyashBox>;
|
||
|
|
let right_int = Box::new(IntegerBox::new(32)) as Box<dyn NyashBox>;
|
||
|
|
let int_add = AddBox::new(left_int, right_int);
|
||
|
|
let int_result = int_add.execute();
|
||
|
|
|
||
|
|
println!(" Integer Addition: 10 + 32 = {}", int_result.to_string_box());
|
||
|
|
|
||
|
|
// String concatenation
|
||
|
|
let left_str = Box::new(StringBox::new("Everything is ")) as Box<dyn NyashBox>;
|
||
|
|
let right_str = Box::new(StringBox::new("Box in Rust!")) as Box<dyn NyashBox>;
|
||
|
|
let str_add = AddBox::new(left_str, right_str);
|
||
|
|
let str_result = str_add.execute();
|
||
|
|
|
||
|
|
println!(" String Concatenation: {}", str_result.to_string_box());
|
||
|
|
|
||
|
|
// Mixed type addition (falls back to string concatenation)
|
||
|
|
let mixed_left = Box::new(StringBox::new("Answer: ")) as Box<dyn NyashBox>;
|
||
|
|
let mixed_right = Box::new(IntegerBox::new(42)) as Box<dyn NyashBox>;
|
||
|
|
let mixed_add = AddBox::new(mixed_left, mixed_right);
|
||
|
|
let mixed_result = mixed_add.execute();
|
||
|
|
|
||
|
|
println!(" Mixed Addition: {}", mixed_result.to_string_box());
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_box_collections() {
|
||
|
|
println!("\n📚 3. Box Collections:");
|
||
|
|
|
||
|
|
// Create a collection of various boxes
|
||
|
|
let mut box_collection: Vec<Box<dyn NyashBox>> = Vec::new();
|
||
|
|
|
||
|
|
box_collection.push(Box::new(StringBox::new("First Box")));
|
||
|
|
box_collection.push(Box::new(IntegerBox::new(100)));
|
||
|
|
box_collection.push(Box::new(BoolBox::new(false)));
|
||
|
|
box_collection.push(Box::new(VoidBox::new()));
|
||
|
|
|
||
|
|
println!(" Collection contents:");
|
||
|
|
for (i, box_item) in box_collection.iter().enumerate() {
|
||
|
|
println!(" [{}] {} (Type: {}, ID: {})",
|
||
|
|
i,
|
||
|
|
box_item.to_string_box(),
|
||
|
|
box_item.type_name(),
|
||
|
|
box_item.box_id());
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test equality
|
||
|
|
println!("\n🔍 Equality Testing:");
|
||
|
|
let test1 = StringBox::new("test");
|
||
|
|
let test2 = StringBox::new("test");
|
||
|
|
let test3 = StringBox::new("different");
|
||
|
|
|
||
|
|
println!(" \"test\" == \"test\": {}", test1.equals(&test2));
|
||
|
|
println!(" \"test\" == \"different\": {}", test1.equals(&test3));
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_environment_system() {
|
||
|
|
println!("\n🌐 4. Environment & Scope Management:");
|
||
|
|
|
||
|
|
// Create global environment
|
||
|
|
let global_env = Environment::new_global();
|
||
|
|
println!(" Created global environment: {}", global_env.lock().unwrap().scope_info());
|
||
|
|
|
||
|
|
// Add global variables
|
||
|
|
global_env.lock().unwrap().define("project_name", Box::new(StringBox::new("Nyash in Rust")));
|
||
|
|
global_env.lock().unwrap().define("version", Box::new(StringBox::new("v1.0-rust")));
|
||
|
|
global_env.lock().unwrap().define("debug_mode", Box::new(BoolBox::new(true)));
|
||
|
|
|
||
|
|
println!(" Global variables: {:?}", global_env.lock().unwrap().list_variables());
|
||
|
|
|
||
|
|
// Create function scope
|
||
|
|
let function_env = Environment::new_child(global_env.clone(), "test_function");
|
||
|
|
println!(" Created function scope: {}", function_env.lock().unwrap().scope_info());
|
||
|
|
|
||
|
|
// Add local variables
|
||
|
|
function_env.lock().unwrap().define("local_var", Box::new(IntegerBox::new(42)));
|
||
|
|
function_env.lock().unwrap().define("temp_result", Box::new(StringBox::new("processing...")));
|
||
|
|
|
||
|
|
// Test variable access from child scope
|
||
|
|
println!("\n 🔍 Variable Access Tests:");
|
||
|
|
|
||
|
|
// Access global variable from function scope
|
||
|
|
match function_env.lock().unwrap().get("project_name") {
|
||
|
|
Ok(value) => println!(" Access global from function: {}", value.to_string_box()),
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Access local variable
|
||
|
|
match function_env.lock().unwrap().get("local_var") {
|
||
|
|
Ok(value) => println!(" Access local variable: {}", value.to_string_box()),
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Try to access local variable from global (should fail)
|
||
|
|
match global_env.lock().unwrap().get("local_var") {
|
||
|
|
Ok(value) => println!(" Unexpected access to local from global: {}", value.to_string_box()),
|
||
|
|
Err(e) => println!(" ✅ Correctly blocked access to local from global: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test variable setting (modification)
|
||
|
|
println!("\n 🔧 Variable Modification Tests:");
|
||
|
|
|
||
|
|
// Modify global variable from function scope
|
||
|
|
let _ = function_env.lock().unwrap().set("version", Box::new(StringBox::new("v1.1-rust-updated")));
|
||
|
|
|
||
|
|
// Check if global was updated
|
||
|
|
let updated_version = global_env.lock().unwrap().get("version").unwrap();
|
||
|
|
println!(" Updated global variable: {}", updated_version.to_string_box());
|
||
|
|
|
||
|
|
// Create nested scope (function inside function)
|
||
|
|
let nested_env = Environment::new_child(function_env.clone(), "nested_function");
|
||
|
|
nested_env.lock().unwrap().define("nested_var", Box::new(BoolBox::new(false)));
|
||
|
|
|
||
|
|
// Test scope chain
|
||
|
|
println!("\n 📊 Scope Chain Analysis:");
|
||
|
|
let scope_chain = nested_env.lock().unwrap().scope_chain_info();
|
||
|
|
for (i, scope_info) in scope_chain.iter().enumerate() {
|
||
|
|
println!(" Level {}: {}", i, scope_info);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test variable shadowing
|
||
|
|
println!("\n 🌑 Variable Shadowing Test:");
|
||
|
|
function_env.lock().unwrap().define("debug_mode", Box::new(BoolBox::new(false))); // Shadow global
|
||
|
|
|
||
|
|
let global_debug = global_env.lock().unwrap().get("debug_mode").unwrap();
|
||
|
|
let function_debug = function_env.lock().unwrap().get("debug_mode").unwrap();
|
||
|
|
|
||
|
|
println!(" Global debug_mode: {}", global_debug.to_string_box());
|
||
|
|
println!(" Function debug_mode (shadowed): {}", function_debug.to_string_box());
|
||
|
|
|
||
|
|
// Test Python compatibility layer
|
||
|
|
println!("\n 🐍 Python Compatibility Layer:");
|
||
|
|
let mut python_env = PythonCompatEnvironment::new();
|
||
|
|
python_env.define("py_var", Box::new(StringBox::new("python_style")));
|
||
|
|
|
||
|
|
let py_value = python_env.get("py_var");
|
||
|
|
println!(" Python-style access: {}", py_value.to_string_box());
|
||
|
|
println!(" _bindings contains: {:?}", python_env._bindings.keys().collect::<Vec<_>>());
|
||
|
|
|
||
|
|
// Dump all variables for debugging
|
||
|
|
println!("\n 📋 Complete Variable Dump:");
|
||
|
|
let all_vars = nested_env.lock().unwrap().dump_all_variables();
|
||
|
|
for (qualified_name, value) in all_vars {
|
||
|
|
println!(" {}: {}", qualified_name, value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_tokenizer_system() {
|
||
|
|
println!("\n🔤 5. Tokenizer System:");
|
||
|
|
|
||
|
|
// Test simple tokens
|
||
|
|
println!(" 📝 Simple Token Test:");
|
||
|
|
let simple_code = "box TestBox { value }";
|
||
|
|
let mut tokenizer = NyashTokenizer::new(simple_code);
|
||
|
|
|
||
|
|
match tokenizer.tokenize() {
|
||
|
|
Ok(tokens) => {
|
||
|
|
println!(" Input: {}", simple_code);
|
||
|
|
println!(" Tokens:");
|
||
|
|
for (i, token) in tokens.iter().enumerate() {
|
||
|
|
if matches!(token.token_type, TokenType::EOF) {
|
||
|
|
break; // EOF は表示しない
|
||
|
|
}
|
||
|
|
println!(" [{}] {:?} at line {}, column {}",
|
||
|
|
i, token.token_type, token.line, token.column);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test complex code (same as debug_this_problem.nyash)
|
||
|
|
println!("\n 🚀 Complex Code Test:");
|
||
|
|
let complex_code = r#"
|
||
|
|
// this問題のミニマル再現
|
||
|
|
box TestBox {
|
||
|
|
value
|
||
|
|
|
||
|
|
getValue() {
|
||
|
|
return this.value
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// テスト
|
||
|
|
obj = new TestBox()
|
||
|
|
obj.value = "test123"
|
||
|
|
print("Direct field: " + obj.value)
|
||
|
|
print("Method call: " + obj.getValue())
|
||
|
|
"#;
|
||
|
|
|
||
|
|
let mut complex_tokenizer = NyashTokenizer::new(complex_code);
|
||
|
|
match complex_tokenizer.tokenize() {
|
||
|
|
Ok(tokens) => {
|
||
|
|
let non_eof_tokens: Vec<_> = tokens.iter()
|
||
|
|
.filter(|t| !matches!(t.token_type, TokenType::EOF))
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
println!(" Successfully tokenized {} tokens", non_eof_tokens.len());
|
||
|
|
|
||
|
|
// Show first 10 tokens
|
||
|
|
println!(" First 10 tokens:");
|
||
|
|
for (i, token) in non_eof_tokens.iter().take(10).enumerate() {
|
||
|
|
println!(" [{}] {:?}", i, token.token_type);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Count token types
|
||
|
|
let mut token_counts = std::collections::HashMap::new();
|
||
|
|
for token in &non_eof_tokens {
|
||
|
|
let type_name = match &token.token_type {
|
||
|
|
TokenType::IDENTIFIER(_) => "IDENTIFIER",
|
||
|
|
TokenType::STRING(_) => "STRING",
|
||
|
|
TokenType::NUMBER(_) => "NUMBER",
|
||
|
|
TokenType::BOX => "BOX",
|
||
|
|
TokenType::NEW => "NEW",
|
||
|
|
TokenType::THIS => "THIS",
|
||
|
|
TokenType::RETURN => "RETURN",
|
||
|
|
TokenType::PRINT => "PRINT",
|
||
|
|
TokenType::DOT => "DOT",
|
||
|
|
TokenType::ASSIGN => "ASSIGN",
|
||
|
|
TokenType::PLUS => "PLUS",
|
||
|
|
TokenType::LPAREN => "LPAREN",
|
||
|
|
TokenType::RPAREN => "RPAREN",
|
||
|
|
TokenType::LBRACE => "LBRACE",
|
||
|
|
TokenType::RBRACE => "RBRACE",
|
||
|
|
_ => "OTHER",
|
||
|
|
};
|
||
|
|
*token_counts.entry(type_name).or_insert(0) += 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
println!(" Token type counts:");
|
||
|
|
for (type_name, count) in token_counts {
|
||
|
|
println!(" {}: {}", type_name, count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test string literals and escapes
|
||
|
|
println!("\n 📝 String Literal Test:");
|
||
|
|
let string_code = r#""Hello, World!" "Line 1\nLine 2" "Tab\tSeparated""#;
|
||
|
|
let mut string_tokenizer = NyashTokenizer::new(string_code);
|
||
|
|
|
||
|
|
match string_tokenizer.tokenize() {
|
||
|
|
Ok(tokens) => {
|
||
|
|
for token in tokens.iter() {
|
||
|
|
if let TokenType::STRING(s) = &token.token_type {
|
||
|
|
println!(" String: {:?}", s);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test numbers
|
||
|
|
println!("\n 🔢 Number Test:");
|
||
|
|
let number_code = "42 0 123 999";
|
||
|
|
let mut number_tokenizer = NyashTokenizer::new(number_code);
|
||
|
|
|
||
|
|
match number_tokenizer.tokenize() {
|
||
|
|
Ok(tokens) => {
|
||
|
|
for token in tokens.iter() {
|
||
|
|
if let TokenType::NUMBER(n) = &token.token_type {
|
||
|
|
println!(" Number: {}", n);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test error handling
|
||
|
|
println!("\n ❌ Error Handling Test:");
|
||
|
|
let error_code = "box test @#$%";
|
||
|
|
let mut error_tokenizer = NyashTokenizer::new(error_code);
|
||
|
|
|
||
|
|
match error_tokenizer.tokenize() {
|
||
|
|
Ok(_) => println!(" Unexpected success"),
|
||
|
|
Err(e) => println!(" Expected error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_parser_system() {
|
||
|
|
println!("\n🌳 6. Parser & AST System:");
|
||
|
|
|
||
|
|
// Test simple box declaration
|
||
|
|
println!(" 📝 Simple Box Declaration Test:");
|
||
|
|
let simple_code = r#"
|
||
|
|
box TestBox {
|
||
|
|
value
|
||
|
|
|
||
|
|
getValue() {
|
||
|
|
return this.value
|
||
|
|
}
|
||
|
|
}
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(simple_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
println!(" Input: {}", simple_code.trim());
|
||
|
|
println!(" AST: {}", ast);
|
||
|
|
|
||
|
|
if let ASTNode::Program { statements, .. } = &ast {
|
||
|
|
println!(" Program has {} statements", statements.len());
|
||
|
|
for (i, stmt) in statements.iter().enumerate() {
|
||
|
|
println!(" [{}] {}", i, stmt.info());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test assignment and method call
|
||
|
|
println!("\n 🚀 Assignment & Method Call Test:");
|
||
|
|
let assignment_code = r#"
|
||
|
|
obj = new TestBox()
|
||
|
|
obj.value = "test123"
|
||
|
|
print("Direct field: " + obj.value)
|
||
|
|
print("Method call: " + obj.getValue())
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(assignment_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
println!(" Successfully parsed assignment & method call code");
|
||
|
|
|
||
|
|
if let ASTNode::Program { statements, .. } = &ast {
|
||
|
|
println!(" Parsed {} statements:", statements.len());
|
||
|
|
for (i, stmt) in statements.iter().enumerate() {
|
||
|
|
println!(" [{}] {} ({})", i, stmt.info(), stmt.node_type());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test expression parsing
|
||
|
|
println!("\n ⚡ Expression Parsing Test:");
|
||
|
|
let expr_code = r#"
|
||
|
|
result = x + y * z
|
||
|
|
condition = a == b && c < d
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(expr_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
println!(" Successfully parsed complex expressions");
|
||
|
|
|
||
|
|
if let ASTNode::Program { statements, .. } = &ast {
|
||
|
|
for (i, stmt) in statements.iter().enumerate() {
|
||
|
|
if let ASTNode::Assignment { target, value, .. } = stmt {
|
||
|
|
println!(" Assignment [{}]: {} = {}", i, target.info(), value.info());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test control structures
|
||
|
|
println!("\n 🔄 Control Structure Test:");
|
||
|
|
let control_code = r#"
|
||
|
|
if condition {
|
||
|
|
print("True branch")
|
||
|
|
} else {
|
||
|
|
print("False branch")
|
||
|
|
}
|
||
|
|
|
||
|
|
loop {
|
||
|
|
print("Loop body")
|
||
|
|
return
|
||
|
|
}
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(control_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
println!(" Successfully parsed control structures");
|
||
|
|
|
||
|
|
if let ASTNode::Program { statements, .. } = &ast {
|
||
|
|
for (i, stmt) in statements.iter().enumerate() {
|
||
|
|
println!(" [{}] {} ({})", i, stmt.info(), stmt.node_type());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" Error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test the debug_this_problem.nyash equivalent
|
||
|
|
println!("\n 🐛 Debug This Problem Test (Rust Parser):");
|
||
|
|
let debug_code = r#"
|
||
|
|
// this問題のミニマル再現
|
||
|
|
box TestBox {
|
||
|
|
value
|
||
|
|
|
||
|
|
getValue() {
|
||
|
|
return this.value
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// テスト
|
||
|
|
obj = new TestBox()
|
||
|
|
obj.value = "test123"
|
||
|
|
print("Direct field: " + obj.value)
|
||
|
|
print("Method call: " + obj.getValue())
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(debug_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
println!(" ✅ Successfully parsed debug_this_problem equivalent!");
|
||
|
|
|
||
|
|
if let ASTNode::Program { statements, .. } = &ast {
|
||
|
|
println!(" Complete program structure:");
|
||
|
|
println!(" Total statements: {}", statements.len());
|
||
|
|
|
||
|
|
let mut box_count = 0;
|
||
|
|
let mut assignment_count = 0;
|
||
|
|
let mut print_count = 0;
|
||
|
|
let mut method_calls = 0;
|
||
|
|
|
||
|
|
for stmt in statements {
|
||
|
|
match stmt {
|
||
|
|
ASTNode::BoxDeclaration { .. } => box_count += 1,
|
||
|
|
ASTNode::Assignment { .. } => assignment_count += 1,
|
||
|
|
ASTNode::Print { .. } => print_count += 1,
|
||
|
|
_ => {}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Count method calls recursively
|
||
|
|
count_method_calls(stmt, &mut method_calls);
|
||
|
|
}
|
||
|
|
|
||
|
|
println!(" - Box declarations: {}", box_count);
|
||
|
|
println!(" - Assignments: {}", assignment_count);
|
||
|
|
println!(" - Print statements: {}", print_count);
|
||
|
|
println!(" - Method calls found: {}", method_calls);
|
||
|
|
|
||
|
|
println!(" 🎯 Parser successfully handles 'this' context in AST!");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Helper function to count method calls recursively
|
||
|
|
fn count_method_calls(node: &ASTNode, count: &mut usize) {
|
||
|
|
match node {
|
||
|
|
ASTNode::MethodCall { .. } => {
|
||
|
|
*count += 1;
|
||
|
|
}
|
||
|
|
ASTNode::Program { statements, .. } => {
|
||
|
|
for stmt in statements {
|
||
|
|
count_method_calls(stmt, count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ASTNode::Assignment { target, value, .. } => {
|
||
|
|
count_method_calls(target, count);
|
||
|
|
count_method_calls(value, count);
|
||
|
|
}
|
||
|
|
ASTNode::Print { expression, .. } => {
|
||
|
|
count_method_calls(expression, count);
|
||
|
|
}
|
||
|
|
ASTNode::BinaryOp { left, right, .. } => {
|
||
|
|
count_method_calls(left, count);
|
||
|
|
count_method_calls(right, count);
|
||
|
|
}
|
||
|
|
ASTNode::BoxDeclaration { methods, .. } => {
|
||
|
|
for method in methods.values() {
|
||
|
|
count_method_calls(method, count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ASTNode::FunctionDeclaration { body, .. } => {
|
||
|
|
for stmt in body {
|
||
|
|
count_method_calls(stmt, count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ASTNode::Return { value, .. } => {
|
||
|
|
if let Some(val) = value {
|
||
|
|
count_method_calls(val, count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_ => {}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn demo_interpreter_system() {
|
||
|
|
println!("\n🚀 7. Interpreter & Execution System:");
|
||
|
|
|
||
|
|
// Test simple variable assignment and print
|
||
|
|
println!(" 📝 Simple Assignment & Print Test:");
|
||
|
|
let simple_code = r#"
|
||
|
|
x = 42
|
||
|
|
y = "Hello, Nyash!"
|
||
|
|
print(x)
|
||
|
|
print(y)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(simple_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Code: {}", simple_code.trim());
|
||
|
|
println!(" Output:");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ Execution successful!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test arithmetic operations
|
||
|
|
println!("\n ⚡ Arithmetic Operations Test:");
|
||
|
|
let arithmetic_code = r#"
|
||
|
|
a = 10
|
||
|
|
b = 32
|
||
|
|
result = a + b
|
||
|
|
print("10 + 32 = " + result)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(arithmetic_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing arithmetic operations...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ Arithmetic execution successful!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test if statements
|
||
|
|
println!("\n 🔄 Control Flow (If) Test:");
|
||
|
|
let if_code = r#"
|
||
|
|
condition = true
|
||
|
|
if condition {
|
||
|
|
print("Condition was true!")
|
||
|
|
result = "success"
|
||
|
|
} else {
|
||
|
|
print("Condition was false!")
|
||
|
|
result = "failure"
|
||
|
|
}
|
||
|
|
print("Result: " + result)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(if_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing if statement...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ If statement execution successful!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test AND/OR operators
|
||
|
|
println!("\n 🔗 Logical Operators Test:");
|
||
|
|
let logic_code = r#"
|
||
|
|
a = true
|
||
|
|
b = false
|
||
|
|
result1 = a && b
|
||
|
|
result2 = a || b
|
||
|
|
print("true && false = " + result1)
|
||
|
|
print("true || false = " + result2)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(logic_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing logical operators...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ Logical operators execution successful!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test loop with break
|
||
|
|
println!("\n 🔁 Loop with Break Test:");
|
||
|
|
let loop_code = r#"
|
||
|
|
counter = 0
|
||
|
|
loop {
|
||
|
|
counter = counter + 1
|
||
|
|
print("Loop iteration: " + counter)
|
||
|
|
if counter == 3 {
|
||
|
|
print("Breaking loop!")
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
print("Final counter: " + counter)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(loop_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing loop with break...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ Loop execution successful!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test Box declaration and instance creation
|
||
|
|
println!("\n 📦 Box Declaration & Instance Test:");
|
||
|
|
let box_code = r#"
|
||
|
|
box TestBox {
|
||
|
|
value
|
||
|
|
|
||
|
|
getValue() {
|
||
|
|
return this.value
|
||
|
|
}
|
||
|
|
|
||
|
|
setValue(newValue) {
|
||
|
|
this.value = newValue
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create instance
|
||
|
|
obj = new TestBox()
|
||
|
|
print("Created TestBox instance: " + obj)
|
||
|
|
|
||
|
|
// Set field directly
|
||
|
|
obj.value = "test123"
|
||
|
|
print("Set field directly: obj.value = " + obj.value)
|
||
|
|
|
||
|
|
// Call method that uses this
|
||
|
|
result = obj.getValue()
|
||
|
|
print("Method call result: " + result)
|
||
|
|
|
||
|
|
// Call method that modifies via this
|
||
|
|
obj.setValue("modified value")
|
||
|
|
print("After setValue: " + obj.value)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(box_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Testing Box instances with 'this' binding...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ Box instance & 'this' working correctly!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test global variable
|
||
|
|
println!("\n 🌍 Global Variable Test:");
|
||
|
|
let global_code = r#"
|
||
|
|
global project_name = "Nyash in Rust"
|
||
|
|
global version = "v1.0"
|
||
|
|
|
||
|
|
print("Project: " + project_name)
|
||
|
|
print("Version: " + version)
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(global_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Setting global variables...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" ✅ Global variables successful!"),
|
||
|
|
Err(e) => println!(" ❌ Runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Parse error: {}", e),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test Self-Hosting Demonstration
|
||
|
|
println!("\n 🎆 SELF-HOSTING DEMONSTRATION 🎆:");
|
||
|
|
println!(" Loading self-hosting test file...");
|
||
|
|
|
||
|
|
match std::fs::read_to_string("test_self_hosting_simple.nyash") {
|
||
|
|
Ok(self_hosting_code) => {
|
||
|
|
match NyashParser::parse_from_string(&self_hosting_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing self-hosting simulation...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => {
|
||
|
|
println!(" 🚀 LEGENDARY ACHIEVEMENT UNLOCKED! 🚀");
|
||
|
|
println!(" Rust-based Nyash interpreter successfully executed");
|
||
|
|
println!(" Nyash code that simulates compiling other Nyash code!");
|
||
|
|
println!(" Self-hosting level: ULTIMATE META-PROGRAMMING! 🎆");
|
||
|
|
},
|
||
|
|
Err(e) => println!(" ❌ Self-hosting runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Self-hosting parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(_) => {
|
||
|
|
println!(" ⚠️ test_self_hosting_simple.nyash not found, using inline test:");
|
||
|
|
|
||
|
|
let inline_self_hosting = r#"
|
||
|
|
print("🎆 Inline Self-Hosting Test 🎆")
|
||
|
|
|
||
|
|
box MetaCompiler {
|
||
|
|
name
|
||
|
|
|
||
|
|
init(compilerName) {
|
||
|
|
this.name = compilerName
|
||
|
|
}
|
||
|
|
|
||
|
|
compile(code) {
|
||
|
|
return "Compiled by " + this.name + ": " + code
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
meta = new MetaCompiler()
|
||
|
|
meta.init("Nyash-in-Rust")
|
||
|
|
result = meta.compile("Everything is Box!")
|
||
|
|
print(result)
|
||
|
|
print("🚀 Meta-compilation successful!")
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(inline_self_hosting) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" 🎆 Inline self-hosting successful! 🎆"),
|
||
|
|
Err(e) => println!(" ❌ Inline self-hosting error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Inline self-hosting parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test Interface Box Implementation
|
||
|
|
println!("\n 🎆 INTERFACE BOX IMPLEMENTATION TEST 🎆:");
|
||
|
|
println!(" Testing interface box syntax support...");
|
||
|
|
|
||
|
|
match std::fs::read_to_string("test_interface.nyash") {
|
||
|
|
Ok(interface_code) => {
|
||
|
|
match NyashParser::parse_from_string(&interface_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing interface box test...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => {
|
||
|
|
println!(" 🚀 INTERFACE BOX STEP 1 SUCCESS! 🚀");
|
||
|
|
println!(" ✅ interface box syntax parsing works!");
|
||
|
|
println!(" ✅ Interface registration successful!");
|
||
|
|
println!(" Next: extends and implements syntax...");
|
||
|
|
},
|
||
|
|
Err(e) => println!(" ❌ Interface runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Interface parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(_) => {
|
||
|
|
println!(" ⚠️ test_interface.nyash not found, using inline test:");
|
||
|
|
|
||
|
|
let inline_interface_test = r#"
|
||
|
|
print("🎆 Inline Interface Test 🎆")
|
||
|
|
|
||
|
|
interface box Testable {
|
||
|
|
test()
|
||
|
|
verify(result)
|
||
|
|
}
|
||
|
|
|
||
|
|
print("Interface box declared successfully!")
|
||
|
|
print("✅ Step 1: interface box syntax - WORKING!")
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(inline_interface_test) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" 🎆 Interface syntax working! 🎆"),
|
||
|
|
Err(e) => println!(" ❌ Interface test error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Interface test parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test Inheritance Implementation
|
||
|
|
println!("\n 🚀 INHERITANCE IMPLEMENTATION TEST 🚀:");
|
||
|
|
println!(" Testing extends & implements syntax...");
|
||
|
|
|
||
|
|
match std::fs::read_to_string("test_inheritance.nyash") {
|
||
|
|
Ok(inheritance_code) => {
|
||
|
|
match NyashParser::parse_from_string(&inheritance_code) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
println!(" Executing inheritance test...");
|
||
|
|
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => {
|
||
|
|
println!(" 🎆 INHERITANCE STEPS 2&3 SUCCESS! 🎆");
|
||
|
|
println!(" ✅ extends syntax working!");
|
||
|
|
println!(" ✅ implements syntax working!");
|
||
|
|
println!(" ✅ Inheritance chain resolution!");
|
||
|
|
println!(" ✅ Interface validation!");
|
||
|
|
println!(" ✅ Method overriding!");
|
||
|
|
},
|
||
|
|
Err(e) => println!(" ❌ Inheritance runtime error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Inheritance parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(_) => {
|
||
|
|
println!(" ⚠️ test_inheritance.nyash not found, using inline test:");
|
||
|
|
|
||
|
|
let inline_inheritance_test = r#"
|
||
|
|
print("🚀 Inline Inheritance Test 🚀")
|
||
|
|
|
||
|
|
interface box Speakable {
|
||
|
|
speak()
|
||
|
|
}
|
||
|
|
|
||
|
|
box Animal {
|
||
|
|
name
|
||
|
|
speak() {
|
||
|
|
return "Animal sound"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
box Dog extends Animal implements Speakable {
|
||
|
|
breed
|
||
|
|
speak() {
|
||
|
|
return "Woof!"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
dog = new Dog()
|
||
|
|
dog.name = "Buddy"
|
||
|
|
dog.breed = "Labrador"
|
||
|
|
print("Dog says: " + dog.speak())
|
||
|
|
print("✅ Inheritance working!")
|
||
|
|
"#;
|
||
|
|
|
||
|
|
match NyashParser::parse_from_string(inline_inheritance_test) {
|
||
|
|
Ok(ast) => {
|
||
|
|
let mut interpreter = NyashInterpreter::new();
|
||
|
|
match interpreter.execute(ast) {
|
||
|
|
Ok(_) => println!(" 🚀 Inheritance test successful! 🚀"),
|
||
|
|
Err(e) => println!(" ❌ Inheritance test error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Err(e) => println!(" ❌ Inheritance test parse error: {}", e),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_main_functionality() {
|
||
|
|
// This test ensures main() doesn't panic
|
||
|
|
// In a real implementation, we'd have more comprehensive tests
|
||
|
|
let string_box = StringBox::new("test");
|
||
|
|
assert_eq!(string_box.type_name(), "StringBox");
|
||
|
|
assert_eq!(string_box.to_string_box().value, "test");
|
||
|
|
}
|
||
|
|
}
|