feat: add typed ast

[r4ai]

No description provided.

[Copilot]

Pull Request Overview

This PR implements typed AST support by integrating a type checker into the compilation pipeline that produces a typed AST with all type information resolved. The typed AST is then used by the code generator to produce more accurate WebAssembly code.

Key changes include:

• Enhanced AST with generic type parameters to support both untyped and typed variants
• Updated type checker to return typed AST nodes instead of just type information
• Modified code generator to accept and work with typed AST
• Added support for boolean literals and improved type handling

Reviewed Changes

Copilot reviewed 21 out of 22 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
src/main.rs	Updated main compilation flow to use typed AST from type checker
crates/type-checker/src/checker.rs	Major refactor to return typed AST nodes alongside type checking
crates/type-checker/src/env.rs	Simplified by removing custom Type enum in favor of AST TypeKind
crates/type-checker/src/lib.rs	Removed Type re-export as it's now in AST
crates/type-checker/src/error.rs	Added MissingTypeAnnotation error variant
crates/code-generator/src/lib.rs	Updated to accept typed AST and handle boolean literals
crates/ast/src/lib.rs	Made AST generic over type parameter to support typed/untyped variants
crates/parser/src/lib.rs	Added boolean literal parsing support
samples/if.ao	Updated sample to use proper boolean types

[Copilot]

This function creates an empty typed block and includes a TODO comment about being a 'minimal implementation for the GREEN phase'. This appears to be temporary scaffolding code that should be properly implemented or removed.

Suggested change

	/// Convert an untyped block to a typed block by providing default types
	/// This is a minimal implementation for the GREEN phase
	fn convert_block_to_typed<'a>(block: &ast::Block<'a>) -> ast::Block<'a, Type> {
	// For minimal GREEN implementation, create an empty typed block
	// This preserves the structure but with empty statements for now
	// A full implementation would need to properly convert all nested expressions
	ast::Block {
	statements: ast::Statements {
	statements: vec![], // Simplified: empty statements to avoid type conversion complexity
	location: block.statements.location.clone(),
	},
	location: block.location.clone(),
	}
	/// Convert an untyped block to a typed block by type-checking its statements
	fn convert_block_to_typed<'a>(&self, block: &ast::Block<'a>) -> Result<ast::Block<'a, Type>, TypeCheckError> {
	let mut typed_statements = Vec::new();
	for statement in &block.statements.statements {
	let typed_statement = self.type_check_statement(statement)?;
	typed_statements.push(typed_statement);
	}
	Ok(ast::Block {
	statements: ast::Statements {
	statements: typed_statements,
	location: block.statements.location.clone(),
	},
	location: block.location.clone(),
	})

[Copilot]

Using unsafe transmute to convert between AST types is dangerous and can lead to memory safety issues. This hack should be replaced with proper type conversion logic.

Suggested change

	// This is a hack for now - a proper implementation would do deep type conversion
	let typed_block = unsafe {
	std::mem::transmute::<ast::Block<'a>, ast::Block<'a, Type>>(block.clone())
	};
	// Perform a proper type conversion for the block
	let typed_block = Self::convert_block_to_typed(block)?;

[Copilot]

Memory transmutation between different generic type parameters can cause undefined behavior if the memory layouts differ. This is a serious safety violation.

Suggested change

	let typed_block = unsafe {
	std::mem::transmute::<ast::Block<'a>, ast::Block<'a, Type>>(block.clone())
	};
	let typed_block = Self::convert_block(block.clone());

[Copilot]

Creating an empty statements vector discards all the actual statements from the original block, which will cause the typed AST to lose important code structure and functionality.

Suggested change

	statements: vec![], // Simplified: empty statements to avoid type conversion complexity
	statements: block.statements.statements.iter().map(|stmt| {
	// Placeholder: Convert each statement to a typed statement
	// A full implementation would involve detailed type conversion logic
	ast::Statement {
	kind: stmt.kind.clone(), // Clone the kind as a placeholder
	location: stmt.location.clone(),
	}
	}).collect(),

[Copilot]

Using unwrap() with a comment claiming validation ensures safety is risky. Consider using expect() with a descriptive message or proper error handling.

Suggested change

	parameter_type: param.parameter_type.clone().unwrap(), // We know this exists from validation
	parameter_type: param.parameter_type.clone().expect("Expected parameter type to be present after validation"), // Validation should ensure this

[Copilot]

Using unwrap() with a comment claiming validation ensures safety is risky. Consider using expect() with a descriptive message or proper error handling.

Suggested change

	return_type: func_def.return_type.clone().unwrap(), // We know this exists from validation
	return_type: func_def.return_type.clone().expect("Return type must exist due to prior validation"), // We know this exists from validation