feat: implement trait and impl parsing infrastructure

- Added trait_def() and impl_block() builder methods to TypedASTBuilder
- Added create_trait() and create_impl_block() to AstHostFunctions
- Implemented trait and impl_block handlers in ZynPEG define_node
- Successfully parsing trait definitions from prelude.zynml

Traits now parse correctly (Display, Add, Sub, Mul, etc).
Impl blocks need grammar fixes for method parsing.

Note: Current impl uses placeholder types - needs full type resolution
to support constraint solving, generic resolution, and lifetime analysis.

Author: darmie

crates/typed_ast/src/typed_builder.rs

@@ -997,6 +997,89 @@ impl TypedASTBuilder {
         )
     }
 
+    /// Build trait declaration
+    ///
+    /// # Arguments
+    /// * `name` - The trait name (e.g., "Display", "Add")
+    /// * `type_params` - Type parameters for generic traits (e.g., <Rhs> in Add<Rhs>)
+    /// * `methods` - Trait method signatures
+    /// * `associated_types` - Associated types (e.g., type Output)
+    /// * `span` - Source span for error reporting
+    ///
+    /// # Example
+    /// ```ignore
+    /// // trait Display { fn to_string(self) -> String }
+    /// builder.trait_def("Display", vec![], methods, vec![], span)
+    /// ```
+    pub fn trait_def(
+        &mut self,
+        name: &str,
+        type_params: Vec<TypedTypeParam>,
+        methods: Vec<TypedMethodSignature>,
+        associated_types: Vec<TypedAssociatedType>,
+        span: Span,
+    ) -> TypedNode<TypedDeclaration> {
+        use crate::typed_ast::TypedInterface;
+
+        let trait_name = self.intern(name);
+
+        typed_node(
+            TypedDeclaration::Interface(TypedInterface {
+                name: trait_name,
+                type_params,
+                extends: vec![],
+                methods,
+                associated_types,
+                visibility: Visibility::Public,
+                span,
+            }),
+            Type::Never, // Traits don't have a value type
+            span,
+        )
+    }
+
+    /// Build trait implementation block
+    ///
+    /// # Arguments
+    /// * `trait_name` - The trait being implemented (e.g., "Add")
+    /// * `trait_type_args` - Type arguments for the trait (e.g., <Tensor> in Add<Tensor>)
+    /// * `for_type` - The type implementing the trait (e.g., Tensor)
+    /// * `methods` - Method implementations
+    /// * `associated_types` - Associated type definitions
+    /// * `span` - Source span for error reporting
+    ///
+    /// # Example
+    /// ```ignore
+    /// // impl Add<Tensor> for Tensor { ... }
+    /// builder.impl_block("Add", vec![tensor_type], tensor_type, methods, assoc_types, span)
+    /// ```
+    pub fn impl_block(
+        &mut self,
+        trait_name: &str,
+        trait_type_args: Vec<Type>,
+        for_type: Type,
+        methods: Vec<TypedMethod>,
+        associated_types: Vec<TypedImplAssociatedType>,
+        span: Span,
+    ) -> TypedNode<TypedDeclaration> {
+        use crate::typed_ast::TypedTraitImpl;
+
+        let trait_name_interned = self.intern(trait_name);
+
+        typed_node(
+            TypedDeclaration::Impl(TypedTraitImpl {
+                trait_name: trait_name_interned,
+                trait_type_args,
+                for_type: for_type.clone(),
+                methods,
+                associated_types,
+                span,
+            }),
+            Type::Never, // Impls don't have a value type
+            span,
+        )
+    }
+
     // ====== COROUTINE AND ASYNC BUILDERS ======
 
     /// Build coroutine statement

crates/zyn_peg/src/runtime.rs

