nac3core/Cargo.toml

@@ -14,8 +14,8 @@ indexmap = "2.2"
 parking_lot = "0.12"
 rayon = "1.8"
 nac3parser = { path = "../nac3parser" }
-strum = "0.26"
-strum_macros = "0.26"
+strum = "0.26.2"
+strum_macros = "0.26.4"
 
 [dependencies.inkwell]
 version = "0.4"

nac3core/src/codegen/expr.rs

@@ -9,7 +9,7 @@ use crate::{
         irrt::*,
         llvm_intrinsics::{
             call_expect, call_float_floor, call_float_pow, call_float_powi, call_int_smax,
-            call_int_umin, call_memcpy_generic,
+            call_memcpy_generic,
         },
         need_sret, numpy,
         stmt::{
@@ -40,7 +40,6 @@ use nac3parser::ast::{
     self, Boolop, Cmpop, Comprehension, Constant, Expr, ExprKind, Location, Operator, StrRef,
     Unaryop,
 };
-use std::cmp::min;
 use std::iter::{repeat, repeat_with};
 use std::{collections::HashMap, convert::TryInto, iter::once, iter::zip};
 
@@ -2025,115 +2024,6 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                     _ => unreachable!(),
                 };
                 ctx.builder.build_float_compare(op, lhs, rhs, "cmp").unwrap()
-            } else if left_ty == ctx.primitives.str {
-                assert!(ctx.unifier.unioned(left_ty, right_ty));
-
-                let llvm_i1 = ctx.ctx.bool_type();
-                let llvm_i32 = ctx.ctx.i32_type();
-                let llvm_usize = generator.get_size_type(ctx.ctx);
-
-                let lhs = lhs.into_struct_value();
-                let rhs = rhs.into_struct_value();
-
-                let plhs = generator.gen_var_alloc(ctx, lhs.get_type().into(), None).unwrap();
-                ctx.builder.build_store(plhs, lhs).unwrap();
-                let prhs = generator.gen_var_alloc(ctx, lhs.get_type().into(), None).unwrap();
-                ctx.builder.build_store(prhs, rhs).unwrap();
-
-                let lhs_len = ctx.build_in_bounds_gep_and_load(
-                    plhs,
-                    &[llvm_i32.const_zero(), llvm_i32.const_int(1, false)],
-                    None,
-                ).into_int_value();
-                let rhs_len = ctx.build_in_bounds_gep_and_load(
-                    prhs,
-                    &[llvm_i32.const_zero(), llvm_i32.const_int(1, false)],
-                    None,
-                ).into_int_value();
-
-                let len = call_int_umin(ctx, lhs_len, rhs_len, None);
-
-                let current_bb = ctx.builder.get_insert_block().unwrap();
-                let post_foreach_cmp = ctx.ctx.insert_basic_block_after(current_bb, "foreach.cmp.end");
-
-                ctx.builder.position_at_end(post_foreach_cmp);
-                let cmp_phi = ctx.builder.build_phi(llvm_i1, "").unwrap();
-                ctx.builder.position_at_end(current_bb);
-
-                gen_for_callback_incrementing(
-                    generator,
-                    ctx,
-                    None,
-                    llvm_usize.const_zero(),
-                    (len, false),
-                    |generator, ctx, _, i| {
-                        let lhs_char = {
-                            let plhs_data = ctx.build_in_bounds_gep_and_load(
-                                plhs,
-                                &[llvm_i32.const_zero(), llvm_i32.const_zero()],
-                                None,
-                            ).into_pointer_value();
-
-                            ctx.build_in_bounds_gep_and_load(
-                                plhs_data,
-                                &[i],
-                                None
-                            ).into_int_value()
-                        };
-                        let rhs_char = {
-                            let prhs_data = ctx.build_in_bounds_gep_and_load(
-                                prhs,
-                                &[llvm_i32.const_zero(), llvm_i32.const_zero()],
-                                None,
-                            ).into_pointer_value();
-
-                            ctx.build_in_bounds_gep_and_load(
-                                prhs_data,
-                                &[i],
-                                None
-                            ).into_int_value()
-                        };
-
-                        gen_if_callback(
-                            generator,
-                            ctx,
-                            |_, ctx| {
-                                Ok(ctx.builder.build_int_compare(IntPredicate::NE, lhs_char, rhs_char, "").unwrap())
-                            },
-                            |_, ctx| {
-                                let bb = ctx.builder.get_insert_block().unwrap();
-                                cmp_phi.add_incoming(&[(&llvm_i1.const_zero(), bb)]);
-                                ctx.builder.build_unconditional_branch(post_foreach_cmp).unwrap();
-
-                                Ok(())
-                            },
-                            |_, _| Ok(()),
-                        )?;
-
-                        Ok(())
-                    },
-                    llvm_usize.const_int(1, false),
-                )?;
-
-                let bb = ctx.builder.get_insert_block().unwrap();
-                let is_len_eq = ctx.builder.build_int_compare(
-                    IntPredicate::EQ,
-                    lhs_len,
-                    rhs_len,
-                    "",
-                ).unwrap();
-                cmp_phi.add_incoming(&[(&is_len_eq, bb)]);
-                ctx.builder.build_unconditional_branch(post_foreach_cmp).unwrap();
-
-                ctx.builder.position_at_end(post_foreach_cmp);
-                let cmp_phi = cmp_phi.as_basic_value().into_int_value();
-
-                // Invert the final value if __ne__
-                if *op == Cmpop::NotEq {
-                    ctx.builder.build_not(cmp_phi, "").unwrap()
-                } else {
-                    cmp_phi
-                }
             } else if [left_ty, right_ty]
                 .iter()
                 .any(|ty| ty.obj_id(&ctx.unifier).is_some_and(|id| id == PrimDef::List.id()))
