artiq: Implement handling for const generic variables

A lot of refactoring was performed, specifically with relaxing
expression codegen to return Option in case where ellipsis are used
within a subexpression.

nac3artiq/demo/min_artiq.py

@@ -2,7 +2,7 @@ from inspect import getfullargspec
 from functools import wraps
 from types import SimpleNamespace
 from numpy import int32, int64
-from typing import Generic, TypeVar
+from typing import Any, Generic, TypeVar
 from math import floor, ceil
 
 import nac3artiq
@@ -10,7 +10,7 @@ from embedding_map import EmbeddingMap
 
 
 __all__ = [
-    "Kernel", "KernelInvariant", "virtual",
+    "Kernel", "KernelInvariant", "virtual", "ConstGeneric",
     "Option", "Some", "none", "UnwrapNoneError",
     "round64", "floor64", "ceil64",
     "extern", "kernel", "portable", "nac3",
@@ -67,6 +67,12 @@ def Some(v: T) -> Option[T]:
 
 none = Option(None)
 
+class _ConstGenericDummy:
+    pass
+
+def ConstGeneric(name, constraint):
+    return TypeVar(name, _ConstGenericDummy, constraint)
+
 def round64(x):
     return round(x)
 

nac3artiq/src/codegen.rs

@@ -145,7 +145,8 @@ impl<'a> ArtiqCodeGenerator<'a> {
             let end_store = self.gen_store_target(
                 ctx,
                 &end,
-                store_name.map(|name| format!("{name}.addr")).as_deref())?;
+                store_name.map(|name| format!("{name}.addr")).as_deref())?
+                .unwrap();
             ctx.builder.build_store(end_store, max);
         }
 
@@ -261,7 +262,9 @@ impl<'b> CodeGenerator for ArtiqCodeGenerator<'b> {
                                     node: ExprKind::Name { id: start, ctx: name_ctx.clone() },
                                     custom: Some(ctx.primitives.int64),
                                 };
-                                let start = self.gen_store_target(ctx, &start_expr, Some("start.addr"))?;
+                                let start = self
+                                    .gen_store_target(ctx, &start_expr, Some("start.addr"))?
+                                    .unwrap();
                                 ctx.builder.build_store(start, now);
                                 Ok(Some(start_expr)) as Result<_, String>
                             },
@@ -274,7 +277,9 @@ impl<'b> CodeGenerator for ArtiqCodeGenerator<'b> {
                             node: ExprKind::Name { id: end, ctx: name_ctx.clone() },
                             custom: Some(ctx.primitives.int64),
                         };
-                        let end = self.gen_store_target(ctx, &end_expr, Some("end.addr"))?;
+                        let end = self
+                            .gen_store_target(ctx, &end_expr, Some("end.addr"))?
+                            .unwrap();
                         ctx.builder.build_store(end, now);
                         self.end = Some(end_expr);
                         self.name_counter += 1;

nac3artiq/src/lib.rs

