Add built-in trait bounds (Copy, Eq, Send) on generic type parameters with monomorphization-time checking, spec updates, integration tests, and LSP diagnostics for bound violations.

Author: Cod-e-Codes

.cursor/skills/writing-ion-code/SKILL.md

@@ -176,7 +176,7 @@ For programs under `tests/`, follow the `ion-integration-tests` skill (`test_exp
 These are **not** in Ion today. Check ION_SPEC.md section 10.3 before using anything similar:
 
 - Capturing closures (fn literals that reference outer variables), or `impl` blocks in user code
-- Traits, trait bounds, or `where` clauses on generics
+- User-defined traits, `where` clauses, or bounds other than built-in `Copy`, `Eq`, and `Send`
 - Returning `&T` / `&mut T` or `Option<&T>` from functions
 - References in struct fields, enum payloads, or channels
 - Shared mutable state across threads (only channels + move)

ION_SPEC.md

@@ -288,7 +288,8 @@ fn_decl          = "fn" , identifier , type_params? , "(" , params? , ")" ,
                    return_type? , block ;
 
 type_params      = "<" , type_param , { "," , type_param } , ">" ;
-type_param       = identifier ;  (* no trait bounds *)
+type_param       = identifier , [ ":" , trait_bound , { "+" , trait_bound } ] ;
+trait_bound      = identifier ;  (* built-in: Copy, Eq, Send *)
 
 params           = param , { "," , param } ;
 param            = identifier , ":" , type_expr ;
@@ -651,7 +652,8 @@ Ion supports a **local, Hindley–Milner-inspired inference**:
 The inference engine is intentionally limited:
 
 - No higher-rank polymorphism.
-- No complex trait constraints; only simple, **structural** `Send` constraints. For a generic type `Wrapper<T>`, each monomorphized instantiation `Wrapper<U>` is `Send` if and only if all of its fields (with `T` replaced by `U`) are `Send`.
+- Generic type parameters may declare optional **trait bounds** (`Copy`, `Eq`, `Send`). Bounds are checked at monomorphization: each concrete instantiation must satisfy every bound on the corresponding parameter. There are no user-defined traits; bounds name structural capabilities checked by the compiler (see Section 4.8).
+- Structural `Send` still applies per instantiation even without an explicit bound: for a generic type `Wrapper<T>`, each monomorphized `Wrapper<U>` is `Send` if and only if all of its fields (with `T` replaced by `U`) are `Send`.
 
 #### 4.5 Type Casting and Array Assignment
 
@@ -677,6 +679,25 @@ The inference engine is intentionally limited:
 - **Match guards**: `pattern if expr => { ... }` where `expr` must be `bool`.
 - **Struct-style enum variants**: `enum E { Ok { value: int }; }` with matching literals and patterns.
 
+#### 4.8 Trait Bounds on Generics
+
+Generic functions, structs, enums, and type aliases may declare bounds on type parameters:
+
+```ion
+fn send_value<T: Send>(value: T) { ... }
+struct Pair<T: Copy + Eq> { first: T; second: T; }
+```
+
+Syntax: `identifier : Bound [ + Bound ... ]` after each type parameter name. Bounds are **built-in identifiers** only; there is no `trait` declaration syntax.
+
+| Bound | Meaning (structural) |
+|-------|----------------------|
+| `Copy` | Type is copied rather than moved at the ownership level (primitives, references, function pointers). |
+| `Eq` | Type supports `==` and `!=` with correct semantics (primitives, `String`, references, arrays and tuples of `Eq` types, structs and enums whose fields or payloads are all `Eq`). |
+| `Send` | Type may cross thread boundaries (Section 7.3). |
+
+At each monomorphization site (generic call, struct or enum construction, type-alias substitution), the compiler substitutes concrete types for parameters and rejects any instantiation where a concrete type does not satisfy a declared bound. Unknown bound names are rejected at the declaration site.
+
 ### 5. Ownership and Borrowing
 
 #### 5.1 Ownership
@@ -715,7 +736,7 @@ fn main() {
 
 By default, Ion types are **move-only**. For a small subset of primitive types (e.g., `int`, `bool`, pointers), the implementation may treat moves as cheap copies, but the semantic model is still “move”.
 
-Ion does not expose a `Copy` marker to user code; whether a move is implemented as a copy is an implementation detail.
+Whether a move is implemented as a copy is an implementation detail. The `Copy` bound on generic parameters (Section 4.8) names types that are copied rather than moved at the ownership level.
 
 After an `if` statement, ownership is merged from branches that can reach the following code. Branches that always `return`, `break`, or `continue` are omitted from the merge. If two fall-through paths disagree on whether a binding is still valid, the compiler reports an error.
 
@@ -1253,7 +1274,7 @@ and [docs/ABI.md](docs/ABI.md). Features listed below are either intentionally
 constrained in the beta subset or unstable until a later release documents a
 stronger contract.
 
-- No trait bounds on generics
+- Trait bounds are limited to built-in `Copy`, `Eq`, and `Send` (no user-defined traits)
 - String `for...in` iterates bytes (`u8`), not Unicode code points or graphemes
 - `if`/`else` merge: ownership after an `if` is merged from branches that can fall through to the following code. A move in a branch that always `return`s, `break`s, or `continue`s does not block use after the `if`. If two fall-through paths disagree (one moved, one valid), it is still an error.
 - `while`/`for` loops: a non-copy variable moved anywhere in the loop body is an error (repeated iteration would need the binding again); copy types and borrows are unchanged. For read-only scans over an owned `Vec<T>`, prefer `Vec::get_ref` (Section 8.2) or index/handle helpers; `Vec::get` move-out still requires consume-once or put-back per iteration.

docs/BETA.md

@@ -35,7 +35,7 @@ The following features may change shape before 1.0:
 
 - tuples beyond flat two-field values;
 - capture-free function literals and function-pointer coercions;
-- generic ergonomics without trait bounds;
+- generic ergonomics with optional built-in trait bounds (`Copy`, `Eq`, `Send`);
 - byte-oriented string iteration;
 - conservative move analysis in `while` and `for` loops;
 - generated C layout details not covered by `docs/ABI.md`.

src/ast/mod.rs

@@ -36,12 +36,52 @@ pub struct ExternFnDecl {
     pub span: Span,
 }
 
+#[derive(Debug, Clone)]
+pub struct TypeParam {
+    pub name: String,
+    pub bounds: Vec<String>,
+}
+
+impl TypeParam {
+    pub fn simple(name: &str) -> Self {
+        TypeParam {
+            name: name.to_string(),
+            bounds: Vec::new(),
+        }
+    }
+
+    pub fn names(params: &[TypeParam]) -> Vec<String> {
+        params.iter().map(|p| p.name.clone()).collect()
+    }
+
+    pub fn format_list(params: &[TypeParam]) -> String {
+        if params.is_empty() {
+            String::new()
+        } else {
+            format!(
+                "<{}>",
+                params
+                    .iter()
+                    .map(|p| {
+                        if p.bounds.is_empty() {
+                            p.name.clone()
+                        } else {
+                            format!("{}: {}", p.name, p.bounds.join(" + "))
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct FnDecl {
     pub doc: Option<String>,
     pub pub_: bool,
     pub name: String,
-    pub generics: Vec<String>,
+    pub generics: Vec<TypeParam>,
     pub params: Vec<Param>,
     pub return_type: Option<Type>,
     pub body: Block,
@@ -53,7 +93,7 @@ pub struct StructDecl {
     pub doc: Option<String>,
     pub pub_: bool,
     pub name: String,
-    pub generics: Vec<String>,
+    pub generics: Vec<TypeParam>,
     pub fields: Vec<StructField>,
     pub span: Span,
 }
@@ -63,7 +103,7 @@ pub struct EnumDecl {
     pub doc: Option<String>,
     pub pub_: bool,
     pub name: String,
-    pub generics: Vec<String>,
+    pub generics: Vec<TypeParam>,
     pub variants: Vec<EnumVariant>,
     pub span: Span,
 }
@@ -73,7 +113,7 @@ pub struct TypeAliasDecl {
     pub doc: Option<String>,
     pub pub_: bool,
     pub name: String,
-    pub generics: Vec<String>,
+    pub generics: Vec<TypeParam>,
     pub target: Type,
     pub span: Span,
 }

src/cgen/mod.rs

@@ -9,7 +9,8 @@ use self::types::{
 };
 
 use crate::ast::{
-    BinOp, EnumDecl, EnumVariant, ExternBlock, Program, Span, StructDecl, Type, TypeAliasDecl, UnOp,
+    BinOp, EnumDecl, EnumVariant, ExternBlock, Program, Span, StructDecl, Type, TypeAliasDecl,
+    TypeParam, UnOp,
 };
 use crate::ir::*;
 use crate::types_util::{is_ref_to_vec, ref_to_vec_elem};
@@ -390,7 +391,7 @@ impl Codegen {
                 doc: None,
                 pub_: false,
                 name: "Option".to_string(),
-                generics: vec!["T".to_string()],
+                generics: vec![TypeParam::simple("T")],
                 variants: vec![
                     EnumVariant {
                         doc: None,
@@ -480,7 +481,7 @@ impl Codegen {
                         doc: None,
                         pub_: false,
                         name: "Option".to_string(),
-                        generics: vec!["T".to_string()],
+                        generics: vec![TypeParam::simple("T")],
                         variants: vec![
                             EnumVariant {
                                 doc: None,
@@ -727,7 +728,7 @@ impl Codegen {
                     doc: None,
                     pub_: false,
                     name: "Option".to_string(),
-                    generics: vec!["T".to_string()],
+                    generics: vec![TypeParam::simple("T")],
                     variants: vec![
                         EnumVariant {
                             doc: None,
@@ -805,7 +806,7 @@ impl Codegen {
                         doc: None,
                         pub_: false,
                         name: "Option".to_string(),
-                        generics: vec!["T".to_string()],
+                        generics: vec![TypeParam::simple("T")],
                         variants: vec![
                             EnumVariant {
                                 doc: None,
@@ -1037,9 +1038,9 @@ impl Codegen {
         };
         let decl = self.struct_map.get(base_name)?;
         let mut substitutions = HashMap::new();
-        for (i, gen_name) in decl.generics.iter().enumerate() {
+        for (i, gen_param) in decl.generics.iter().enumerate() {
             if i < params.len() {
-                substitutions.insert(gen_name.clone(), params[i].clone());
+                substitutions.insert(gen_param.name.clone(), params[i].clone());
             }
         }
         Some((decl, substitutions))
@@ -1057,9 +1058,9 @@ impl Codegen {
         };
         let decl = self.enum_map.get(base_name)?;
         let mut substitutions = HashMap::new();
-        for (i, gen_name) in decl.generics.iter().enumerate() {
+        for (i, gen_param) in decl.generics.iter().enumerate() {
             if i < params.len() {
-                substitutions.insert(gen_name.clone(), params[i].clone());
+                substitutions.insert(gen_param.name.clone(), params[i].clone());
             }
         }
         Some((decl, substitutions))
@@ -3327,7 +3328,7 @@ impl Codegen {
             .generics
             .iter()
             .zip(type_params.iter())
-            .map(|(name, ty)| (name.clone(), ty))
+            .map(|(param, ty)| (param.name.clone(), ty))
             .collect();
 
         self.write_indent();
@@ -3952,7 +3953,7 @@ impl Codegen {
                     e.generics
                         .iter()
                         .zip(type_params.iter())
-                        .map(|(name, ty)| (name.clone(), ty))
+                        .map(|(name, ty)| (name.name.clone(), ty))
                         .collect()
                 })
                 .unwrap_or_default();
@@ -5126,9 +5127,9 @@ impl Codegen {
 
         // Create substitution map: generic param name -> concrete type
         let mut substitutions: HashMap<String, &Type> = HashMap::new();
-        for (i, param_name) in decl.generics.iter().enumerate() {
+        for (i, gen_param) in decl.generics.iter().enumerate() {
             if i < params.len() {
-                substitutions.insert(param_name.clone(), &params[i]);
+                substitutions.insert(gen_param.name.clone(), &params[i]);
             }
         }
 
@@ -5161,9 +5162,9 @@ impl Codegen {
 
         // Create substitution map: generic param name -> concrete type
         let mut substitutions: HashMap<String, &Type> = HashMap::new();
-        for (i, param_name) in decl.generics.iter().enumerate() {
+        for (i, gen_param) in decl.generics.iter().enumerate() {
             if i < params.len() {
-                substitutions.insert(param_name.clone(), &params[i]);
+                substitutions.insert(gen_param.name.clone(), &params[i]);
             }
         }
 

src/cgen/types.rs

@@ -232,7 +232,7 @@ pub(crate) fn resolve_type_alias(ty: &Type, type_aliases: &HashMap<String, TypeA
                             .generics
                             .iter()
                             .zip(params.iter())
-                            .map(|(gen_name, param_ty)| (gen_name.clone(), param_ty))
+                            .map(|(tp, param_ty)| (tp.name.clone(), param_ty))
                             .collect();
                         let resolved = substitute_type_params(&alias.target, &substitutions);
                         return resolve_type_alias(&resolved, type_aliases);
@@ -251,7 +251,7 @@ pub(crate) fn resolve_type_alias(ty: &Type, type_aliases: &HashMap<String, TypeA
                         .generics
                         .iter()
                         .zip(params.iter())
-                        .map(|(gen_name, param_ty)| (gen_name.clone(), param_ty))
+                        .map(|(tp, param_ty)| (tp.name.clone(), param_ty))
                         .collect();
                     let resolved = substitute_type_params(&alias.target, &substitutions);
                     return resolve_type_alias(&resolved, type_aliases);

src/ir/mod.rs

@@ -464,7 +464,7 @@ impl IRBuilder {
 
         IRFunction {
             name: function.name.clone(),
-            generics: function.generics.clone(),
+            generics: TypeParam::names(&function.generics),
             params,
             return_type: function.return_type.clone(),
             blocks,

src/lsp/server.rs

@@ -400,6 +400,20 @@ fn diagnostic_from_tc_error(err: &TypeCheckError) -> (crate::ast::Span, String)
                 names.join(", ")
             ),
         ),
+        TypeCheckError::TraitBoundNotSatisfied {
+            span,
+            type_name,
+            bound,
+            context,
+        } => (
+            *span,
+            format!(
+                "Trait bound not satisfied: type '{type_name}' does not satisfy '{bound}' in {context}"
+            ),
+        ),
+        TypeCheckError::UnknownTraitBound { span, bound } => {
+            (*span, format!("Unknown trait bound: '{bound}'"))
+        }
         TypeCheckError::Message(msg) => (crate::ast::Span::default(), msg.clone()),
     }
 }

src/parser/mod.rs

@@ -807,24 +807,13 @@ impl Parser {
         }
     }
 
-    fn parse_generic_params(&mut self) -> Result<Vec<String>, ParseError> {
+    fn parse_generic_params(&mut self) -> Result<Vec<TypeParam>, ParseError> {
         if !self.is_at_end() && matches!(self.peek().kind, TokenKind::Less) {
             self.advance(); // consume <
             let mut params = Vec::new();
 
             loop {
-                let name_idx = self.current;
-                let name = if let TokenKind::Ident(ref ident_name) = self.tokens[name_idx].kind {
-                    ident_name.clone()
-                } else {
-                    return Err(ParseError::UnexpectedToken {
-                        expected: "type parameter name".to_string(),
-                        got: self.tokens[name_idx].kind.clone(),
-                        span: Span::from_token(&self.tokens[name_idx]),
-                    });
-                };
-                self.current += 1; // consume identifier
-                params.push(name);
+                params.push(self.parse_type_param()?);
 
                 if !self.is_at_end() && matches!(self.peek().kind, TokenKind::Comma) {
                     self.advance(); // consume ,
@@ -840,6 +829,47 @@ impl Parser {
         }
     }
 
+    fn parse_type_param(&mut self) -> Result<TypeParam, ParseError> {
+        let name_idx = self.current;
+        let name = if let TokenKind::Ident(ref ident_name) = self.tokens[name_idx].kind {
+            ident_name.clone()
+        } else {
+            return Err(ParseError::UnexpectedToken {
+                expected: "type parameter name".to_string(),
+                got: self.tokens[name_idx].kind.clone(),
+                span: Span::from_token(&self.tokens[name_idx]),
+            });
+        };
+        self.current += 1; // consume identifier
+
+        let mut bounds = Vec::new();
+        if !self.is_at_end() && matches!(self.peek().kind, TokenKind::Colon) {
+            self.advance(); // consume :
+            loop {
+                let bound_idx = self.current;
+                let bound = if let TokenKind::Ident(ref bound_name) = self.tokens[bound_idx].kind {
+                    bound_name.clone()
+                } else {
+                    return Err(ParseError::UnexpectedToken {
+                        expected: "trait bound name".to_string(),
+                        got: self.tokens[bound_idx].kind.clone(),
+                        span: Span::from_token(&self.tokens[bound_idx]),
+                    });
+                };
+                self.current += 1;
+                bounds.push(bound);
+
+                if !self.is_at_end() && matches!(self.peek().kind, TokenKind::Plus) {
+                    self.advance(); // consume +
+                } else {
+                    break;
+                }
+            }
+        }
+
+        Ok(TypeParam { name, bounds })
+    }
+
     fn parse_struct_decl(&mut self) -> Result<StructDecl, ParseError> {
         let struct_span = Span::from_token(self.expect(TokenKind::Struct)?);