@@ -2304,121 +2194,8 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                 };
 
                 gen_list_cmpop(generator, ctx)?
-            } else if [left_ty, right_ty].iter().any(|ty| matches!(&*ctx.unifier.get_ty_immutable(*ty), TypeEnum::TTuple { .. })) {
-                let TypeEnum::TTuple { ty: left_tys, .. } = &*ctx.unifier.get_ty_immutable(left_ty) else {
-                    return Err(format!("'{}' not supported between instances of '{}' and '{}'", op.op_info().symbol, ctx.unifier.stringify(left_ty), ctx.unifier.stringify(right_ty)))
-                };
-                let TypeEnum::TTuple { ty: right_tys, .. } = &*ctx.unifier.get_ty_immutable(right_ty) else {
-                    return Err(format!("'{}' not supported between instances of '{}' and '{}'", op.op_info().symbol, ctx.unifier.stringify(left_ty), ctx.unifier.stringify(right_ty)))
-                };
-
-                if ![Cmpop::Eq, Cmpop::NotEq].contains(op) {
-                    todo!("Only __eq__ and __ne__ is implemented for tuples")
-                }
-
-                let llvm_i1 = ctx.ctx.bool_type();
-                let llvm_i32 = ctx.ctx.i32_type();
-
-                // Assume `true` by default
-                let cmp_addr = generator.gen_var_alloc(ctx, llvm_i1.into(), None).unwrap();
-                ctx.builder.build_store(cmp_addr, llvm_i1.const_all_ones()).unwrap();
-
-                let current_bb = ctx.builder.get_insert_block().unwrap();
-                let post_foreach_cmp = ctx.ctx.insert_basic_block_after(current_bb, "foreach.cmp.end");
-
-                ctx.builder.position_at_end(post_foreach_cmp);
-                let cmp_phi = ctx.builder.build_phi(llvm_i1, "").unwrap();
-                ctx.builder.position_at_end(current_bb);
-
-                // Generate comparison between each element
-                let min_len = min(left_tys.len(), right_tys.len());
-                for i in 0..min_len {
-                    let current_bb = ctx.builder.get_insert_block().unwrap();
-                    let bb = ctx.ctx.insert_basic_block_after(current_bb, &format!("foreach.cmp.tuple.{i}e"));
-                    ctx.builder.build_unconditional_branch(bb).unwrap();
-
-                    ctx.builder.position_at_end(bb);
-                    let left_ty = left_tys[i];
-                    let left_elem = {
-                        let plhs = generator.gen_var_alloc(ctx, lhs.get_type(), None).unwrap();
-                        ctx.builder.build_store(plhs, *lhs).unwrap();
-
-                        ctx.build_in_bounds_gep_and_load(
-                            plhs,
-                            &[llvm_i32.const_zero(), llvm_i32.const_int(i as u64, false)],
-                            None,
-                        )
-                    };
-                    let right_ty = right_tys[i];
-                    let right_elem = {
-                        let prhs = generator.gen_var_alloc(ctx, rhs.get_type(), None).unwrap();
-                        ctx.builder.build_store(prhs, *rhs).unwrap();
-
-                        ctx.build_in_bounds_gep_and_load(
-                            prhs,
-                            &[llvm_i32.const_zero(), llvm_i32.const_int(i as u64, false)],
-                            None,
-                        )
-                    };
-
-                    gen_if_callback(
-                        generator,
-                        ctx,
-                        |generator, ctx| {
-                            // Defer the `not` operation until the end - a != b <=> !(a == b)
-                            let op = if *op == Cmpop::NotEq { Cmpop::Eq } else { *op };
-
-                            let cmp = gen_cmpop_expr_with_values(
-                                generator,
-                                ctx,
-                                (Some(left_ty), left_elem),
-                                &[op],
-                                &[(Some(right_ty), right_elem)],
-                            )
-                                .transpose()
-                                .unwrap()
-                                .and_then(|v| {
-                                    v.to_basic_value_enum(ctx, generator, ctx.primitives.bool)
-                                })
-                                .map(BasicValueEnum::into_int_value)?;
-
-                            Ok(ctx.builder.build_not(cmp, "").unwrap())
-                        },
-                        |_, ctx| {
-                            let bb = ctx.builder.get_insert_block().unwrap();
-                            cmp_phi.add_incoming(&[(&llvm_i1.const_zero(), bb)]);
-                            ctx.builder.build_unconditional_branch(post_foreach_cmp).unwrap();
-
-                            Ok(())
-                        },
-                        |_, _| Ok(()),
-                    )?;
-                }
-
-                // Length of tuples is checked last as operators do not short-circuit by tuple
-                // length in Python:
-                //
-                // >>> (1, 2) < ("a",)
-                // TypeError: '<' not supported between instances of 'int' and 'str'
-                let bb = ctx.builder.get_insert_block().unwrap();
-                let is_len_eq = llvm_i1.const_int(
-                    u64::from(left_tys.len() == right_tys.len()),
-                    false,
-                );
-                cmp_phi.add_incoming(&[(&is_len_eq, bb)]);
-                ctx.builder.build_unconditional_branch(post_foreach_cmp).unwrap();
-
-                ctx.builder.position_at_end(post_foreach_cmp);
-                let cmp_phi = cmp_phi.as_basic_value().into_int_value();
-
-                // Invert the final value if __ne__
-                if *op == Cmpop::NotEq {
-                    ctx.builder.build_not(cmp_phi, "").unwrap()
-                } else {
-                    cmp_phi
-                }
             } else if [left_ty, right_ty].iter().any(|ty| matches!(&*ctx.unifier.get_ty_immutable(*ty), TypeEnum::TVar { .. })) {
-                if ctx.registry.llvm_options.opt_level == OptimizationLevel::None {
+                if ctx.registry.llvm_options.opt_level != OptimizationLevel::None {
                     ctx.make_assert(
                         generator,
                         ctx.ctx.bool_type().const_all_ones(),
@@ -2431,10 +2208,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
 
                 ctx.ctx.bool_type().get_poison()
             } else {
-                return Err(format!("'{}' not supported between instances of '{}' and '{}'",
-                                   op.op_info().symbol,
-                                   ctx.unifier.stringify(left_ty),
-                                   ctx.unifier.stringify(right_ty)))
+                unimplemented!()
             };
 
             Ok(prev?.map(|v| ctx.builder.build_and(v, current, "cmp").unwrap()).or(Some(current)))

nac3core/src/codegen/mod.rs

@@ -580,11 +580,11 @@ fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
 ) -> BasicTypeEnum<'ctx> {
     // If the type is used in the definition of a function, return `i1` instead of `i8` for ABI
     // consistency.
-    if unifier.unioned(ty, primitives.bool) {
+    return if unifier.unioned(ty, primitives.bool) {
         ctx.bool_type().into()
     } else {
         get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, ty)
-    }
+    };
 }
 
 /// Whether `sret` is needed for a return value with type `ty`.