@@ -75,6 +75,7 @@ pub struct PrimitivePythonId {
     list: u64,
     tuple: u64,
     typevar: u64,
+    const_generic_dummy: u64,
     none: u64,
     exception: u64,
     generic_alias: (u64, u64),
@@ -877,6 +878,15 @@ impl Nac3 {
                 .extract()
                 .unwrap(),
             typevar: get_attr_id(typing_mod, "TypeVar"),
+            const_generic_dummy: id_fn
+                .call1((
+                    builtins_mod.getattr("globals")
+                        .and_then(|v| v.call0())
+                        .and_then(|v| v.get_item("_ConstGenericDummy"))
+                        .unwrap(),
+                ))
+                .and_then(|v| v.extract())
+                .unwrap(),
             int: get_attr_id(builtins_mod, "int"),
             int32: get_attr_id(numpy_mod, "int32"),
             int64: get_attr_id(numpy_mod, "int64"),

nac3artiq/src/symbol_resolver.rs

@@ -266,10 +266,12 @@ impl InnerResolver {
         Ok(Ok(ty))
     }
 
-    // handle python objects that represent types themselves
-    // primitives and class types should be themselves, use `ty_id` to check,
-    // TypeVars and GenericAlias(`A[int, bool]`) should use `ty_ty_id` to check
-    // the `bool` value returned indicates whether they are instantiated or not
+    /// handle python objects that represent types themselves
+    ///
+    /// primitives and class types should be themselves, use `ty_id` to check,
+    /// TypeVars and GenericAlias(`A[int, bool]`) should use `ty_ty_id` to check
+    ///
+    /// the `bool` value returned indicates whether they are instantiated or not
     fn get_pyty_obj_type(
         &self,
         py: Python,
@@ -345,13 +347,21 @@ impl InnerResolver {
             }
         } else if ty_ty_id == self.primitive_ids.typevar {
             let name: &str = pyty.getattr("__name__").unwrap().extract().unwrap();
-            let constraint_types = {
+            let (constraint_types, is_const_generic) = {
                 let constraints = pyty.getattr("__constraints__").unwrap();
                 let mut result: Vec<Type> = vec![];
                 let needs_defer = self.deferred_eval_store.needs_defer.load(Relaxed);
+
+                let mut is_const_generic = false;
                 for i in 0usize.. {
                     if let Ok(constr) = constraints.get_item(i) {
-                        if needs_defer {
+                        let constr_id: u64 = self.helper.id_fn.call1(py, (constr,))?.extract(py)?;
+                        if constr_id == self.primitive_ids.const_generic_dummy {
+                            is_const_generic = true;
+                            continue
+                        }
+
+                        if !is_const_generic && needs_defer {
                             result.push(unifier.get_dummy_var().0);
                         } else {
                             result.push({
@@ -375,17 +385,28 @@ impl InnerResolver {
                         break;
                     }
                 }
-                if needs_defer {
+
+                if !is_const_generic && needs_defer {
                     self.deferred_eval_store.store.write()
                         .push((result.clone(),
                                constraints.extract()?,
                                pyty.getattr("__name__")?.extract::<String>()?
                         ))
                 }
-                result
+
+                (result, is_const_generic)
             };
-            let res =
-                unifier.get_fresh_var_with_range(&constraint_types, Some(name.into()), None).0;
+
+            let res = if is_const_generic {
+                if constraint_types.len() != 1 {
+                    return Ok(Err(format!("ConstGeneric expects 1 argument, got {}", constraint_types.len())))
+                }
+
+                unifier.get_fresh_const_generic_var(constraint_types[0], Some(name.into()), None).0
+            } else {
+                unifier.get_fresh_var_with_range(&constraint_types, Some(name.into()), None).0
+            };
+
             Ok(Ok((res, true)))
         } else if ty_ty_id == self.primitive_ids.generic_alias.0
             || ty_ty_id == self.primitive_ids.generic_alias.1

nac3ast/src/location.rs

@@ -26,7 +26,7 @@ pub struct Location {
 
 impl fmt::Display for Location {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}: line {} column {}", self.file.0, self.row, self.column)
+        write!(f, "{}:{}:{}", self.file.0, self.row, self.column)
     }
 }
 

nac3core/src/codegen/expr.rs

@@ -207,12 +207,12 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
         generator: &mut dyn CodeGenerator,
         value: &Constant,
         ty: Type,
-    ) -> BasicValueEnum<'ctx> {
+    ) -> Option<BasicValueEnum<'ctx>> {
         match value {
             Constant::Bool(v) => {
                 assert!(self.unifier.unioned(ty, self.primitives.bool));
                 let ty = self.ctx.i8_type();
-                ty.const_int(if *v { 1 } else { 0 }, false).into()
+                Some(ty.const_int(if *v { 1 } else { 0 }, false).into())
             }
             Constant::Int(val) => {
                 let ty = if self.unifier.unioned(ty, self.primitives.int32)
@@ -226,28 +226,33 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                 } else {
                     unreachable!();
                 };
-                ty.const_int(*val as u64, false).into()
+                Some(ty.const_int(*val as u64, false).into())
             }
             Constant::Float(v) => {
                 assert!(self.unifier.unioned(ty, self.primitives.float));
                 let ty = self.ctx.f64_type();
-                ty.const_float(*v).into()
+                Some(ty.const_float(*v).into())
             }
             Constant::Tuple(v) => {
                 let ty = self.unifier.get_ty(ty);
                 let types =
                     if let TypeEnum::TTuple { ty } = &*ty { ty.clone() } else { unreachable!() };
                 let values = zip(types.into_iter(), v.iter())
-                    .map(|(ty, v)| self.gen_const(generator, v, ty))
+                    .map_while(|(ty, v)| self.gen_const(generator, v, ty))
                     .collect_vec();
-                let types = values.iter().map(BasicValueEnum::get_type).collect_vec();
-                let ty = self.ctx.struct_type(&types, false);
-                ty.const_named_struct(&values).into()
+
+                if values.len() == v.len() {
+                    let types = values.iter().map(BasicValueEnum::get_type).collect_vec();
+                    let ty = self.ctx.struct_type(&types, false);
+                    Some(ty.const_named_struct(&values).into())
+                } else {
+                    None
+                }
             }
             Constant::Str(v) => {
                 assert!(self.unifier.unioned(ty, self.primitives.str));
                 if let Some(v) = self.const_strings.get(v) {
-                    *v
+                    Some(*v)
                 } else {
                     let str_ptr =
                         self.builder.build_global_string_ptr(v, "const").as_pointer_value().into();
@@ -256,9 +261,22 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
                     let val =
                         ty.into_struct_type().const_named_struct(&[str_ptr, size.into()]).into();
                     self.const_strings.insert(v.to_string(), val);
-                    val
+                    Some(val)
                 }
             }
+            Constant::Ellipsis => {
+                let msg = self.gen_string(generator, "NotImplementedError");
+
+                self.raise_exn(
+                    generator,
+                    "0:NotImplementedError",
+                    msg,
+                    [None, None, None],
+                    self.current_loc,
+                );
+
+                None
+            }
             _ => unreachable!(),
         }
     }
@@ -481,7 +499,7 @@ impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
         generator: &mut dyn CodeGenerator,
         s: S,
     ) -> BasicValueEnum<'ctx> {
-        self.gen_const(generator, &nac3parser::ast::Constant::Str(s.into()), self.primitives.str)
+        self.gen_const(generator, &nac3parser::ast::Constant::Str(s.into()), self.primitives.str).unwrap()
     }
 
     pub fn raise_exn(
@@ -935,7 +953,7 @@ pub fn gen_comprehension<'ctx, 'a, G: CodeGenerator>(
     generator: &mut G,
     ctx: &mut CodeGenContext<'ctx, 'a>,
     expr: &Expr<Option<Type>>,
-) -> Result<BasicValueEnum<'ctx>, String> {
+) -> Result<Option<BasicValueEnum<'ctx>>, String> {
     if let ExprKind::ListComp { elt, generators } = &expr.node {
         let current = ctx.builder.get_insert_block().unwrap().get_parent().unwrap();
 
@@ -949,9 +967,16 @@ pub fn gen_comprehension<'ctx, 'a, G: CodeGenerator>(
         ctx.builder.position_at_end(init_bb);
 
         let Comprehension { target, iter, ifs, .. } = &generators[0];
-        let iter_val = generator.gen_expr(ctx, iter)?
-            .unwrap()
-            .to_basic_value_enum(ctx, generator, iter.custom.unwrap())?;
+        let iter_val = if let Some(v) = generator.gen_expr(ctx, iter)? {
+            v.to_basic_value_enum(ctx, generator, iter.custom.unwrap())?
+        } else {
+            for bb in [test_bb, body_bb, cont_bb] {
+                ctx.builder.position_at_end(bb);
+                ctx.builder.build_unreachable();
+            }
+
+            return Ok(None)
+        };
         let int32 = ctx.ctx.i32_type();
         let size_t = generator.get_size_type(ctx.ctx);
         let zero_size_t = size_t.const_zero();
@@ -994,7 +1019,7 @@ pub fn gen_comprehension<'ctx, 'a, G: CodeGenerator>(
             list_content = ctx.build_gep_and_load(list, &[zero_size_t, zero_32], Some("listcomp.data.addr"))
                 .into_pointer_value();
 
-            let i = generator.gen_store_target(ctx, target, Some("i.addr"))?;
+            let i = generator.gen_store_target(ctx, target, Some("i.addr"))?.unwrap();
             ctx.builder.build_store(i, ctx.builder.build_int_sub(start, step, "start_init"));
 
             ctx.builder.build_conditional_branch(
@@ -1049,12 +1074,25 @@ pub fn gen_comprehension<'ctx, 'a, G: CodeGenerator>(
             generator.gen_assign(ctx, target, val.into())?;
         }
 
+        // Emits the content of `cont_bb`
+        let emit_cont_bb = |ctx: &CodeGenContext| {
+            ctx.builder.position_at_end(cont_bb);
+            let len_ptr = unsafe {
+                ctx.builder.build_gep(list, &[zero_size_t, int32.const_int(1, false)], "length")
+            };
+            ctx.builder.build_store(len_ptr, ctx.builder.build_load(index, "index"));
+        };
+
         for cond in ifs.iter() {
-            let result = generator
-                .gen_expr(ctx, cond)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, cond.custom.unwrap())?
-                .into_int_value();
+            let result = if let Some(v) = generator.gen_expr(ctx, cond)? {
+                v.to_basic_value_enum(ctx, generator, cond.custom.unwrap())?.into_int_value()
+            } else {
+                // Bail if the predicate is an ellipsis - Emit cont_bb contents in case the
+                // no element matches the predicate
+                emit_cont_bb(ctx);
+
+                return Ok(None)
+            };
             let result = generator.bool_to_i1(ctx, result);
             let succ = ctx.ctx.append_basic_block(current, "then");
             ctx.builder.build_conditional_branch(result, succ, test_bb);
@@ -1062,7 +1100,12 @@ pub fn gen_comprehension<'ctx, 'a, G: CodeGenerator>(
             ctx.builder.position_at_end(succ);
         }
 
-        let elem = generator.gen_expr(ctx, elt)?.unwrap();
+        let Some(elem) = generator.gen_expr(ctx, elt)? else {
+            // Similarly, bail if the generator expression is an ellipsis, but keep cont_bb contents
+            emit_cont_bb(ctx);
+
+            return Ok(None)
+        };
         let i = ctx.builder.build_load(index, "i").into_int_value();
         let elem_ptr = unsafe { ctx.builder.build_gep(list_content, &[i], "elem_ptr") };
         let val = elem.to_basic_value_enum(ctx, generator, elt.custom.unwrap())?;
@@ -1071,13 +1114,9 @@ pub fn gen_comprehension<'ctx, 'a, G: CodeGenerator>(
             .build_store(index, ctx.builder.build_int_add(i, size_t.const_int(1, false), "inc"));
         ctx.builder.build_unconditional_branch(test_bb);
 
-        ctx.builder.position_at_end(cont_bb);
-        let len_ptr = unsafe {
-            ctx.builder.build_gep(list, &[zero_size_t, int32.const_int(1, false)], "length")
-        };
-        ctx.builder.build_store(len_ptr, ctx.builder.build_load(index, "index"));
+        emit_cont_bb(ctx);
 
-        Ok(list.into())
+        Ok(Some(list.into()))
     } else {
         unreachable!()
     }
@@ -1101,14 +1140,16 @@ pub fn gen_binop_expr<'ctx, 'a, G: CodeGenerator>(
 ) -> Result<Option<ValueEnum<'ctx>>, String> {
     let ty1 = ctx.unifier.get_representative(left.custom.unwrap());
     let ty2 = ctx.unifier.get_representative(right.custom.unwrap());
-    let left_val = generator
-        .gen_expr(ctx, left)?
-        .unwrap()
-        .to_basic_value_enum(ctx, generator, left.custom.unwrap())?;
-    let right_val = generator
-        .gen_expr(ctx, right)?
-        .unwrap()
-        .to_basic_value_enum(ctx, generator, right.custom.unwrap())?;
+    let left_val = if let Some(v) = generator.gen_expr(ctx, left)? {
+        v.to_basic_value_enum(ctx, generator, left.custom.unwrap())?
+    } else {
+        return Ok(None)
+    };
+    let right_val = if let Some(v) = generator.gen_expr(ctx, right)? {
+        v.to_basic_value_enum(ctx, generator, right.custom.unwrap())?
+    } else {
+        return Ok(None)
+    };
 
     // we can directly compare the types, because we've got their representatives
     // which would be unchanged until further unification, which we would never do
@@ -1211,7 +1252,10 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
     Ok(Some(match &expr.node {
         ExprKind::Constant { value, .. } => {
             let ty = expr.custom.unwrap();
-            ctx.gen_const(generator, value, ty).into()
+            let Some(const_val) = ctx.gen_const(generator, value, ty) else {
+                return Ok(None)
+            };
+            const_val.into()
         }
         ExprKind::Name { id, .. } if id == &"none".into() => {
             match (
@@ -1242,15 +1286,17 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
             // we should use memcpy for that instead of generating thousands of stores
             let elements = elts
                 .iter()
-                .map(|x| {
-                    generator
-                        .gen_expr(ctx, x)
-                        .map_or_else(
-                            Err,
-                            |v| v.unwrap().to_basic_value_enum(ctx, generator, x.custom.unwrap())
-                        )
-                })
+                .map(|x| generator.gen_expr(ctx, x))
+                .take_while(|v| !matches!(v, Ok(None)))
                 .collect::<Result<Vec<_>, _>>()?;
+            let elements = elements.into_iter().zip(elts)
+                .map(|(v, x)| v.unwrap().to_basic_value_enum(ctx, generator, x.custom.unwrap()))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            if elements.len() < elts.len() {
+                return Ok(None)
+            }
+
             let ty = if elements.is_empty() {
                 if let TypeEnum::TList { ty } = &*ctx.unifier.get_ty(expr.custom.unwrap()) {
                     ctx.get_llvm_type(generator, *ty)
@@ -1277,14 +1323,19 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
             arr_str_ptr.into()
         }
         ExprKind::Tuple { elts, .. } => {
-            let element_val = elts
+            let elements_val = elts
                 .iter()
-                .map(|x| {
-                    generator
-                        .gen_expr(ctx, x)
-                        .map_or_else(Err, |v| v.unwrap().to_basic_value_enum(ctx, generator, x.custom.unwrap()))
-                })
+                .map(|x| generator.gen_expr(ctx, x))
+                .take_while(|v| !matches!(v, Ok(None)))
                 .collect::<Result<Vec<_>, _>>()?;
+            let element_val = elements_val.into_iter().zip(elts)
+                .map(|(v, x)| v.unwrap().to_basic_value_enum(ctx, generator, x.custom.unwrap()))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            if element_val.len() < elts.len() {
+                return Ok(None)
+            }
+
             let element_ty = element_val.iter().map(BasicValueEnum::get_type).collect_vec();
             let tuple_ty = ctx.ctx.struct_type(&element_ty, false);
             let tuple_ptr = ctx.builder.build_alloca(tuple_ty, "tuple");
@@ -1302,8 +1353,8 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
         }
         ExprKind::Attribute { value, attr, .. } => {
             // note that we would handle class methods directly in calls
-            match generator.gen_expr(ctx, value)?.unwrap() {
-                ValueEnum::Static(v) => v.get_field(*attr, ctx).map_or_else(|| {
+            match generator.gen_expr(ctx, value)? {
+                Some(ValueEnum::Static(v)) => v.get_field(*attr, ctx).map_or_else(|| {
                     let v = v.to_basic_value_enum(ctx, generator, value.custom.unwrap())?;
                     let index = ctx.get_attr_index(value.custom.unwrap(), *attr);
                     Ok(ValueEnum::Dynamic(ctx.build_gep_and_load(
@@ -1312,7 +1363,7 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                         None,
                     ))) as Result<_, String>
                 }, Ok)?,
-                ValueEnum::Dynamic(v) => {
+                Some(ValueEnum::Dynamic(v)) => {
                     let index = ctx.get_attr_index(value.custom.unwrap(), *attr);
                     ValueEnum::Dynamic(ctx.build_gep_and_load(
                         v.into_pointer_value(),
@@ -1320,15 +1371,16 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                         None,
                     ))
                 }
+                None => return Ok(None),
             }
         }
         ExprKind::BoolOp { op, values } => {
             // requires conditional branches for short-circuiting...
-            let left = generator
-                .gen_expr(ctx, &values[0])?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, values[0].custom.unwrap())?
-                .into_int_value();
+            let left = if let Some(v) = generator.gen_expr(ctx, &values[0])? {
+                v.to_basic_value_enum(ctx, generator, values[0].custom.unwrap())?.into_int_value()
+            } else {
+                return Ok(None)
+            };
             let left = generator.bool_to_i1(ctx, left);
             let current = ctx.builder.get_insert_block().unwrap().get_parent().unwrap();
             let a_bb = ctx.ctx.append_basic_block(current, "a");
@@ -1340,45 +1392,62 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                     ctx.builder.position_at_end(a_bb);
                     let a = ctx.ctx.i8_type().const_int(1, false);
                     ctx.builder.build_unconditional_branch(cont_bb);
+
                     ctx.builder.position_at_end(b_bb);
-                    let b = generator
-                        .gen_expr(ctx, &values[1])?
-                        .unwrap()
-                        .to_basic_value_enum(ctx, generator, values[1].custom.unwrap())?
-                        .into_int_value();
-                    let b = generator.bool_to_i8(ctx, b);
-                    ctx.builder.build_unconditional_branch(cont_bb);
-                    (a, b)
+                    let b = if let Some(v) = generator.gen_expr(ctx, &values[1])? {
+                        let b = v.to_basic_value_enum(ctx, generator, values[1].custom.unwrap())?.into_int_value();
+                        let b = generator.bool_to_i8(ctx, b);
+                        ctx.builder.build_unconditional_branch(cont_bb);
+
+                        Some(b)
+                    } else {
+                        None
+                    };
+
+                    (Some(a), b)
                 }
                 Boolop::And => {
                     ctx.builder.position_at_end(a_bb);
-                    let a = generator
-                        .gen_expr(ctx, &values[1])?
-                        .unwrap()
-                        .to_basic_value_enum(ctx, generator, values[1].custom.unwrap())?
-                        .into_int_value();
-                    let a = generator.bool_to_i8(ctx, a);
-                    ctx.builder.build_unconditional_branch(cont_bb);
+                    let a = if let Some(v) = generator.gen_expr(ctx, &values[1])? {
+                        let a = v.to_basic_value_enum(ctx, generator, values[1].custom.unwrap())?.into_int_value();
+                        let a = generator.bool_to_i8(ctx, a);
+                        ctx.builder.build_unconditional_branch(cont_bb);
+
+                        Some(a)
+                    } else {
+                        None
+                    };
+
                     ctx.builder.position_at_end(b_bb);
                     let b = ctx.ctx.i8_type().const_zero();
                     ctx.builder.build_unconditional_branch(cont_bb);
-                    (a, b)
+
+                    (a, Some(b))
                 }
             };
+
             ctx.builder.position_at_end(cont_bb);
-            let phi = ctx.builder.build_phi(ctx.ctx.i8_type(), "");
-            phi.add_incoming(&[(&a, a_bb), (&b, b_bb)]);
-            phi.as_basic_value().into()
+            match (a, b) {
+                (Some(a), Some(b)) => {
+                    let phi = ctx.builder.build_phi(ctx.ctx.i8_type(), "");
+                    phi.add_incoming(&[(&a, a_bb), (&b, b_bb)]);
+                    phi.as_basic_value().into()
+                }
+                (Some(a), None) => a.into(),
+                (None, Some(b)) => b.into(),
+                (None, None) => unreachable!(),
+            }
         }
         ExprKind::BinOp { op, left, right } => {
             return gen_binop_expr(generator, ctx, left, op, right, expr.location, false);
         }
         ExprKind::UnaryOp { op, operand } => {
             let ty = ctx.unifier.get_representative(operand.custom.unwrap());
-            let val =
-                generator.gen_expr(ctx, operand)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, operand.custom.unwrap())?;
+            let val = if let Some(v) = generator.gen_expr(ctx, operand)? {
+                v.to_basic_value_enum(ctx, generator, operand.custom.unwrap())?
+            } else {
+                return Ok(None)
+            };
             if ty == ctx.primitives.bool {
                 let val = val.into_int_value();
                 match op {
@@ -1415,7 +1484,7 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
             }
         }
         ExprKind::Compare { left, ops, comparators } => {
-            izip!(chain(once(left.as_ref()), comparators.iter()), comparators.iter(), ops.iter(),)
+            let cmp_val = izip!(chain(once(left.as_ref()), comparators.iter()), comparators.iter(), ops.iter(),)
                 .fold(Ok(None), |prev: Result<Option<_>, String>, (lhs, rhs, op)| {
                     let ty = ctx.unifier.get_representative(lhs.custom.unwrap());
                     let current =
@@ -1427,23 +1496,15 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                                 ctx.primitives.uint64,
                             ].contains(&ty);
 
-                            let (lhs, rhs) = if let (
-                                BasicValueEnum::IntValue(lhs),
-                                BasicValueEnum::IntValue(rhs),
-                            ) = (
-                                generator
-                                    .gen_expr(ctx, lhs)?
-                                    .unwrap()
-                                    .to_basic_value_enum(ctx, generator, lhs.custom.unwrap())?,
-                                generator
-                                    .gen_expr(ctx, rhs)?
-                                    .unwrap()
-                                    .to_basic_value_enum(ctx, generator, rhs.custom.unwrap())?,
-                            ) {
-                                (lhs, rhs)
-                            } else {
-                                unreachable!()
-                            };
+                            let BasicValueEnum::IntValue(lhs) = (match generator.gen_expr(ctx, lhs)? {
+                                Some(v) => v.to_basic_value_enum(ctx, generator, lhs.custom.unwrap())?,
+                                None => return Ok(None),
+                            }) else { unreachable!() };
+
+                            let BasicValueEnum::IntValue(rhs) = (match generator.gen_expr(ctx, rhs)? {
+                                Some(v) => v.to_basic_value_enum(ctx, generator, rhs.custom.unwrap())?,
+                                None => return Ok(None),
+                            }) else { unreachable!() };
 
                             let op = match op {
                                 ast::Cmpop::Eq | ast::Cmpop::Is => IntPredicate::EQ,
@@ -1474,23 +1535,16 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
 
                             ctx.builder.build_int_compare(op, lhs, rhs, "cmp")
                         } else if ty == ctx.primitives.float {
-                            let (lhs, rhs) = if let (
-                                BasicValueEnum::FloatValue(lhs),
-                                BasicValueEnum::FloatValue(rhs),
-                            ) = (
-                                generator
-                                    .gen_expr(ctx, lhs)?
-                                    .unwrap()
-                                    .to_basic_value_enum(ctx, generator, lhs.custom.unwrap())?,
-                                generator
-                                    .gen_expr(ctx, rhs)?
-                                    .unwrap()
-                                    .to_basic_value_enum(ctx, generator, rhs.custom.unwrap())?,
-                            ) {
-                                (lhs, rhs)
-                            } else {
-                                unreachable!()
-                            };
+                            let BasicValueEnum::FloatValue(lhs) = (match generator.gen_expr(ctx, lhs)? {
+                                Some(v) => v.to_basic_value_enum(ctx, generator, lhs.custom.unwrap())?,
+                                None => return Ok(None),
+                            }) else { unreachable!() };
+
+                            let BasicValueEnum::FloatValue(rhs) = (match generator.gen_expr(ctx, rhs)? {
+                                Some(v) => v.to_basic_value_enum(ctx, generator, rhs.custom.unwrap())?,
+                                None => return Ok(None),
+                            }) else { unreachable!() };
+
                             let op = match op {
                                 ast::Cmpop::Eq | ast::Cmpop::Is => inkwell::FloatPredicate::OEQ,
                                 ast::Cmpop::NotEq => inkwell::FloatPredicate::ONE,
@@ -1505,16 +1559,18 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                             unimplemented!()
                         };
                     Ok(prev?.map(|v| ctx.builder.build_and(v, current, "cmp")).or(Some(current)))
-                })?
-                .unwrap()
-                .into() // as there should be at least 1 element, it should never be none
+                })?;
+
+                match cmp_val {
+                    Some(v) => v.into(),
+                    None => return Ok(None),
+                }
         }
         ExprKind::IfExp { test, body, orelse } => {
-            let test = generator
-                .gen_expr(ctx, test)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, test.custom.unwrap())?
-                .into_int_value();
+            let test = match generator.gen_expr(ctx, test)? {
+                Some(v) => v.to_basic_value_enum(ctx, generator, test.custom.unwrap())?.into_int_value(),
+                None => return Ok(None),
+            };
             let test = generator.bool_to_i1(ctx, test);
             let body_ty = body.custom.unwrap();
             let is_none = ctx.unifier.get_representative(body_ty) == ctx.primitives.none;
@@ -1529,37 +1585,52 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
             let else_bb = ctx.ctx.append_basic_block(current, "else");
             let cont_bb = ctx.ctx.append_basic_block(current, "cont");
             ctx.builder.build_conditional_branch(test, then_bb, else_bb);
+
             ctx.builder.position_at_end(then_bb);
             let a = generator.gen_expr(ctx, body)?;
-            match result {
-                None => None,
-                Some(v) => {
-                    let a = a.unwrap().to_basic_value_enum(ctx, generator, body.custom.unwrap())?;
-                    Some(ctx.builder.build_store(v, a))
-                }
-            };
-            ctx.builder.build_unconditional_branch(cont_bb);
+            if let Some(a) = a {
+                match result {
+                    None => None,
+                    Some(v) => {
+                        let a = a.to_basic_value_enum(ctx, generator, body.custom.unwrap())?;
+                        Some(ctx.builder.build_store(v, a))
+                    }
+                };
+                ctx.builder.build_unconditional_branch(cont_bb);
+            }
+
             ctx.builder.position_at_end(else_bb);
             let b = generator.gen_expr(ctx, orelse)?;
-            match result {
-                None => None,
-                Some(v) => {
-                    let b = b.unwrap().to_basic_value_enum(ctx, generator, orelse.custom.unwrap())?;
-                    Some(ctx.builder.build_store(v, b))
-                }
-            };
-            ctx.builder.build_unconditional_branch(cont_bb);
+            if let Some(b) = b {
+                match result {
+                    None => None,
+                    Some(v) => {
+                        let b = b.to_basic_value_enum(ctx, generator, orelse.custom.unwrap())?;
+                        Some(ctx.builder.build_store(v, b))
+                    }
+                };
+                ctx.builder.build_unconditional_branch(cont_bb);
+            }
+
             ctx.builder.position_at_end(cont_bb);
-            match result {
-                None => return Ok(None),
-                Some(v) => return Ok(Some(ctx.builder.build_load(v, "if_exp_val_load").into()))
+            if let Some(v) = result {
+                ctx.builder.build_load(v, "if_exp_val_load").into()
+            } else {
+                return Ok(None)
             }
         }
         ExprKind::Call { func, args, keywords } => {
             let mut params = args
                 .iter()
-                .map(|arg| Ok((None, generator.gen_expr(ctx, arg)?.unwrap())) as Result<_, String>)
+                .map(|arg| generator.gen_expr(ctx, arg))
+                .take_while(|expr| !matches!(expr, Ok(None)))
+                .map(|expr| Ok((None, expr?.unwrap())) as Result<_, String>)
                 .collect::<Result<Vec<_>, _>>()?;
+
+            if params.len() < args.len() {
+                return Ok(None)
+            }
+
             let kw_iter = keywords.iter().map(|kw| {
                 Ok((
                     Some(*kw.node.arg.as_ref().unwrap()),
@@ -1593,7 +1664,11 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                         .map(|v| v.into()));
                 }
                 ExprKind::Attribute { value, attr, .. } => {
-                    let val = generator.gen_expr(ctx, value)?.unwrap();
+                    let val = match generator.gen_expr(ctx, value)? {
+                        Some(v) => v,
+                        None => return Ok(None),
+                    };
+
                     let id = if let TypeEnum::TObj { obj_id, .. } =
                         &*ctx.unifier.get_ty(value.custom.unwrap())
                     {
@@ -1691,18 +1766,20 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
         }
         ExprKind::Subscript { value, slice, .. } => {
             if let TypeEnum::TList { ty } = &*ctx.unifier.get_ty(value.custom.unwrap()) {
-                let v = generator
-                    .gen_expr(ctx, value)?
-                    .unwrap()
-                    .to_basic_value_enum(ctx, generator, value.custom.unwrap())?
-                    .into_pointer_value();
+                let v = if let Some(v) = generator.gen_expr(ctx, value)? {
+                    v.to_basic_value_enum(ctx, generator, value.custom.unwrap())?.into_pointer_value()
+                } else {
+                    return Ok(None)
+                };
                 let ty = ctx.get_llvm_type(generator, *ty);
                 let arr_ptr = ctx.build_gep_and_load(v, &[zero, zero], Some("arr.addr"))
                     .into_pointer_value();
                 if let ExprKind::Slice { lower, upper, step } = &slice.node {
                     let one = int32.const_int(1, false);
-                    let (start, end, step) =
-                        handle_slice_indices(lower, upper, step, ctx, generator, v)?;
+                    let Some((start, end, step)) =
+                        handle_slice_indices(lower, upper, step, ctx, generator, v)? else {
+                        return Ok(None)
+                    };
                     let length = calculate_len_for_slice_range(
                         generator,
                         ctx,
@@ -1723,8 +1800,10 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                         step,
                     );
                     let res_array_ret = allocate_list(generator, ctx, ty, length, Some("ret"));
-                    let res_ind =
-                        handle_slice_indices(&None, &None, &None, ctx, generator, res_array_ret)?;
+                    let Some(res_ind) =
+                        handle_slice_indices(&None, &None, &None, ctx, generator, res_array_ret)? else {
+                        return Ok(None)
+                    };
                     list_slice_assignment(
                         generator,
                         ctx,
@@ -1739,11 +1818,11 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                     let len = ctx
                         .build_gep_and_load(v, &[zero, int32.const_int(1, false)], Some("len"))
                         .into_int_value();
-                    let raw_index = generator
-                        .gen_expr(ctx, slice)?
-                        .unwrap()
-                        .to_basic_value_enum(ctx, generator, slice.custom.unwrap())?
-                        .into_int_value();
+                    let raw_index = if let Some(v) = generator.gen_expr(ctx, slice)? {
+                        v.to_basic_value_enum(ctx, generator, slice.custom.unwrap())?.into_int_value()
+                    } else {
+                        return Ok(None)
+                    };
                     let raw_index = ctx.builder.build_int_s_extend(
                         raw_index,
                         generator.get_size_type(ctx.ctx),
@@ -1786,15 +1865,12 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                     } else {
                         unreachable!("tuple subscript must be const int after type check");
                     };
-                let v = generator
-                    .gen_expr(ctx, value)?
-                    .unwrap();
-                match v {
-                    ValueEnum::Dynamic(v) => {
+                match generator.gen_expr(ctx, value)? {
+                    Some(ValueEnum::Dynamic(v)) => {
                         let v = v.into_struct_value();
                         ctx.builder.build_extract_value(v, index, "tup_elem").unwrap().into()
                     }
-                    ValueEnum::Static(v) => {
+                    Some(ValueEnum::Static(v)) => {
                         match v.get_tuple_element(index) {
                             Some(v) => v,
                             None => {
@@ -1805,12 +1881,19 @@ pub fn gen_expr<'ctx, 'a, G: CodeGenerator>(
                             }
                         }
                     }
+                    None => return Ok(None),
                 }
             } else {
                 unreachable!("should not be other subscriptable types after type check");
             }
         },
-        ExprKind::ListComp { .. } => gen_comprehension(generator, ctx, expr)?.into(),
+        ExprKind::ListComp { .. } => {
+            if let Some(v) = gen_comprehension(generator, ctx, expr)? {
+                v.into()
+            } else {
+                return Ok(None)
+            }
+        }
         _ => unimplemented!(),
     }))
 }

nac3core/src/codegen/generator.rs

@@ -98,7 +98,7 @@ pub trait CodeGenerator {
         ctx: &mut CodeGenContext<'ctx, 'a>,
         pattern: &Expr<Option<Type>>,
         name: Option<&str>,
-    ) -> Result<PointerValue<'ctx>, String>
+    ) -> Result<Option<PointerValue<'ctx>>, String>
     where
         Self: Sized,
     {

nac3core/src/codegen/irrt/mod.rs

@@ -158,33 +158,41 @@ pub fn handle_slice_indices<'a, 'ctx, G: CodeGenerator>(
     ctx: &mut CodeGenContext<'ctx, 'a>,
     generator: &mut G,
     list: PointerValue<'ctx>,
-) -> Result<(IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>), String> {
+) -> Result<Option<(IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>)>, String> {
     let int32 = ctx.ctx.i32_type();
     let zero = int32.const_zero();
     let one = int32.const_int(1, false);
     let length = ctx.build_gep_and_load(list, &[zero, one], Some("length")).into_int_value();
     let length = ctx.builder.build_int_truncate_or_bit_cast(length, int32, "leni32");
-    Ok(match (start, end, step) {
+    Ok(Some(match (start, end, step) {
         (s, e, None) => (
-            s.as_ref().map_or_else(
-                || Ok(int32.const_zero()),
-                |s| handle_slice_index_bound(s, ctx, generator, length),
-            )?,
+            if let Some(s) = s.as_ref() {
+                match handle_slice_index_bound(s, ctx, generator, length)? {
+                    Some(v) => v,
+                    None => return Ok(None),
+                }
+            } else {
+                int32.const_zero()
+            },
             {
-                let e = e.as_ref().map_or_else(
-                    || Ok(length),
-                    |e| handle_slice_index_bound(e, ctx, generator, length),
-                )?;
+                let e = if let Some(s) = e.as_ref() {
+                    match handle_slice_index_bound(s, ctx, generator, length)? {
+                        Some(v) => v,
+                        None => return Ok(None),
+                    }
+                } else {
+                    length
+                };
                 ctx.builder.build_int_sub(e, one, "final_end")
             },
             one,
         ),
         (s, e, Some(step)) => {
-            let step = generator
-                .gen_expr(ctx, step)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, ctx.primitives.int32)?
-                .into_int_value();
+            let step = if let Some(v) = generator.gen_expr(ctx, step)? {
+                v.to_basic_value_enum(ctx, generator, ctx.primitives.int32)?.into_int_value()
+            } else {
+                return Ok(None)
+            };
             // assert step != 0, throw exception if not
             let not_zero = ctx.builder.build_int_compare(
                 IntPredicate::NE,
@@ -205,7 +213,9 @@ pub fn handle_slice_indices<'a, 'ctx, G: CodeGenerator>(
             (
                 match s {
                     Some(s) => {
-                        let s = handle_slice_index_bound(s, ctx, generator, length)?;
+                        let Some(s) = handle_slice_index_bound(s, ctx, generator, length)? else {
+                            return Ok(None)
+                        };
                         ctx.builder
                             .build_select(
                                 ctx.builder.build_and(
@@ -228,7 +238,9 @@ pub fn handle_slice_indices<'a, 'ctx, G: CodeGenerator>(
                 },
                 match e {
                     Some(e) => {
-                        let e = handle_slice_index_bound(e, ctx, generator, length)?;
+                        let Some(e) = handle_slice_index_bound(e, ctx, generator, length)? else {
+                            return Ok(None)
+                        };
                         ctx.builder
                             .build_select(
                                 neg,
@@ -243,7 +255,7 @@ pub fn handle_slice_indices<'a, 'ctx, G: CodeGenerator>(
                 step,
             )
         }
-    })
+    }))
 }
 
 /// this function allows index out of range, since python
@@ -253,7 +265,7 @@ pub fn handle_slice_index_bound<'a, 'ctx, G: CodeGenerator>(
     ctx: &mut CodeGenContext<'ctx, 'a>,
     generator: &mut G,
     length: IntValue<'ctx>,
-) -> Result<IntValue<'ctx>, String> {
+) -> Result<Option<IntValue<'ctx>>, String> {
     const SYMBOL: &str = "__nac3_slice_index_bound";
     let func = ctx.module.get_function(SYMBOL).unwrap_or_else(|| {
         let i32_t = ctx.ctx.i32_type();
@@ -261,14 +273,18 @@ pub fn handle_slice_index_bound<'a, 'ctx, G: CodeGenerator>(
         ctx.module.add_function(SYMBOL, fn_t, None)
     });
 
-    let i = generator.gen_expr(ctx, i)?.unwrap().to_basic_value_enum(ctx, generator, i.custom.unwrap())?;
-    Ok(ctx
+    let i = if let Some(v) = generator.gen_expr(ctx, i)? {
+        v.to_basic_value_enum(ctx, generator, i.custom.unwrap())?
+    } else {
+        return Ok(None)
+    };
+    Ok(Some(ctx
         .builder
         .build_call(func, &[i.into(), length.into()], "bounded_ind")
         .try_as_basic_value()
         .left()
         .unwrap()
-        .into_int_value())
+        .into_int_value()))
 }
 
 /// This function handles 'end' **inclusively**.

nac3core/src/codegen/stmt.rs

@@ -60,10 +60,10 @@ pub fn gen_store_target<'ctx, 'a, G: CodeGenerator>(
     ctx: &mut CodeGenContext<'ctx, 'a>,
     pattern: &Expr<Option<Type>>,
     name: Option<&str>,
-) -> Result<PointerValue<'ctx>, String> {
+) -> Result<Option<PointerValue<'ctx>>, String> {
     // very similar to gen_expr, but we don't do an extra load at the end
     // and we flatten nested tuples
-    Ok(match &pattern.node {
+    Ok(Some(match &pattern.node {
         ExprKind::Name { id, .. } => match ctx.var_assignment.get(id) {
             None => {
                 let ptr_ty = ctx.get_llvm_type(generator, pattern.custom.unwrap());
@@ -79,11 +79,11 @@ pub fn gen_store_target<'ctx, 'a, G: CodeGenerator>(
         }
         ExprKind::Attribute { value, attr, .. } => {
             let index = ctx.get_attr_index(value.custom.unwrap(), *attr);
-            let val = generator.gen_expr(ctx, value)?.unwrap().to_basic_value_enum(
-                ctx,
-                generator,
-                value.custom.unwrap(),
-            )?;
+            let val = if let Some(v) = generator.gen_expr(ctx, value)? {
+                v.to_basic_value_enum(ctx, generator, value.custom.unwrap())?
+            } else {
+                return Ok(None)
+            };
             let ptr = if let BasicValueEnum::PointerValue(v) = val {
                 v
             } else {
@@ -107,19 +107,19 @@ pub fn gen_store_target<'ctx, 'a, G: CodeGenerator>(
             ));
             let i32_type = ctx.ctx.i32_type();
             let zero = i32_type.const_zero();
-            let v = generator
-                .gen_expr(ctx, value)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, value.custom.unwrap())?
-                .into_pointer_value();
+            let v = if let Some(v) = generator.gen_expr(ctx, value)? {
+                v.to_basic_value_enum(ctx, generator, value.custom.unwrap())?.into_pointer_value()
+            } else {
+                return Ok(None)
+            };
             let len = ctx
                 .build_gep_and_load(v, &[zero, i32_type.const_int(1, false)], Some("len"))
                 .into_int_value();
-            let raw_index = generator
-                .gen_expr(ctx, slice)?
-                .unwrap()
-                .to_basic_value_enum(ctx, generator, slice.custom.unwrap())?
-                .into_int_value();
+            let raw_index = if let Some(v) = generator.gen_expr(ctx, slice)? {
+                v.to_basic_value_enum(ctx, generator, slice.custom.unwrap())?.into_int_value()
+            } else {
+                return Ok(None)
+            };
             let raw_index = ctx.builder.build_int_s_extend(
                 raw_index,
                 generator.get_size_type(ctx.ctx),
@@ -161,7 +161,7 @@ pub fn gen_store_target<'ctx, 'a, G: CodeGenerator>(
             }
         }
         _ => unreachable!(),
-    })
+    }))
 }
 
 /// See [CodeGenerator::gen_assign].
@@ -196,8 +196,10 @@ pub fn gen_assign<'ctx, 'a, G: CodeGenerator>(
                     .unwrap()
                     .to_basic_value_enum(ctx, generator, ls.custom.unwrap())?
                     .into_pointer_value();
-                let (start, end, step) =
-                    handle_slice_indices(lower, upper, step, ctx, generator, ls)?;
+                let Some((start, end, step)) =
+                    handle_slice_indices(lower, upper, step, ctx, generator, ls)? else {
+                    return Ok(())
+                };
                 let value = value
                     .to_basic_value_enum(ctx, generator, target.custom.unwrap())?
                     .into_pointer_value();
@@ -207,7 +209,9 @@ pub fn gen_assign<'ctx, 'a, G: CodeGenerator>(
                     } else {
                         unreachable!()
                     };
-                let src_ind = handle_slice_indices(&None, &None, &None, ctx, generator, value)?;
+                let Some(src_ind) = handle_slice_indices(&None, &None, &None, ctx, generator, value)? else {
+                    return Ok(())
+                };
                 list_slice_assignment(generator, ctx, ty, ls, (start, end, step), value, src_ind)
             } else {
                 unreachable!()
@@ -219,7 +223,9 @@ pub fn gen_assign<'ctx, 'a, G: CodeGenerator>(
             } else {
                 String::from("target.addr")
             };
-            let ptr = generator.gen_store_target(ctx, target, Some(name.as_str()))?;
+            let Some(ptr) = generator.gen_store_target(ctx, target, Some(name.as_str()))? else {
+                return Ok(())
+            };
 
             if let ExprKind::Name { id, .. } = &target.node {
                 let (_, static_value, counter) = ctx.var_assignment.get_mut(id).unwrap();
@@ -270,17 +276,23 @@ pub fn gen_for<'ctx, 'a, G: CodeGenerator>(
         // store loop bb information and restore it later
         let loop_bb = ctx.loop_target.replace((incr_bb, cont_bb));
 
-        let iter_val = generator.gen_expr(ctx, iter)?.unwrap().to_basic_value_enum(
-            ctx,
-            generator,
-            iter.custom.unwrap(),
-        )?;
+        let iter_val = if let Some(v) = generator.gen_expr(ctx, iter)? {
+            v.to_basic_value_enum(
+                ctx,
+                generator,
+                iter.custom.unwrap(),
+            )?
+        } else {
+            return Ok(())
+        };
         if is_iterable_range_expr {
             let iter_val = iter_val.into_pointer_value();
             // Internal variable for loop; Cannot be assigned
             let i = generator.gen_var_alloc(ctx, int32.into(), Some("for.i.addr"))?;
             // Variable declared in "target" expression of the loop; Can be reassigned *or* shadowed
-            let target_i = generator.gen_store_target(ctx, target, Some("for.target.addr"))?;
+            let Some(target_i) = generator.gen_store_target(ctx, target, Some("for.target.addr"))? else {
+                unreachable!()
+            };
             let (start, stop, step) = destructure_range(ctx, iter_val);
 
             ctx.builder.build_store(i, start);
@@ -412,11 +424,16 @@ pub fn gen_while<'ctx, 'a, G: CodeGenerator>(
         let loop_bb = ctx.loop_target.replace((test_bb, cont_bb));
         ctx.builder.build_unconditional_branch(test_bb);
         ctx.builder.position_at_end(test_bb);
-        let test = generator.gen_expr(ctx, test)?.unwrap().to_basic_value_enum(
-            ctx,
-            generator,
-            test.custom.unwrap(),
-        )?;
+        let test = if let Some(v) = generator.gen_expr(ctx, test)? {
+            v.to_basic_value_enum(ctx, generator, test.custom.unwrap())?
+        } else {
+            for bb in [body_bb, cont_bb] {
+                ctx.builder.position_at_end(bb);
+                ctx.builder.build_unreachable();
+            }
+
+            return Ok(())
+        };
         if let BasicValueEnum::IntValue(test) = test {
             ctx.builder.build_conditional_branch(generator.bool_to_i1(ctx, test), body_bb, orelse_bb);
         } else {
@@ -478,13 +495,11 @@ pub fn gen_if<'ctx, 'a, G: CodeGenerator>(
         };
         ctx.builder.build_unconditional_branch(test_bb);
         ctx.builder.position_at_end(test_bb);
-        let test = generator.gen_expr(ctx, test)?
-            .unwrap()
-            .to_basic_value_enum(ctx, generator, test.custom.unwrap())?;
-        if let BasicValueEnum::IntValue(test) = test {
+        let test = generator
+            .gen_expr(ctx, test)
+            .and_then(|v| v.map(|v| v.to_basic_value_enum(ctx, generator, test.custom.unwrap())).transpose())?;
+        if let Some(BasicValueEnum::IntValue(test)) = test {
             ctx.builder.build_conditional_branch(generator.bool_to_i1(ctx, test), body_bb, orelse_bb);
-        } else {
-            unreachable!()
         };
         ctx.builder.position_at_end(body_bb);
         generator.gen_block(ctx, body.iter())?;
@@ -604,7 +619,7 @@ pub fn exn_constructor<'ctx, 'a>(
         let msg = if !args.is_empty() {
             args.remove(0).1.to_basic_value_enum(ctx, generator, ctx.primitives.str)?
         } else {
-            empty_string
+            empty_string.unwrap()
         };
         ctx.builder.build_store(ptr, msg);
         for i in [6, 7, 8].iter() {
@@ -627,7 +642,7 @@ pub fn exn_constructor<'ctx, 'a>(
                 &[zero, int32.const_int(*i, false)],
                 "exn.str",
             );
-            ctx.builder.build_store(ptr, empty_string);
+            ctx.builder.build_store(ptr, empty_string.unwrap());
         }
         // set ints to zero
         for i in [2, 3].iter() {
@@ -1036,14 +1051,17 @@ pub fn gen_return<'ctx, 'a, G: CodeGenerator>(
     value: &Option<Box<Expr<Option<Type>>>>,
 ) -> Result<(), String> {
     let func = ctx.builder.get_insert_block().and_then(|bb| bb.get_parent()).unwrap();
-    let value = value
-        .as_ref()
-        .map(|v_expr| {
-            generator.gen_expr(ctx, v_expr).and_then(|v| {
-                v.unwrap().to_basic_value_enum(ctx, generator, v_expr.custom.unwrap())
-            })
-        })
-        .transpose()?;
+    let value = if let Some(v_expr) = value.as_ref() {
+        if let Some(v) = generator.gen_expr(ctx, v_expr).transpose() {
+            Some(
+                v.and_then(|v| v.to_basic_value_enum(ctx, generator, v_expr.custom.unwrap()))?
+            )
+        } else {
+            return Ok(())
+        }
+    } else {
+        None
+    };
     if let Some(return_target) = ctx.return_target {
         if let Some(value) = value {
             ctx.builder.build_store(ctx.return_buffer.unwrap(), value);
@@ -1105,12 +1123,16 @@ pub fn gen_stmt<'ctx, 'a, G: CodeGenerator>(
         }
         StmtKind::AnnAssign { target, value, .. } => {
             if let Some(value) = value {
-                let value = generator.gen_expr(ctx, value)?.unwrap();
+                let Some(value) = generator.gen_expr(ctx, value)? else {
+                    return Ok(())
+                };
                 generator.gen_assign(ctx, target, value)?;
             }
         }
         StmtKind::Assign { targets, value, .. } => {
-            let value = generator.gen_expr(ctx, value)?.unwrap();
+            let Some(value) = generator.gen_expr(ctx, value)? else {
+                return Ok(())
+            };
             for target in targets.iter() {
                 generator.gen_assign(ctx, target, value.clone())?;
             }
@@ -1132,28 +1154,28 @@ pub fn gen_stmt<'ctx, 'a, G: CodeGenerator>(
         StmtKind::Try { .. } => gen_try(generator, ctx, stmt)?,
         StmtKind::Raise { exc, .. } => {
             if let Some(exc) = exc {
-                let exc = generator.gen_expr(ctx, exc)?.unwrap().to_basic_value_enum(
-                    ctx,
-                    generator,
-                    exc.custom.unwrap(),
-                )?;
+                let exc = if let Some(v) = generator.gen_expr(ctx, exc)? {
+                    v.to_basic_value_enum(ctx, generator, exc.custom.unwrap())?
+                } else {
+                    return Ok(())
+                };
                 gen_raise(generator, ctx, Some(&exc), stmt.location);
             } else {
                 gen_raise(generator, ctx, None, stmt.location);
             }
         }
         StmtKind::Assert { test, msg, .. } => {
-            let test = generator.gen_expr(ctx, test)?.unwrap().to_basic_value_enum(
-                ctx,
-                generator,
-                test.custom.unwrap(),
-            )?;
+            let test = if let Some(v) = generator.gen_expr(ctx, test)? {
+                v.to_basic_value_enum(ctx, generator, test.custom.unwrap())?
+            } else {
+                return Ok(())
+            };
             let err_msg = match msg {
-                Some(msg) => generator.gen_expr(ctx, msg)?.unwrap().to_basic_value_enum(
-                    ctx,
-                    generator,
-                    msg.custom.unwrap(),
-                )?,
+                Some(msg) => if let Some(v) = generator.gen_expr(ctx, msg)? {
+                    v.to_basic_value_enum(ctx, generator, msg.custom.unwrap())?
+                } else {
+                    return Ok(())
+                },
                 None => ctx.gen_string(generator, ""),
             };
             ctx.make_assert_impl(

nac3core/src/symbol_resolver.rs

@@ -1,11 +1,12 @@
 use std::fmt::Debug;
 use std::sync::Arc;
 use std::{collections::HashMap, fmt::Display};
+use std::rc::Rc;
 
 use crate::typecheck::typedef::TypeEnum;
 use crate::{
     codegen::CodeGenContext,
-    toplevel::{DefinitionId, TopLevelDef},
+    toplevel::{DefinitionId, TopLevelDef, type_annotation::TypeAnnotation},
 };
 use crate::{
     codegen::CodeGenerator,
@@ -16,7 +17,7 @@ use crate::{
 };
 use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
 use itertools::{chain, izip};
-use nac3parser::ast::{Expr, Location, StrRef};
+use nac3parser::ast::{Constant, Expr, Location, StrRef};
 use parking_lot::RwLock;
 
 #[derive(Clone, PartialEq, Debug)]
@@ -33,6 +34,147 @@ pub enum SymbolValue {
     OptionNone,
 }
 
+impl SymbolValue {
+    /// Creates a [SymbolValue] from a [Constant].
+    ///
+    /// * `constant` - The constant to create the value from.
+    /// * `expected_ty` - The expected type of the [SymbolValue].
+    pub fn from_constant(
+        constant: &Constant,
+        expected_ty: Type,
+        primitives: &PrimitiveStore,
+        unifier: &mut Unifier
+    ) -> Result<Self, String> {
+        match constant {
+            Constant::None => {
+                if unifier.unioned(expected_ty, primitives.option) {
+                    Ok(SymbolValue::OptionNone)
+                } else {
+                    Err(format!("Expected {:?}, but got Option", expected_ty))
+                }
+            }
+            Constant::Bool(b) => {
+                if unifier.unioned(expected_ty, primitives.bool) {
+                    Ok(SymbolValue::Bool(*b))
+                } else {
+                    Err(format!("Expected {:?}, but got bool", expected_ty))
+                }
+            }
+            Constant::Str(s) => {
+                if unifier.unioned(expected_ty, primitives.str) {
+                    Ok(SymbolValue::Str(s.to_string()))
+                } else {
+                    Err(format!("Expected {:?}, but got str", expected_ty))
+                }
+            },
+            Constant::Int(i) => {
+                if unifier.unioned(expected_ty, primitives.int32) {
+                    i32::try_from(*i)
+                        .map(|val| SymbolValue::I32(val))
+                        .map_err(|e| e.to_string())
+                } else if unifier.unioned(expected_ty, primitives.int64) {
+                    i64::try_from(*i)
+                        .map(|val| SymbolValue::I64(val))
+                        .map_err(|e| e.to_string())
+                } else if unifier.unioned(expected_ty, primitives.uint32) {
+                    u32::try_from(*i)
+                        .map(|val| SymbolValue::U32(val))
+                        .map_err(|e| e.to_string())
+                } else if unifier.unioned(expected_ty, primitives.uint64) {
+                    u64::try_from(*i)
+                        .map(|val| SymbolValue::U64(val))
+                        .map_err(|e| e.to_string())
+                } else {
+                    Err(format!("Expected {}, but got int", unifier.stringify(expected_ty)))
+                }
+            }
+            Constant::Tuple(t) => {
+                let expected_ty = unifier.get_ty(expected_ty);
+                let TypeEnum::TTuple { ty } = expected_ty.as_ref() else {
+                    return Err(format!("Expected {:?}, but got Tuple", expected_ty.get_type_name()))
+                };
+
+                assert_eq!(ty.len(), t.len());
+
+                let elems = t.into_iter()
+                    .zip(ty)
+                    .map(|(constant, ty)| Self::from_constant(constant, *ty, primitives, unifier))
+                    .collect::<Result<Vec<SymbolValue>, _>>()?;
+                Ok(SymbolValue::Tuple(elems))
+            }
+            Constant::Float(f) => {
+                if unifier.unioned(expected_ty, primitives.float) {
+                    Ok(SymbolValue::Double(*f))
+                } else {
+                    Err(format!("Expected {:?}, but got float", expected_ty))
+                }
+            },
+            _ => Err(format!("Unsupported value type {:?}", constant)),
+        }
+    }
+
+    /// Returns the [Type] representing the data type of this value.
+    pub fn get_type(&self, primitives: &PrimitiveStore, unifier: &mut Unifier) -> Type {
+        match self {
+            SymbolValue::I32(_) => primitives.int32,
+            SymbolValue::I64(_) => primitives.int64,
+            SymbolValue::U32(_) => primitives.uint32,
+            SymbolValue::U64(_) => primitives.uint64,
+            SymbolValue::Str(_) => primitives.str,
+            SymbolValue::Double(_) => primitives.float,
+            SymbolValue::Bool(_) => primitives.bool,
+            SymbolValue::Tuple(vs) => {
+                let vs_tys = vs
+                    .iter()
+                    .map(|v| v.get_type(primitives, unifier))
+                    .collect::<Vec<_>>();
+                unifier.add_ty(TypeEnum::TTuple {
+                    ty: vs_tys,
+                })
+            }
+            SymbolValue::OptionSome(_) => primitives.option,
+            SymbolValue::OptionNone => primitives.option,
+        }
+    }
+
+    /// Returns the [TypeAnnotation] representing the data type of this value.
+    pub fn get_type_annotation(&self, primitives: &PrimitiveStore, unifier: &mut Unifier) -> TypeAnnotation {
+        match self {
+            SymbolValue::Bool(..) => TypeAnnotation::Primitive(primitives.bool),
+            SymbolValue::Double(..) => TypeAnnotation::Primitive(primitives.float),
+            SymbolValue::I32(..) => TypeAnnotation::Primitive(primitives.int32),
+            SymbolValue::I64(..) => TypeAnnotation::Primitive(primitives.int64),
+            SymbolValue::U32(..) => TypeAnnotation::Primitive(primitives.uint32),
+            SymbolValue::U64(..) => TypeAnnotation::Primitive(primitives.uint64),
+            SymbolValue::Str(..) => TypeAnnotation::Primitive(primitives.str),
+            SymbolValue::Tuple(vs) => {
+                let vs_tys = vs
+                    .iter()
+                    .map(|v| v.get_type_annotation(primitives, unifier))
+                    .collect::<Vec<_>>();
+                TypeAnnotation::Tuple(vs_tys)
+            }
+            SymbolValue::OptionNone => TypeAnnotation::CustomClass {
+                id: primitives.option.get_obj_id(unifier),
+                params: Default::default(),
+            },
+            SymbolValue::OptionSome(v) => {
+                let ty = v.get_type_annotation(primitives, unifier);
+                TypeAnnotation::CustomClass {
+                    id: primitives.option.get_obj_id(unifier),
+                    params: vec![ty],
+                }
+            }
+        }
+    }
+
+    /// Returns the [TypeEnum] representing the data type of this value.
+    pub fn get_type_enum(&self, primitives: &PrimitiveStore, unifier: &mut Unifier) -> Rc<TypeEnum> {
+        let ty = self.get_type(primitives, unifier);
+        unifier.get_ty(ty)
+    }
+}
+
 impl Display for SymbolValue {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

nac3core/src/toplevel/builtins.rs

@@ -22,7 +22,7 @@ use inkwell::{
     IntPredicate
 };
 
-type BuiltinInfo = (Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>, &'static [&'static str]);
+type BuiltinInfo = Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>;
 
 pub fn get_exn_constructor(
     name: &str,
@@ -1906,68 +1906,6 @@ pub fn get_builtins(primitives: &mut (PrimitiveStore, Unifier)) -> BuiltinInfo {
 
     let ast_list: Vec<Option<ast::Stmt<()>>> =
         (0..top_level_def_list.len()).map(|_| None).collect();
-    (
-        izip!(top_level_def_list, ast_list).collect_vec(),
-        &[
-            "int32",
-            "int64",
-            "uint32",
-            "uint64",
-            "float",
-            "round",
-            "round64",
-            "np_round",
-            "range",
-            "str",
-            "bool",
-            "floor",
-            "floor64",
-            "np_floor",
-            "ceil",
-            "ceil64",
-            "np_ceil",
-            "len",
-            "min",
-            "max",
-            "abs",
-            "np_isnan",
-            "np_isinf",
-            "np_sin",
-            "np_cos",
-            "np_exp",
-            "np_exp2",
-            "np_log",
-            "np_log10",
-            "np_log2",
-            "np_fabs",
-            "np_sqrt",
-            "np_rint",
-            "np_tan",
-            "np_arcsin",
-            "np_arccos",
-            "np_arctan",
-            "np_sinh",
-            "np_cosh",
-            "np_tanh",
-            "np_arcsinh",
-            "np_arccosh",
-            "np_arctanh",
-            "np_expm1",
-            "np_cbrt",
-            "sp_spec_erf",
-            "sp_spec_erfc",
-            "sp_spec_gamma",
-            "sp_spec_gammaln",
-            "sp_spec_j0",
-            "sp_spec_j1",
-            "np_arctan2",
-            "np_copysign",
-            "np_fmax",
-            "np_fmin",
-            "np_ldexp",
-            "np_hypot",
-            "np_nextafter",
-            "Some",
-        ],
-    )
+
+    izip!(top_level_def_list, ast_list).collect_vec()
 }

nac3core/src/toplevel/composer.rs

@@ -53,7 +53,7 @@ impl TopLevelComposer {
         core_config: ComposerConfig,
     ) -> (Self, HashMap<StrRef, DefinitionId>, HashMap<StrRef, Type>) {
         let mut primitives = Self::make_primitives();
-        let (mut definition_ast_list, builtin_name_list) = builtins::get_builtins(&mut primitives);
+        let mut definition_ast_list = builtins::get_builtins(&mut primitives);
         let primitives_ty = primitives.0;
         let mut unifier = primitives.1;
         let mut keyword_list: HashSet<StrRef> = HashSet::from_iter(vec![
@@ -83,12 +83,26 @@ impl TopLevelComposer {
         let mut builtin_id: HashMap<StrRef, DefinitionId> = Default::default();
         let mut builtin_ty: HashMap<StrRef, Type> = Default::default();
 
-        for (id, name) in builtin_name_list.iter().rev().enumerate() {
+        let builtin_name_list = definition_ast_list.iter()
+            .map(|def_ast| match *def_ast.0.read() {
+                TopLevelDef::Class { name, .. } => name.to_string(),
+                TopLevelDef::Function { simple_name, .. } => simple_name.to_string(),
+            })
+            .collect_vec();
+
+        for (id, name) in builtin_name_list.iter().enumerate() {
             let name = (**name).into();
-            let id = definition_ast_list.len() - id - 1;
             let def = definition_ast_list[id].0.read();
-            if let TopLevelDef::Function { simple_name, signature, .. } = &*def {
-                assert!(name == *simple_name);
+            if let TopLevelDef::Function { name: func_name, simple_name, signature, .. } = &*def {
+                assert_eq!(name, *simple_name, "Simple name of builtin function should match builtin name list");
+
+                // Do not add member functions into the list of builtin IDs;
+                // Here we assume that all builtin top-level functions have the same name and simple
+                // name, and all member functions have something prefixed to its name
+                if *func_name != simple_name.to_string() {
+                    continue
+                }
+
                 builtin_ty.insert(name, *signature);
                 builtin_id.insert(name, DefinitionId(id));
             } else if let TopLevelDef::Class { name, constructor, object_id, .. } = &*def
@@ -546,6 +560,7 @@ impl TopLevelComposer {
                         &primitive_types,
                         b,
                         vec![(*class_def_id, class_type_vars.clone())].into_iter().collect(),
+                        None,
                     )?;
 
                     if let TypeAnnotation::CustomClass { .. } = &base_ty {
@@ -880,6 +895,7 @@ impl TopLevelComposer {
                                     // NOTE: since only class need this, for function
                                     // it should be fine to be empty map
                                     HashMap::new(),
+                                    None,
                                 )?;
 
                                 let type_vars_within =
@@ -947,6 +963,7 @@ impl TopLevelComposer {
                                     // NOTE: since only class need this, for function
                                     // it should be fine to be empty map
                                     HashMap::new(),
+                                    None,
                                 )?
                             };
 
@@ -1144,6 +1161,7 @@ impl TopLevelComposer {
                                         vec![(class_id, class_type_vars_def.clone())]
                                             .into_iter()
                                             .collect(),
+                                        None,
                                     )?
                                 };
                                 // find type vars within this method parameter type annotation
@@ -1207,6 +1225,7 @@ impl TopLevelComposer {
                                 primitives,
                                 result,
                                 vec![(class_id, class_type_vars_def.clone())].into_iter().collect(),
+                                None,
                             )?;
                             // find type vars within this return type annotation
                             let type_vars_within =
@@ -1303,6 +1322,7 @@ impl TopLevelComposer {
                                 primitives,
                                 annotation.as_ref(),
                                 vec![(class_id, class_type_vars_def.clone())].into_iter().collect(),
+                                None,
                             )?;
                             // find type vars within this return type annotation
                             let type_vars_within =
@@ -1721,7 +1741,7 @@ impl TopLevelComposer {
                             .iter()
                             .map(|(_, ty)| {
                                 unifier.get_instantiations(*ty).unwrap_or_else(|| {
-                                    if let TypeEnum::TVar { name, loc, .. } = &*unifier.get_ty(*ty)
+                                    if let TypeEnum::TVar { name, loc, is_const_generic: false, .. } = &*unifier.get_ty(*ty)
                                     {
                                         let rigid = unifier.get_fresh_rigid_var(*name, *loc).0;
                                         no_ranges.push(rigid);

nac3core/src/toplevel/helper.rs

@@ -416,40 +416,6 @@ impl TopLevelComposer {
         primitive: &PrimitiveStore,
         unifier: &mut Unifier,
     ) -> Result<(), String> {
-        fn type_default_param(
-            val: &SymbolValue,
-            primitive: &PrimitiveStore,
-            unifier: &mut Unifier,
-        ) -> TypeAnnotation {
-            match val {
-                SymbolValue::Bool(..) => TypeAnnotation::Primitive(primitive.bool),
-                SymbolValue::Double(..) => TypeAnnotation::Primitive(primitive.float),
-                SymbolValue::I32(..) => TypeAnnotation::Primitive(primitive.int32),
-                SymbolValue::I64(..) => TypeAnnotation::Primitive(primitive.int64),
-                SymbolValue::U32(..) => TypeAnnotation::Primitive(primitive.uint32),
-                SymbolValue::U64(..) => TypeAnnotation::Primitive(primitive.uint64),
-                SymbolValue::Str(..) => TypeAnnotation::Primitive(primitive.str),
-                SymbolValue::Tuple(vs) => {
-                    let vs_tys = vs
-                        .iter()
-                        .map(|v| type_default_param(v, primitive, unifier))
-                        .collect::<Vec<_>>();
-                    TypeAnnotation::Tuple(vs_tys)
-                }
-                SymbolValue::OptionNone => TypeAnnotation::CustomClass {
-                    id: primitive.option.get_obj_id(unifier),
-                    params: Default::default(),
-                },
-                SymbolValue::OptionSome(v) => {
-                    let ty = type_default_param(v, primitive, unifier);
-                    TypeAnnotation::CustomClass {
-                        id: primitive.option.get_obj_id(unifier),
-                        params: vec![ty],
-                    }
-                }
-            }
-        }
-
         fn is_compatible(
             found: &TypeAnnotation,
             expect: &TypeAnnotation,
@@ -481,7 +447,7 @@ impl TopLevelComposer {
             }
         }
 
-        let found = type_default_param(val, primitive, unifier);
+        let found = val.get_type_annotation(primitive, unifier);
         if !is_compatible(&found, ty, unifier, primitive) {
             Err(format!(
                 "incompatible default parameter type, expect {}, found {}",

nac3core/src/toplevel/test.rs

@@ -361,7 +361,7 @@ fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&s
                     pass
         "}
     ],
-    vec!["application of type vars to generic class is not currently supported (at unknown: line 4 column 24)"];
+    vec!["application of type vars to generic class is not currently supported (at unknown:4:24)"];
     "err no type var in generic app"
 )]
 #[test_case(
@@ -417,7 +417,7 @@ fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&s
             def __init__():
                 pass
     "}],
-    vec!["__init__ method must have a `self` parameter (at unknown: line 2 column 5)"];
+    vec!["__init__ method must have a `self` parameter (at unknown:2:5)"];
     "err no self_1"
 )]
 #[test_case(
@@ -439,7 +439,7 @@ fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&s
         "}
 
     ],
-    vec!["a class definition can only have at most one base class declaration and one generic declaration (at unknown: line 1 column 24)"];
+    vec!["a class definition can only have at most one base class declaration and one generic declaration (at unknown:1:24)"];
     "err multiple inheritance"
 )]
 #[test_case(
@@ -507,7 +507,7 @@ fn test_simple_function_analyze(source: Vec<&str>, tys: Vec<&str>, names: Vec<&s
                     pass
         "}
     ],
-    vec!["duplicate definition of class `A` (at unknown: line 1 column 1)"];
+    vec!["duplicate definition of class `A` (at unknown:1:1)"];
     "class same name"
 )]
 fn test_analyze(source: Vec<&str>, res: Vec<&str>) {

nac3core/src/toplevel/type_annotation.rs

@@ -1,3 +1,4 @@
+use crate::symbol_resolver::SymbolValue;
 use super::*;
 
 #[derive(Clone, Debug)]
@@ -12,6 +13,16 @@ pub enum TypeAnnotation {
     // can only be CustomClassKind
     Virtual(Box<TypeAnnotation>),
     TypeVar(Type),
+    /// A constant used in the context of a const-generic variable.
+    Constant {
+        /// The non-type variable associated with this constant.
+        ///
+        /// Invoking [Unifier::get_ty] on this type will return a [TypeEnum::TVar] representing the
+        /// const generic variable of which this constant is associated with.
+        ty: Type,
+        /// The constant value of this constant.
+        value: SymbolValue
+    },
     List(Box<TypeAnnotation>),
     Tuple(Vec<TypeAnnotation>),
 }
@@ -47,6 +58,7 @@ impl TypeAnnotation {
                     }
                 )
             }
+            Constant { value, .. } => format!("Const({value})"),
             Virtual(ty) => format!("virtual[{}]", ty.stringify(unifier)),
             List(ty) => format!("list[{}]", ty.stringify(unifier)),
             Tuple(types) => {
@@ -56,6 +68,12 @@ impl TypeAnnotation {
     }
 }
 
+/// Parses an AST expression `expr` into a [TypeAnnotation].
+///
+/// * `locked` - A [HashMap] containing the IDs of known definitions, mapped to a [Vec] of all
+/// generic variables associated with the definition.
+/// * `type_var` - The type variable associated with the type argument currently being parsed. Pass
+/// [None] when this function is invoked externally.
 pub fn parse_ast_to_type_annotation_kinds<T>(
     resolver: &(dyn SymbolResolver + Send + Sync),
     top_level_defs: &[Arc<RwLock<TopLevelDef>>],
@@ -64,6 +82,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
     expr: &ast::Expr<T>,
     // the key stores the type_var of this topleveldef::class, we only need this field here
     locked: HashMap<DefinitionId, Vec<Type>>,
+    type_var: Option<Type>,
 ) -> Result<TypeAnnotation, String> {
     let name_handle = |id: &StrRef,
                        unifier: &mut Unifier,
@@ -127,7 +146,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
          slice: &ast::Expr<T>,
          unifier: &mut Unifier,
          mut locked: HashMap<DefinitionId, Vec<Type>>| {
-            if vec!["virtual".into(), "Generic".into(), "list".into(), "tuple".into()].contains(id)
+            if vec!["virtual".into(), "Generic".into(), "list".into(), "tuple".into(), "Option".into()].contains(id)
             {
                 return Err(format!("keywords cannot be class name (at {})", expr.location));
             }
@@ -161,7 +180,8 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 }
                 let result = params_ast
                     .iter()
-                    .map(|x| {
+                    .enumerate()
+                    .map(|(idx, x)| {
                         parse_ast_to_type_annotation_kinds(
                             resolver,
                             top_level_defs,
@@ -172,6 +192,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                                 locked.insert(obj_id, type_vars.clone());
                                 locked.clone()
                             },
+                            Some(type_vars[idx]),
                         )
                     })
                     .collect::<Result<Vec<_>, _>>()?;
@@ -190,6 +211,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
             };
             Ok(TypeAnnotation::CustomClass { id: obj_id, params: param_type_infos })
         };
+
     match &expr.node {
         ast::ExprKind::Name { id, .. } => name_handle(id, unifier, locked),
         // virtual
@@ -205,6 +227,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 primitives,
                 slice.as_ref(),
                 locked,
+                None,
             )?;
             if !matches!(def, TypeAnnotation::CustomClass { .. }) {
                 unreachable!("must be concretized custom class kind in the virtual")
@@ -225,6 +248,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 primitives,
                 slice.as_ref(),
                 locked,
+                None,
             )?;
             Ok(TypeAnnotation::List(def_ann.into()))
         }
@@ -242,6 +266,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                 primitives,
                 slice.as_ref(),
                 locked,
+                None,
             )?;
             let id =
                 if let TypeEnum::TObj { obj_id, .. } = unifier.get_ty(primitives.option).as_ref() {
@@ -275,6 +300,7 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
                         primitives,
                         e,
                         locked.clone(),
+                        None,
                     )
                 })
                 .collect::<Result<Vec<_>, _>>()?;
@@ -290,6 +316,31 @@ pub fn parse_ast_to_type_annotation_kinds<T>(
             }
         }
 
+        ast::ExprKind::Constant { value, .. } => {
+            let type_var = type_var.expect("Expect type variable to be present");
+
+            let ntv_ty_enum = unifier.get_ty_immutable(type_var);
+            let TypeEnum::TVar { range: underlying_ty, .. } = ntv_ty_enum.as_ref() else {
+                unreachable!()
+            };
+            let underlying_ty = underlying_ty[0];
+
+            let value = SymbolValue::from_constant(value, underlying_ty, primitives, unifier)?;
+
+            if matches!(value, SymbolValue::Str(_) | SymbolValue::Tuple(_) | SymbolValue::OptionSome(_)) {
+                return Err(format!(
+                    "expression {} is not allowed for constant type annotation (at {})",
+                    value.to_string(),
+                    expr.location
+                ))
+            }
+
+            Ok(TypeAnnotation::Constant {
+                ty: type_var,
+                value,
+            })
+        }
+
         _ => Err(format!("unsupported expression for type annotation (at {})", expr.location)),
     }
 }
@@ -308,94 +359,130 @@ pub fn get_type_from_type_annotation_kinds(
         TypeAnnotation::CustomClass { id: obj_id, params } => {
             let def_read = top_level_defs[obj_id.0].read();
             let class_def: &TopLevelDef = def_read.deref();
-            if let TopLevelDef::Class { fields, methods, type_vars, .. } = class_def {
-                if type_vars.len() != params.len() {
-                    Err(format!(
-                        "unexpected number of type parameters: expected {} but got {}",
-                        type_vars.len(),
-                        params.len()
-                    ))
-                } else {
-                    let param_ty = params
-                        .iter()
-                        .map(|x| {
-                            get_type_from_type_annotation_kinds(
-                                top_level_defs,
-                                unifier,
-                                primitives,
-                                x,
-                                subst_list
-                            )
-                        })
-                        .collect::<Result<Vec<_>, _>>()?;
+            let TopLevelDef::Class { fields, methods, type_vars, .. } = class_def else {
+                unreachable!("should be class def here")
+            };
 
-                    let subst = {
-                        // check for compatible range
-                        // TODO: if allow type var to be applied(now this disallowed in the parse_to_type_annotation), need more check
-                        let mut result: HashMap<u32, Type> = HashMap::new();
-                        for (tvar, p) in type_vars.iter().zip(param_ty) {
-                            if let TypeEnum::TVar { id, range, fields: None, name, loc } =
-                                unifier.get_ty(*tvar).as_ref()
-                            {
-                                let ok: bool = {
-                                    // create a temp type var and unify to check compatibility
-                                    p == *tvar || {
-                                        let temp = unifier.get_fresh_var_with_range(
-                                            range.as_slice(),
-                                            *name,
-                                            *loc,
-                                        );
-                                        unifier.unify(temp.0, p).is_ok()
-                                    }
-                                };
-                                if ok {
-                                    result.insert(*id, p);
-                                } else {
-                                    return Err(format!(
-                                        "cannot apply type {} to type variable with id {:?}",
-                                        unifier.internal_stringify(
-                                            p,
-                                            &mut |id| format!("class{}", id),
-                                            &mut |id| format!("typevar{}", id),
-                                            &mut None
-                                        ),
-                                        *id
-                                    ));
+            if type_vars.len() != params.len() {
+                return Err(format!(
+                    "unexpected number of type parameters: expected {} but got {}",
+                    type_vars.len(),
+                    params.len()
+                ))
+            }
+
+            let param_ty = params
+                .iter()
+                .map(|x| {
+                    get_type_from_type_annotation_kinds(
+                        top_level_defs,
+                        unifier,
+                        primitives,
+                        x,
+                        subst_list
+                    )
+                })
+                .collect::<Result<Vec<_>, _>>()?;
+
+            let subst = {
+                // check for compatible range
+                // TODO: if allow type var to be applied(now this disallowed in the parse_to_type_annotation), need more check
+                let mut result: HashMap<u32, Type> = HashMap::new();
+                for (tvar, p) in type_vars.iter().zip(param_ty) {
+                    match unifier.get_ty(*tvar).as_ref() {
+                        TypeEnum::TVar { id, range, fields: None, name, loc, is_const_generic: false } => {
+                            let ok: bool = {
+                                // create a temp type var and unify to check compatibility
+                                p == *tvar || {
+                                    let temp = unifier.get_fresh_var_with_range(
+                                        range.as_slice(),
+                                        *name,
+                                        *loc,
+                                    );
+                                    unifier.unify(temp.0, p).is_ok()
                                 }
+                            };
+                            if ok {
+                                result.insert(*id, p);
                             } else {
-                                unreachable!("must be generic type var")
+                                return Err(format!(
+                                    "cannot apply type {} to type variable with id {:?}",
+                                    unifier.internal_stringify(
+                                        p,
+                                        &mut |id| format!("class{}", id),
+                                        &mut |id| format!("typevar{}", id),
+                                        &mut None
+                                    ),
+                                    *id
+                                ));
                             }
                         }
-                        result
-                    };
-                    let mut tobj_fields = methods
-                        .iter()
-                        .map(|(name, ty, _)| {
-                            let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty);
-                            // methods are immutable
-                            (*name, (subst_ty, false))
-                        })
-                        .collect::<HashMap<_, _>>();
-                    tobj_fields.extend(fields.iter().map(|(name, ty, mutability)| {
-                        let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty);
-                        (*name, (subst_ty, *mutability))
-                    }));
-                    let need_subst = !subst.is_empty();
-                    let ty = unifier.add_ty(TypeEnum::TObj {
-                        obj_id: *obj_id,
-                        fields: tobj_fields,
-                        params: subst,
-                    });
-                    if need_subst {
-                        subst_list.as_mut().map(|wl| wl.push(ty));
+
+                        TypeEnum::TVar { id, range, name, loc, is_const_generic: true, .. } => {
+                            let ty = range[0];
+                            let ok: bool = {
+                                // create a temp type var and unify to check compatibility
+                                p == *tvar || {
+                                    let temp = unifier.get_fresh_const_generic_var(
+                                        ty,
+                                        *name,
+                                        *loc,
+                                    );
+                                    unifier.unify(temp.0, p).is_ok()
+                                }
+                            };
+                            if ok {
+                                result.insert(*id, p);
+                            } else {
+                                return Err(format!(
+                                    "cannot apply type {} to type variable {}",
+                                    unifier.stringify(p),
+                                    name.unwrap_or_else(|| format!("typevar{id}").into()),
+                                ))
+                            }
+                        }
+
+                        _ => unreachable!("must be generic type var"),
                     }
-                    Ok(ty)
                 }
-            } else {
-                unreachable!("should be class def here")
+                result
+            };
+            let mut tobj_fields = methods
+                .iter()
+                .map(|(name, ty, _)| {
+                    let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty);
+                    // methods are immutable
+                    (*name, (subst_ty, false))
+                })
+                .collect::<HashMap<_, _>>();
+            tobj_fields.extend(fields.iter().map(|(name, ty, mutability)| {
+                let subst_ty = unifier.subst(*ty, &subst).unwrap_or(*ty);
+                (*name, (subst_ty, *mutability))
+            }));
+            let need_subst = !subst.is_empty();
+            let ty = unifier.add_ty(TypeEnum::TObj {
+                obj_id: *obj_id,
+                fields: tobj_fields,
+                params: subst,
+            });
+            if need_subst {
+                subst_list.as_mut().map(|wl| wl.push(ty));
             }
+            Ok(ty)
         }
         TypeAnnotation::Primitive(ty) | TypeAnnotation::TypeVar(ty) => Ok(*ty),
+        TypeAnnotation::Constant { ty, value, .. } => {
+            let ty_enum = unifier.get_ty(*ty);
+            let (ty, loc) = match &*ty_enum {
+                TypeEnum::TVar { range: ntv_underlying_ty, loc, is_const_generic: true, .. } => {
+                    (ntv_underlying_ty[0], loc)
+                }
+                _ => unreachable!("{} ({})", unifier.stringify(*ty), ty_enum.get_type_name()),
+            };
+
+            let var = unifier.get_fresh_constant(value.clone(), ty, *loc);
+            Ok(var)
+        }
         TypeAnnotation::Virtual(ty) => {
             let ty = get_type_from_type_annotation_kinds(
                 top_level_defs,
@@ -470,7 +557,7 @@ pub fn get_type_var_contained_in_type_annotation(ann: &TypeAnnotation) -> Vec<Ty
                 result.extend(get_type_var_contained_in_type_annotation(a));
             }
         }
-        TypeAnnotation::Primitive(..) => {}
+        TypeAnnotation::Primitive(..) | TypeAnnotation::Constant { .. } => {}
     }
     result
 }

nac3core/src/typecheck/function_check.rs

@@ -62,7 +62,7 @@ impl<'a> Inferencer<'a> {
     ) -> Result<(), String> {
         // there are some cases where the custom field is None
         if let Some(ty) = &expr.custom {
-            if !self.unifier.is_concrete(*ty, &self.function_data.bound_variables) {
+            if !matches!(&expr.node, ExprKind::Constant { value: Constant::Ellipsis, .. }) && !self.unifier.is_concrete(*ty, &self.function_data.bound_variables) {
                 return Err(format!(
                     "expected concrete type at {} but got {}",
                     expr.location,

nac3core/src/typecheck/type_inferencer/mod.rs

@@ -964,6 +964,7 @@ impl<'a> Inferencer<'a> {
             ast::Constant::Str(_) => Ok(self.primitives.str),
             ast::Constant::None
                 => report_error("CPython `None` not supported (nac3 uses `none` instead)", *loc),
+            ast::Constant::Ellipsis => Ok(self.unifier.get_fresh_var(None, None).0),
             _ => report_error("not supported", *loc),
         }
     }

nac3core/src/typecheck/typedef/mod.rs

@@ -134,6 +134,17 @@ pub enum TypeEnum {
         range: Vec<Type>,
         name: Option<StrRef>,
         loc: Option<Location>,
+        /// Whether this type variable refers to a const-generic variable.
+        is_const_generic: bool,
+    },
+
+    /// A constant for substitution into a const generic variable.
+    TConstant {
+        /// The value of the constant.
+        value: SymbolValue,
+        /// The underlying type of the value.
+        ty: Type,
+        loc: Option<Location>,
     },
 
     /// A tuple type.
@@ -178,6 +189,7 @@ impl TypeEnum {
         match self {
             TypeEnum::TRigidVar { .. } => "TRigidVar",
             TypeEnum::TVar { .. } => "TVar",
+            TypeEnum::TConstant { .. } => "TConstant",
             TypeEnum::TTuple { .. } => "TTuple",
             TypeEnum::TList { .. } => "TList",
             TypeEnum::TObj { .. } => "TObj",
@@ -263,6 +275,7 @@ impl Unifier {
             fields: Some(fields),
             name: None,
             loc: None,
+            is_const_generic: false,
         })
     }
 
@@ -336,7 +349,33 @@ impl Unifier {
         let id = self.var_id + 1;
         self.var_id += 1;
         let range = range.to_vec();
-        (self.add_ty(TypeEnum::TVar { id, range, fields: None, name, loc }), id)
+        (self.add_ty(TypeEnum::TVar { id, range, fields: None, name, loc, is_const_generic: false }), id)
+    }
+
+    /// Returns a fresh type representing a constant generic variable with the given underlying type
+    /// `ty`.
+    pub fn get_fresh_const_generic_var(
+        &mut self,
+        ty: Type,
+        name: Option<StrRef>,
+        loc: Option<Location>,
+    ) -> (Type, u32) {
+        let id = self.var_id + 1;
+        self.var_id += 1;
+        (self.add_ty(TypeEnum::TVar { id, range: vec![ty], fields: None, name, loc, is_const_generic: true }), id)
+    }
+
+    /// Returns a fresh type representing a [fresh constant][TypeEnum::TConstant] with the given
+    /// `value` and type `ty`.
+    pub fn get_fresh_constant(
+        &mut self,
+        value: SymbolValue,
+        ty: Type,
+        loc: Option<Location>,
+    ) -> Type {
+        assert!(matches!(self.get_ty(ty).as_ref(), TypeEnum::TObj { .. }));
+
+        self.add_ty(TypeEnum::TConstant { ty, value, loc })
     }
 
     /// Unification would not unify rigid variables with other types, but we want to do this for
@@ -412,7 +451,7 @@ impl Unifier {
     pub fn is_concrete(&mut self, a: Type, allowed_typevars: &[Type]) -> bool {
         use TypeEnum::*;
         match &*self.get_ty(a) {
-            TRigidVar { .. } => true,
+            TRigidVar { .. } | TConstant { .. } => true,
             TVar { .. } => allowed_typevars.iter().any(|b| self.unification_table.unioned(a, *b)),
             TCall { .. } => false,
             TList { ty } => self.is_concrete(*ty, allowed_typevars),
@@ -560,8 +599,8 @@ impl Unifier {
         };
         match (&*ty_a, &*ty_b) {
             (
-                TVar { fields: fields1, id, name: name1, loc: loc1, .. },
-                TVar { fields: fields2, id: id2, name: name2, loc: loc2, .. },
+                TVar { fields: fields1, id, name: name1, loc: loc1, is_const_generic: false, .. },
+                TVar { fields: fields2, id: id2, name: name2, loc: loc2, is_const_generic: false, .. },
             ) => {
                 let new_fields = match (fields1, fields2) {
                     (None, None) => None,
@@ -616,10 +655,11 @@ impl Unifier {
                         range,
                         name: name1.or(*name2),
                         loc: loc1.or(*loc2),
+                        is_const_generic: false,
                     }),
                 );
             }
-            (TVar { fields: None, range, .. }, _) => {
+            (TVar { fields: None, range, is_const_generic: false, .. }, _) => {
                 // We check for the range of the type variable to see if unification is allowed.
                 // Note that although b may be compatible with a, we may have to constrain type
                 // variables in b to make sure that instantiations of b would always be compatible
@@ -636,7 +676,7 @@ impl Unifier {
                 self.unify_impl(x, b, false)?;
                 self.set_a_to_b(a, x);
             }
-            (TVar { fields: Some(fields), range, .. }, TTuple { ty }) => {
+            (TVar { fields: Some(fields), range, is_const_generic: false, .. }, TTuple { ty }) => {
                 let len = ty.len() as i32;
                 for (k, v) in fields.iter() {
                     match *k {
@@ -666,7 +706,7 @@ impl Unifier {
                 self.unify_impl(x, b, false)?;
                 self.set_a_to_b(a, x);
             }
-            (TVar { fields: Some(fields), range, .. }, TList { ty }) => {
+            (TVar { fields: Some(fields), range, is_const_generic: false, .. }, TList { ty }) => {
                 for (k, v) in fields.iter() {
                     match *k {
                         RecordKey::Int(_) => {
@@ -681,6 +721,35 @@ impl Unifier {
                 self.unify_impl(x, b, false)?;
                 self.set_a_to_b(a, x);
             }
+
+            (TVar { id: id1, range: ty1, is_const_generic: true, .. }, TVar { id: id2, range: ty2, .. }) => {
+                let ty1 = ty1[0];
+                let ty2 = ty2[0];
+
+                if id1 != id2 {
+                    self.unify_impl(ty1, ty2, false)?;
+                }
+
+                self.set_a_to_b(a, b);
+            }
+
+            (TVar { range: ty1, is_const_generic: true, .. }, TConstant { ty: ty2, .. }) => {
+                let ty1 = ty1[0];
+
+                self.unify_impl(ty1, *ty2, false)?;
+                self.set_a_to_b(a, b);
+            }
+
+            (TConstant { value: val1, ty: ty1, .. }, TConstant { value: val2, ty: ty2, .. }) => {
+                if val1 != val2 {
+                    eprintln!("VALUE MISMATCH: lhs={val1:?} rhs={val2:?} eq={}", val1 == val2);
+                    return self.incompatible_types(a, b)
+                }
+                self.unify_impl(*ty1, *ty2, false)?;
+
+                self.set_a_to_b(a, b);
+            }
+
             (TTuple { ty: ty1 }, TTuple { ty: ty2 }) => {
                 if ty1.len() != ty2.len() {
                     return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
@@ -775,7 +844,14 @@ impl Unifier {
                 if id1 != id2 {
                     self.incompatible_types(a, b)?;
                 }
-                for (x, y) in zip(params1.values(), params2.values()) {
+
+                // Sort the type arguments by its UnificationKey first, since `HashMap::iter` visits
+                // all K-V pairs "in arbitrary order"
+                let (tv1, tv2) = (
+                    params1.iter().sorted_by_key(|(k, _)| *k).map(|(_, v)| v).collect_vec(),
+                    params2.iter().sorted_by_key(|(k, _)| *k).map(|(_, v)| v).collect_vec(),
+                );
+                for (x, y) in zip(tv1, tv2) {
                     if self.unify_impl(*x, *y, false).is_err() {
                         return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
                     };
@@ -928,6 +1004,9 @@ impl Unifier {
                 };
                 n
             }
+            TypeEnum::TConstant { value, .. } => {
+                format!("const({value})")
+            }
             TypeEnum::TTuple { ty } => {
                 let mut fields =
                     ty.iter().map(|v| self.internal_stringify(*v, obj_to_name, var_to_name, notes));
@@ -983,8 +1062,8 @@ impl Unifier {
         }
     }
 
+    /// Unifies `a` and `b` together, and set the value to the value of `b`.
     fn set_a_to_b(&mut self, a: Type, b: Type) {
-        // unify a and b together, and set the value to b's value.
         let table = &mut self.unification_table;
         let ty_b = table.probe_value(b).clone();
         table.unify(a, b);
@@ -1207,6 +1286,7 @@ impl Unifier {
                             range,
                             name: name2.or(*name),
                             loc: loc2.or(*loc),
+                            is_const_generic: false,
                         };
                         Ok(Some(self.unification_table.new_key(ty.into())))
                     }

nac3standalone/demo/interpret_demo.py

@@ -9,7 +9,7 @@ import pathlib
 
 from numpy import int32, int64, uint32, uint64
 from scipy import special
-from typing import TypeVar, Generic
+from typing import TypeVar, Generic, Any
 
 T = TypeVar('T')
 class Option(Generic[T]):
@@ -44,6 +44,12 @@ def Some(v: T) -> Option[T]:
 
 none = Option(None)
 
+class _ConstGenericDummy:
+    pass
+
+def ConstGeneric(name, constraint):
+    return TypeVar(name, _ConstGenericDummy, constraint)
+
 def round_away_zero(x):
     if x >= 0.0:
         return math.floor(x + 0.5)
@@ -99,6 +105,7 @@ def patch(module):
     module.uint32 = uint32
     module.uint64 = uint64
     module.TypeVar = TypeVar
+    module.ConstGeneric = ConstGeneric
     module.Generic = Generic
     module.extern = extern
     module.Option = Option

nac3standalone/demo/src/const_generic.py

@@ -0,0 +1,50 @@
+A = ConstGeneric("A", int32)
+B = ConstGeneric("B", uint32)
+T = TypeVar("T")
+
+class ConstGenericClass(Generic[A]):
+    def __init__(self):
+        pass
+
+class ConstGeneric2Class(Generic[A, B]):
+    def __init__(self):
+        pass
+
+class HybridGenericClass2(Generic[A, T]):
+    pass
+
+class HybridGenericClass3(Generic[T, A, B]):
+    pass
+
+def make_generic_2() -> ConstGenericClass[2]:
+    return ...
+
+def make_generic2_1_2() -> ConstGeneric2Class[1, 2]:
+    return ...
+
+def make_hybrid_class_2_int32() -> HybridGenericClass2[2, int32]:
+    return ...
+
+def make_hybrid_class_i32_0_1() -> HybridGenericClass3[int32, 0, 1]:
+    return ...
+
+def consume_generic_2(instance: ConstGenericClass[2]):
+    pass
+
+def consume_generic2_1_2(instance: ConstGeneric2Class[1, 2]):
+    pass
+
+def consume_hybrid_class_2_i32(instance: HybridGenericClass2[2, int32]):
+    pass
+
+def consume_hybrid_class_i32_0_1(instance: HybridGenericClass3[int32, 0, 1]):
+    pass
+
+def f():
+    consume_generic_2(make_generic_2())
+    consume_generic2_1_2(make_generic2_1_2())
+    consume_hybrid_class_2_i32(make_hybrid_class_2_int32())
+    consume_hybrid_class_i32_0_1(make_hybrid_class_i32_0_1())
+
+def run() -> int32:
+    return 0

nac3standalone/demo/src/type_annotations.py

@@ -0,0 +1,26 @@
+def run() -> int32:
+    # Numeric Primitives
+    b: bool = False
+    i32: int32 = 0
+    i64: int64 = int64(0)
+    u32: uint32 = uint32(0)
+    u64: uint64 = uint64(0)
+    f64: float = 0.0
+
+    # String
+    s: str = ""
+
+    # List
+    l_i32: list[int32] = []
+    l_f64: list[float] = []
+    l_str: list[str] = []
+
+    # Option
+    o_some: Option[int32] = Some(0)
+    o_none: Option[int32] = none
+
+    # Tuple
+    t_i32_i32: tuple[int32, int32] = (0, 0)
+    t_i32_f64: tuple[int32, float] = (0, 0.0)
+
+    return 0

nac3standalone/src/main.rs

@@ -25,7 +25,7 @@ use nac3core::{
     },
 };
 use nac3parser::{
-    ast::{Expr, ExprKind, StmtKind},
+    ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
     parser,
 };
 
@@ -74,8 +74,20 @@ fn handle_typevar_definition(
     unifier: &mut Unifier,
     primitives: &PrimitiveStore,
 ) -> Result<Type, String> {
-    if let ExprKind::Call { func, args, .. } = &var.node {
-        if matches!(&func.node, ExprKind::Name { id, .. } if id == &"TypeVar".into()) {
+    let ExprKind::Call { func, args, .. } = &var.node else {
+        return Err(format!(
+            "expression {:?} cannot be handled as a generic parameter in global scope",
+            var
+        ))
+    };
+
+    match &func.node {
+        ExprKind::Name { id, .. } if id == &"TypeVar".into() => {
+            let ExprKind::Constant { value: Constant::Str(ty_name), .. } = &args[0].node else {
+                unreachable!("Expected string constant for first parameter of `TypeVar`, got {:?}", &args[0].node)
+            };
+            let generic_name: StrRef = ty_name.to_string().into();
+
             let constraints = args
                 .iter()
                 .skip(1)
@@ -87,22 +99,54 @@ fn handle_typevar_definition(
                         primitives,
                         x,
                         Default::default(),
+                        None,
                     )?;
                     get_type_from_type_annotation_kinds(
                         def_list, unifier, primitives, &ty, &mut None
                     )
                 })
                 .collect::<Result<Vec<_>, _>>()?;
-            Ok(unifier.get_fresh_var_with_range(&constraints, None, None).0)
-        } else {
-            Err(format!(
-                "expression {:?} cannot be handled as a TypeVar in global scope",
-                var
-            ))
+            let loc = func.location;
+
+            if constraints.len() == 1 {
+                return Err(format!("A single constraint is not allowed (at {})", loc))
+            }
+
+            Ok(unifier.get_fresh_var_with_range(&constraints, Some(generic_name), Some(loc)).0)
         }
-    } else {
-        Err(format!(
-            "expression {:?} cannot be handled as a TypeVar in global scope",
+
+        ExprKind::Name { id, .. } if id == &"ConstGeneric".into() => {
+            if args.len() != 2 {
+                return Err(format!("Expected 2 arguments for `ConstGeneric`, got {}", args.len()))
+            }
+
+            let ExprKind::Constant { value: Constant::Str(ty_name), .. } = &args[0].node else {
+                return Err(format!(
+                    "Expected string constant for first parameter of `ConstGeneric`, got {:?}",
+                    &args[0].node
+                ))
+            };
+            let generic_name: StrRef = ty_name.to_string().into();
+
+            let ty = parse_ast_to_type_annotation_kinds(
+                resolver,
+                def_list,
+                unifier,
+                primitives,
+                &args[1],
+                Default::default(),
+                None,
+            )?;
+            let constraint = get_type_from_type_annotation_kinds(
+                def_list, unifier, primitives, &ty, &mut None
+            )?;
+            let loc = func.location;
+
+            Ok(unifier.get_fresh_const_generic_var(constraint, Some(generic_name), Some(loc)).0)
+        }
+
+        _ => Err(format!(
+            "expression {:?} cannot be handled as a generic parameter in global scope",
             var
         ))
     }
@@ -135,7 +179,7 @@ fn handle_assignment_pattern(
                     internal_resolver.add_module_global(*id, val);
                     Ok(())
                 } else {
-                    Err(format!("fails to evaluate this expression `{:?}` as a constant or TypeVar at {}",
+                    Err(format!("fails to evaluate this expression `{:?}` as a constant or generic parameter at {}",
                         targets[0].node,
                         targets[0].location,
                     ))