@@ -274,6 +274,17 @@ pub trait AstHostFunctions {
     /// Create an import declaration
     fn create_import(&mut self, module_name: &str) -> NodeHandle;
 
+    /// Create a trait declaration
+    fn create_trait(&mut self, name: &str, methods: Vec<NodeHandle>) -> NodeHandle;
+
+    /// Create a trait implementation block
+    fn create_impl_block(
+        &mut self,
+        trait_name: &str,
+        for_type_name: &str,
+        methods: Vec<NodeHandle>,
+    ) -> NodeHandle;
+
     /// Create a function parameter
     fn create_param(&mut self, name: &str, ty: NodeHandle) -> NodeHandle;
 
@@ -1429,6 +1440,54 @@ impl AstHostFunctions for TypedAstBuilder {
         self.store_decl(import_decl)
     }
 
+    fn create_trait(&mut self, name: &str, methods: Vec<NodeHandle>) -> NodeHandle {
+        let span = self.default_span();
+
+        // For now, create a simple trait with no type params or associated types
+        // Methods will be empty vec - full implementation needs method signature handling
+        let trait_decl = self.inner.trait_def(
+            name,
+            vec![], // type_params
+            vec![], // methods (TODO: convert handles to TypedMethodSignature)
+            vec![], // associated_types
+            span,
+        );
+
+        self.store_decl(trait_decl)
+    }
+
+    fn create_impl_block(
+        &mut self,
+        trait_name: &str,
+        for_type_name: &str,
+        methods: Vec<NodeHandle>,
+    ) -> NodeHandle {
+        let span = self.default_span();
+
+        // TODO: Properly resolve the type by name from type registry
+        // For now, use a placeholder type ID
+        let for_type = Type::Named {
+            id: zyntax_typed_ast::TypeId::new(0),
+            type_args: vec![],
+            const_args: vec![],
+            variance: vec![],
+            nullability: zyntax_typed_ast::type_registry::NullabilityKind::NonNull,
+        };
+
+        // For now, create impl with empty methods
+        // Full implementation needs method body handling
+        let impl_decl = self.inner.impl_block(
+            trait_name,
+            vec![], // trait_type_args (TODO: handle generic trait args)
+            for_type,
+            vec![], // methods (TODO: convert handles to TypedMethod)
+            vec![], // associated_types
+            span,
+        );
+
+        self.store_decl(impl_decl)
+    }
+
     fn create_param(&mut self, name: &str, ty: NodeHandle) -> NodeHandle {
         // Store parameter name and type for later use in create_function
         let handle = self.alloc_handle();
@@ -5020,6 +5079,39 @@ impl<'a, H: AstHostFunctions> CommandInterpreter<'a, H> {
                 Ok(RuntimeValue::Node(handle))
             }
 
+            "trait" => {
+                // Trait declaration (e.g., "trait Display { ... }")
+                let name = match args.get("name") {
+                    Some(RuntimeValue::String(s)) => s.clone(),
+                    _ => return Err(crate::error::ZynPegError::CodeGenError("trait: missing name".into())),
+                };
+
+                // TODO: Handle type_params and items (methods/associated types)
+                let methods = vec![];
+
+                let handle = self.host.create_trait(&name, methods);
+                Ok(RuntimeValue::Node(handle))
+            }
+
+            "impl_block" => {
+                // Trait implementation (e.g., "impl Add<Tensor> for Tensor { ... }")
+                let trait_name = match args.get("trait_name") {
+                    Some(RuntimeValue::String(s)) => s.clone(),
+                    _ => return Err(crate::error::ZynPegError::CodeGenError("impl_block: missing trait_name".into())),
+                };
+
+                let for_type = match args.get("type_name") {
+                    Some(RuntimeValue::String(s)) => s.clone(),
+                    _ => return Err(crate::error::ZynPegError::CodeGenError("impl_block: missing type_name".into())),
+                };
+
+                // TODO: Handle trait_args and items (methods/associated types)
+                let methods = vec![];
+
+                let handle = self.host.create_impl_block(&trait_name, &for_type, methods);
+                Ok(RuntimeValue::Node(handle))
+            }
+
             _ => {
                 Err(crate::error::ZynPegError::CodeGenError(format!("Unknown node type: {}", node_type)))
             }