nac3core/src/typecheck/magic_methods.rs

@@ -680,7 +680,6 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
         bool: bool_t,
         uint32: uint32_t,
         uint64: uint64_t,
-        str: str_t,
         list: list_t,
         ndarray: ndarray_t,
         ..
@@ -726,9 +725,6 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
     impl_sign(unifier, store, bool_t, Some(int32_t));
     impl_eq(unifier, store, bool_t, &[bool_t, ndarray_bool_t], None);
 
-    /* str ========= */
-    impl_cmpop(unifier, store, str_t, &[str_t], &[Cmpop::Eq, Cmpop::NotEq], Some(bool_t));
-
     /* list ======== */
     impl_binop(unifier, store, list_t, &[list_t], Some(list_t), &[Operator::Add]);
     impl_binop(unifier, store, list_t, &[int32_t, int64_t], Some(list_t), &[Operator::Mult]);

nac3core/src/typecheck/typedef/mod.rs

@@ -1,11 +1,3 @@
-use super::magic_methods::{Binop, HasOpInfo};
-use super::type_error::{TypeError, TypeErrorKind};
-use super::unification_table::{UnificationKey, UnificationTable};
-use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
-use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
-use crate::typecheck::magic_methods::OpInfo;
-use crate::typecheck::type_inferencer::PrimitiveStore;
 use indexmap::IndexMap;
 use itertools::{repeat_n, Itertools};
 use nac3parser::ast::{Cmpop, Location, StrRef, Unaryop};
@@ -17,6 +9,15 @@ use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::{borrow::Cow, collections::HashSet};
 
+use super::magic_methods::Binop;
+use super::type_error::{TypeError, TypeErrorKind};
+use super::unification_table::{UnificationKey, UnificationTable};
+use crate::symbol_resolver::SymbolValue;
+use crate::toplevel::helper::PrimDef;
+use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
+use crate::typecheck::magic_methods::OpInfo;
+use crate::typecheck::type_inferencer::PrimitiveStore;
+
 #[cfg(test)]
 mod test;
 
@@ -1007,18 +1008,8 @@ impl Unifier {
                             self.unify_impl(v.ty, ty[ind as usize], false)
                                 .map_err(|e| e.at(v.loc))?;
                         }
-                        RecordKey::Str(s) => {
-                            let tuple_fns = [
-                                Cmpop::Eq.op_info().method_name,
-                                Cmpop::NotEq.op_info().method_name,
-                            ];
-
-                            if !tuple_fns.into_iter().any(|op| s.to_string() == op) {
-                                return Err(TypeError::new(
-                                    TypeErrorKind::NoSuchField(*k, b),
-                                    v.loc,
-                                ));
-                            }
+                        RecordKey::Str(_) => {
+                            return Err(TypeError::new(TypeErrorKind::NoSuchField(*k, b), v.loc))
                         }
                     }
                 }

nac3standalone/demo/src/str.py

@@ -1,30 +0,0 @@
-@extern
-def output_bool(x: bool):
-    ...
-
-
-def str_eq():
-    output_bool("" == "")
-    output_bool("a" == "")
-    output_bool("a" == "b")
-    output_bool("b" == "a")
-    output_bool("a" == "a")
-    output_bool("test string" == "test string")
-    output_bool("test string1" == "test string2")
-
-
-def str_ne():
-    output_bool("" != "")
-    output_bool("a" != "")
-    output_bool("a" != "b")
-    output_bool("b" != "a")
-    output_bool("a" != "a")
-    output_bool("test string" != "test string")
-    output_bool("test string1" != "test string2")
-
-
-def run() -> int32:
-    str_eq()
-    str_ne()
-
-    return 0

nac3standalone/demo/src/tuple.py

@@ -1,7 +1,3 @@
-@extern
-def output_bool(b: bool):
-    ...
-
 @extern
 def output_int32_list(x: list[int32]):
     ...
@@ -17,41 +13,6 @@ class A:
         self.a = a
         self.b = b
 
-
-def test_tuple_eq():
-    # 0-len
-    output_bool(() == ())
-    # 1-len
-    output_bool((1,) == ())
-    output_bool(() == (1,))
-    output_bool((1,) == (1,))
-    output_bool((1,) == (2,))
-    # # 2-len
-    output_bool((1, 2) == ())
-    output_bool(() == (1, 2))
-    output_bool((1,) == (1, 2))
-    output_bool((1, 2) == (1,))
-    output_bool((2, 2) == (1, 2))
-    output_bool((1, 2) == (2, 2))
-
-
-def test_tuple_ne():
-    # 0-len
-    output_bool(() != ())
-    # 1-len
-    output_bool((1,) != ())
-    output_bool(() != (1,))
-    output_bool((1,) != (1,))
-    output_bool((1,) != (2,))
-    # 2-len
-    output_bool((1, 2) != ())
-    output_bool(() != (1, 2))
-    output_bool((1,) != (1, 2))
-    output_bool((1, 2) != (1,))
-    output_bool((2, 2) != (1, 2))
-    output_bool((1, 2) != (2, 2))
-
-
 def run() -> int32:
     data = [0, 1, 2, 3]
 
@@ -72,7 +33,4 @@ def run() -> int32:
     output_int32(len((1, 2, 3, 4)))
     output_int32(len((1, 2, 3, 4, 5)))
 
-    test_tuple_eq()
-    test_tuple_ne()
-
     return 0