architeuthis/nac3
1
0
Fork 0
forked from M-Labs/nac3
Code Pull Requests Activity

[meta] Update to Rust Edition 2024

Browse Source
This commit is contained in:
David Mak
2025-03-26 11:23:56 +08:00
parent 34f6c3eaf8
commit cdd0b2011e
102 changed files with 584 additions and 572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
nac3artiq/Cargo.toml
View File

@@ -2,7 +2,7 @@
name = "nac3artiq"
version = "0.1.0"
authors = ["M-Labs"]
edition = "2021"
edition = "2024"
[lib]
name = "nac3artiq"

33
nac3artiq/src/codegen.rs
View File

@@ -1,5 +1,5 @@
use std::{
collections::{hash_map::DefaultHasher, HashMap},
collections::{HashMap, hash_map::DefaultHasher},
hash::{Hash, Hasher},
iter::once,
mem,
@@ -8,42 +8,42 @@ use std::{
use itertools::Itertools;
use pyo3::{
types::{PyDict, PyList},
PyObject, PyResult, Python,
types::{PyDict, PyList},
};
use super::{symbol_resolver::InnerResolver, timeline::TimeFns, SpecialPythonId};
use super::{SpecialPythonId, symbol_resolver::InnerResolver, timeline::TimeFns};
use nac3core::{
codegen::{
CodeGenContext, CodeGenerator,
expr::{create_fn_and_call, destructure_range, gen_call, infer_and_call_function},
llvm_intrinsics::{call_int_smax, call_memcpy, call_stackrestore, call_stacksave},
stmt::{gen_block, gen_for_callback_incrementing, gen_if_callback, gen_with},
type_aligned_alloca,
types::{ndarray::NDArrayType, RangeType},
types::{RangeType, ndarray::NDArrayType},
values::{
ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, ProxyValue,
UntypedArrayLikeAccessor,
},
CodeGenContext, CodeGenerator,
},
inkwell::{
AddressSpace, IntPredicate, OptimizationLevel,
context::Context,
module::Linkage,
targets::TargetMachine,
types::{BasicType, IntType},
values::{BasicValueEnum, IntValue, PointerValue, StructValue},
AddressSpace, IntPredicate, OptimizationLevel,
},
nac3parser::ast::{Expr, ExprKind, Located, Stmt, StmtKind, StrRef},
symbol_resolver::ValueEnum,
toplevel::{
helper::{extract_ndims, PrimDef},
numpy::unpack_ndarray_var_tys,
DefinitionId, GenCall,
helper::{PrimDef, extract_ndims},
numpy::unpack_ndarray_var_tys,
},
typecheck::{
type_inferencer::PrimitiveStore,
typedef::{iter_type_vars, FunSignature, FuncArg, Type, TypeEnum, VarMap},
typedef::{FunSignature, FuncArg, Type, TypeEnum, VarMap, iter_type_vars},
},
};
@@ -189,11 +189,7 @@ impl CodeGenerator for ArtiqCodeGenerator<'_> {
}
fn get_size_type<'ctx>(&self, ctx: &'ctx Context) -> IntType<'ctx> {
if self.size_t == 32 {
ctx.i32_type()
} else {
ctx.i64_type()
}
if self.size_t == 32 { ctx.i32_type() } else { ctx.i64_type() }
}
fn gen_block<'ctx, 'a, 'c, I: Iterator<Item = &'c Stmt<Option<Type>>>>(
@@ -452,7 +448,10 @@ fn gen_rpc_tag(
&*ctx.unifier.get_ty_immutable(ndarray_ndims)
{
if values.len() != 1 {
return Err(format!("NDArray types with multiple literal bounds for ndims is not supported: {}", ctx.unifier.stringify(ty)));
return Err(format!(
"NDArray types with multiple literal bounds for ndims is not supported: {}",
ctx.unifier.stringify(ty)
));
}
let value = values[0].clone();
@@ -834,7 +833,7 @@ fn rpc_codegen_callback_fn<'ctx>(
let ptr_type = int8.ptr_type(AddressSpace::default());
let tag_ptr_type = ctx.ctx.struct_type(&[ptr_type.into(), size_type.into()], false);
let service_id = int32.const_int(fun.1 .0 as u64, false);
let service_id = int32.const_int(fun.1.0 as u64, false);
// -- setup rpc tags
let mut tag = Vec::new();
if obj.is_some() {
@@ -857,7 +856,7 @@ fn rpc_codegen_callback_fn<'ctx>(
let tag_arr_ptr = ctx.module.add_global(
int8.array_type(tag.len() as u32),
None,
format!("tagptr{}", fun.1 .0).as_str(),
format!("tagptr{}", fun.1.0).as_str(),
);
tag_arr_ptr.set_initializer(&int8.const_array(
&tag.iter().map(|v| int8.const_int(u64::from(*v), false)).collect::<Vec<_>>(),

33
nac3artiq/src/lib.rs
View File

@@ -1,6 +1,7 @@
#![deny(future_incompatible, let_underscore, nonstandard_style, clippy::all)]
#![warn(clippy::pedantic)]
#![allow(
unsafe_op_in_unsafe_fn,
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
clippy::enum_glob_use,
@@ -30,17 +31,17 @@ use tempfile::{self, TempDir};
use nac3core::{
codegen::{
concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt, CodeGenLLVMOptions,
CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator, WithCall, WorkerRegistry,
CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator, WithCall,
WorkerRegistry, concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt,
},
inkwell::{
OptimizationLevel,
context::Context,
memory_buffer::MemoryBuffer,
module::{FlagBehavior, Linkage, Module},
passes::PassBuilderOptions,
support::is_multithreaded,
targets::*,
OptimizationLevel,
},
nac3parser::{
ast::{self, Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
@@ -48,19 +49,19 @@ use nac3core::{
},
symbol_resolver::SymbolResolver,
toplevel::{
DefinitionId, GenCall, TopLevelDef,
builtins::get_exn_constructor,
composer::{BuiltinFuncCreator, BuiltinFuncSpec, ComposerConfig, TopLevelComposer},
DefinitionId, GenCall, TopLevelDef,
},
typecheck::{
type_inferencer::PrimitiveStore,
typedef::{into_var_map, FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap, into_var_map},
},
};
use nac3ld::Linker;
use codegen::{
attributes_writeback, gen_core_log, gen_rtio_log, rpc_codegen_callback, ArtiqCodeGenerator,
ArtiqCodeGenerator, attributes_writeback, gen_core_log, gen_rtio_log, rpc_codegen_callback,
};
use symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver};
use timeline::TimeFns;
@@ -321,7 +322,7 @@ impl Nac3 {
None => {
return Some(format!(
"object launching kernel does not have method `{method_name}`"
))
));
}
}
} else {
@@ -342,7 +343,7 @@ impl Nac3 {
None if default_value.is_none() => {
return Some(format!(
"argument `{name}` not provided when launching kernel function"
))
));
}
_ => break,
};
@@ -356,7 +357,7 @@ impl Nac3 {
Err(e) => {
return Some(format!(
"type error ({e}) at parameter #{i} when calling kernel function"
))
));
}
};
if let Err(e) = unifier.unify(in_ty, *ty) {
@@ -582,9 +583,10 @@ impl Nac3 {
&& decorator_str != "extern"
{
return Err(CompileError::new_err(format!(
"compilation failed\n----------\nDecorator {} is not supported (at {})",
decorator_id_string(decorator).unwrap(), stmt.location
)));
"compilation failed\n----------\nDecorator {} is not supported (at {})",
decorator_id_string(decorator).unwrap(),
stmt.location
)));
}
}
}
@@ -618,7 +620,8 @@ impl Nac3 {
{
return Err(CompileError::new_err(format!(
"compilation failed\n----------\nDecorator {} is not supported (at {})",
decorator_id_string(decorator).unwrap(), stmt.location
decorator_id_string(decorator).unwrap(),
stmt.location
)));
}
}
@@ -774,7 +777,7 @@ impl Nac3 {
TopLevelDef::Variable { .. } => {
return Err(CompileError::new_err(String::from(
"Unsupported @rpc annotation on global variable",
)))
)));
}
TopLevelDef::Module { .. } => {
unreachable!("Type module cannot be decorated with @rpc")
@@ -1384,7 +1387,7 @@ impl Nac3 {
}
#[cfg(feature = "init-llvm-profile")]
extern "C" {
unsafe extern "C" {
fn __llvm_profile_initialize();
}

28
nac3artiq/src/symbol_resolver.rs
View File

@@ -1,41 +1,41 @@
use std::{
collections::{HashMap, HashSet},
sync::{
atomic::{AtomicBool, Ordering::Relaxed},
Arc,
atomic::{AtomicBool, Ordering::Relaxed},
},
};
use itertools::Itertools;
use parking_lot::RwLock;
use pyo3::{
types::{PyDict, PyTuple},
PyAny, PyErr, PyObject, PyResult, Python,
types::{PyDict, PyTuple},
};
use super::PrimitivePythonId;
use nac3core::{
codegen::{
types::{ndarray::NDArrayType, structure::StructProxyType, ProxyType},
values::ndarray::make_contiguous_strides,
CodeGenContext, CodeGenerator,
types::{ProxyType, ndarray::NDArrayType, structure::StructProxyType},
values::ndarray::make_contiguous_strides,
},
inkwell::{
AddressSpace,
module::Linkage,
types::{BasicType, BasicTypeEnum},
values::{BasicValue, BasicValueEnum},
AddressSpace,
},
nac3parser::ast::{self, StrRef},
symbol_resolver::{StaticValue, SymbolResolver, SymbolValue, ValueEnum},
toplevel::{
DefinitionId, TopLevelDef,
helper::PrimDef,
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
DefinitionId, TopLevelDef,
},
typecheck::{
type_inferencer::PrimitiveStore,
typedef::{into_var_map, iter_type_vars, Type, TypeEnum, TypeVar, Unifier, VarMap},
typedef::{Type, TypeEnum, TypeVar, Unifier, VarMap, into_var_map, iter_type_vars},
},
};
@@ -290,7 +290,7 @@ impl InnerResolver {
return Ok(Err(format!(
"inhomogeneous type ({}) at element #{i} of the list",
e.to_display(unifier)
)))
)));
}
};
}
@@ -469,7 +469,7 @@ impl InnerResolver {
match self.get_pyty_obj_type(py, origin.as_ref(py), unifier, defs, primitives)? {
Ok((ty, false)) => ty,
Ok((_, true)) => {
return Ok(Err("instantiated type does not take type parameters".into()))
return Ok(Err("instantiated type does not take type parameters".into()));
}
Err(err) => return Ok(Err(err)),
};
@@ -884,7 +884,7 @@ impl InnerResolver {
Err(e) => {
return Ok(Err(format!(
"error when getting type of the option object ({e})"
)))
)));
}
};
let new_var_map: VarMap = params.iter().map(|(id, _)| (*id, ty)).collect();
@@ -907,7 +907,7 @@ impl InnerResolver {
// loop through non-function fields of the class to get the instantiated value
for field in fields {
let name: String = (*field.0).into();
if let TypeEnum::TFunc(..) = &*unifier.get_ty(field.1 .0) {
if let TypeEnum::TFunc(..) = &*unifier.get_ty(field.1.0) {
continue;
}
let field_data = match obj.getattr(name.as_str()) {
@@ -920,10 +920,10 @@ impl InnerResolver {
Err(e) => {
return Ok(Err(format!(
"error when getting type of field `{name}` ({e})"
)))
)));
}
};
let field_ty = unifier.subst(field.1 .0, &var_map).unwrap_or(field.1 .0);
let field_ty = unifier.subst(field.1.0, &var_map).unwrap_or(field.1.0);
if let Err(e) = unifier.unify(ty, field_ty) {
// field type mismatch
return Ok(Err(format!(
@@ -1445,7 +1445,7 @@ impl InnerResolver {
attributes
.iter()
.filter_map(|f| {
let definition = top_level_defs.get(f.1 .0).unwrap().read();
let definition = top_level_defs.get(f.1.0).unwrap().read();
if let TopLevelDef::Variable { ty, .. } = &*definition {
Some((f.0, *ty))
} else {

4
nac3artiq/src/timeline.rs
View File

@@ -1,6 +1,6 @@
use nac3core::{
codegen::{expr::infer_and_call_function, CodeGenContext},
inkwell::{values::BasicValueEnum, AddressSpace, AtomicOrdering},
codegen::{CodeGenContext, expr::infer_and_call_function},
inkwell::{AddressSpace, AtomicOrdering, values::BasicValueEnum},
};
/// Functions for manipulating the timeline.

2
nac3ast/Cargo.toml
View File

@@ -2,7 +2,7 @@
name = "nac3ast"
version = "0.1.0"
authors = ["RustPython Team", "M-Labs"]
edition = "2021"
edition = "2024"
[features]
default = ["constant-optimization", "fold"]

2
nac3ast/src/ast_gen.rs
View File

@@ -6,7 +6,7 @@ pub use crate::location::Location;
use fxhash::FxBuildHasher;
use parking_lot::{Mutex, MutexGuard};
use std::{cell::RefCell, collections::HashMap, fmt, sync::LazyLock};
use string_interner::{symbol::SymbolU32, DefaultBackend, StringInterner};
use string_interner::{DefaultBackend, StringInterner, symbol::SymbolU32};
pub type Interner = StringInterner<DefaultBackend, FxBuildHasher>;
static INTERNER: LazyLock<Mutex<Interner>> =

2
nac3ast/src/fold_helpers.rs
View File

@@ -1,6 +1,6 @@
use crate::StrRef;
use crate::constant;
use crate::fold::Fold;
use crate::StrRef;
pub(crate) trait Foldable<T, U> {
type Mapped;

2
nac3core/Cargo.toml
View File

@@ -2,7 +2,7 @@
name = "nac3core"
version = "0.1.0"
authors = ["M-Labs"]
edition = "2021"
edition = "2024"
[features]
default = ["derive"]

2
nac3core/nac3core_derive/Cargo.toml
View File

@@ -1,7 +1,7 @@
[package]
name = "nac3core_derive"
version = "0.1.0"
edition = "2021"
edition = "2024"
[lib]
proc-macro = true

21
nac3core/nac3core_derive/src/lib.rs
View File

@@ -2,8 +2,8 @@ use proc_macro::TokenStream;
use proc_macro_error::{abort, proc_macro_error};
use quote::quote;
use syn::{
parse_macro_input, spanned::Spanned, Data, DataStruct, Expr, ExprField, ExprMethodCall,
ExprPath, GenericArgument, Ident, LitStr, Path, PathArguments, Type, TypePath,
Data, DataStruct, Expr, ExprField, ExprMethodCall, ExprPath, GenericArgument, Ident, LitStr,
Path, PathArguments, Type, TypePath, parse_macro_input, spanned::Spanned,
};
/// Extracts all generic arguments of a [`Type`] into a [`Vec`].
@@ -59,11 +59,7 @@ fn replace_top_level_receiver(expr: &mut Expr, ident: Ident) -> Option<&mut Expr
| Expr::Field(ExprField { base: operand, .. }) = expr
{
return if extract_dot_operand(operand).is_some() {
if replace_top_level_receiver(operand, ident).is_some() {
Some(expr)
} else {
None
}
if replace_top_level_receiver(operand, ident).is_some() { Some(expr) } else { None }
} else {
*operand = Box::new(Expr::Path(ExprPath {
attrs: Vec::default(),
@@ -105,7 +101,7 @@ fn normalize_value_expr(expr: &Expr) -> proc_macro2::TokenStream {
abort!(
path,
format!(
"Expected one of `size_t`, `usize`, or an implicit call expression in #[value_type(...)], found {}",
"Expected one of `size_t`, `usize`, or an implicit call expression in #[value_type(...)], found {}",
quote!(#expr).to_string(),
)
)
@@ -154,7 +150,7 @@ fn normalize_value_expr(expr: &Expr) -> proc_macro2::TokenStream {
abort!(
expr,
format!(
"Expected one of `size_t`, `usize`, or an implicit call expression in #[value_type(...)], found {}",
"Expected one of `size_t`, `usize`, or an implicit call expression in #[value_type(...)], found {}",
quote!(#expr).to_string(),
)
)
@@ -224,10 +220,9 @@ pub fn derive(input: TokenStream) -> TokenStream {
let Data::Struct(DataStruct { fields, .. }) = &input.data else {
abort!(input, "Only structs with named fields are supported");
};
if let Err(err_span) =
fields
.iter()
.try_for_each(|field| if field.ident.is_some() { Ok(()) } else { Err(field.span()) })
if let Err(err_span) = fields
.iter()
.try_for_each(|field| if field.ident.is_some() { Ok(()) } else { Err(field.span()) })
{
abort!(err_span, "Only structs with named fields are supported");
};

2
nac3core/nac3core_derive/tests/structfields_ndarray.rs
View File

@@ -1,8 +1,8 @@
use nac3core::{
codegen::types::structure::StructField,
inkwell::{
values::{IntValue, PointerValue},
AddressSpace,
values::{IntValue, PointerValue},
},
};
use nac3core_derive::StructFields;

2
nac3core/nac3core_derive/tests/structfields_slice.rs
View File

@@ -1,8 +1,8 @@
use nac3core::{
codegen::types::structure::StructField,
inkwell::{
values::{IntValue, PointerValue},
AddressSpace,
values::{IntValue, PointerValue},
},
};
use nac3core_derive::StructFields;

2
nac3core/nac3core_derive/tests/structfields_slice_context.rs
View File

@@ -1,8 +1,8 @@
use nac3core::{
codegen::types::structure::StructField,
inkwell::{
values::{IntValue, PointerValue},
AddressSpace,
values::{IntValue, PointerValue},
},
};
use nac3core_derive::StructFields;

2
nac3core/nac3core_derive/tests/structfields_slice_ctx.rs
View File

@@ -1,8 +1,8 @@
use nac3core::{
codegen::types::structure::StructField,
inkwell::{
values::{IntValue, PointerValue},
AddressSpace,
values::{IntValue, PointerValue},
},
};
use nac3core_derive::StructFields;

2
nac3core/nac3core_derive/tests/structfields_slice_sizet.rs
View File

@@ -1,8 +1,8 @@
use nac3core::{
codegen::types::structure::StructField,
inkwell::{
values::{IntValue, PointerValue},
AddressSpace,
values::{IntValue, PointerValue},
},
};
use nac3core_derive::StructFields;

230
nac3core/src/codegen/builtin_fns.rs
View File

@@ -1,26 +1,26 @@
use inkwell::{
FloatPredicate, IntPredicate, OptimizationLevel,
types::BasicTypeEnum,
values::{BasicValueEnum, IntValue},
FloatPredicate, IntPredicate, OptimizationLevel,
};
use itertools::Itertools;
use super::{
CodeGenContext, CodeGenerator,
expr::destructure_range,
extern_fns, irrt,
irrt::calculate_len_for_slice_range,
llvm_intrinsics,
macros::codegen_unreachable,
types::{ndarray::NDArrayType, ListType, RangeType, TupleType},
types::{ListType, RangeType, TupleType, ndarray::NDArrayType},
values::{
ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
ProxyValue, TypedArrayLikeAccessor, UntypedArrayLikeAccessor,
ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
},
CodeGenContext, CodeGenerator,
};
use crate::{
toplevel::{
helper::{arraylike_flatten_element_type, extract_ndims, PrimDef},
helper::{PrimDef, arraylike_flatten_element_type, extract_ndims},
numpy::unpack_ndarray_var_tys,
},
typecheck::typedef::{Type, TypeEnum},
@@ -99,17 +99,21 @@ pub fn call_int32<'ctx, G: CodeGenerator + ?Sized>(
}
BasicValueEnum::IntValue(n) if n.get_type().get_bit_width() == 32 => {
debug_assert!([ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
n.into()
}
BasicValueEnum::IntValue(n) if n.get_type().get_bit_width() == 64 => {
debug_assert!([ctx.primitives.int64, ctx.primitives.uint64,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.int64, ctx.primitives.uint64,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
ctx.builder.build_int_truncate(n, llvm_i32, "trunc").map(Into::into).unwrap()
}
@@ -155,9 +159,11 @@ pub fn call_int64<'ctx, G: CodeGenerator + ?Sized>(
Ok(match n {
BasicValueEnum::IntValue(n) if matches!(n.get_type().get_bit_width(), 1 | 8 | 32) => {
debug_assert!([ctx.primitives.bool, ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.bool, ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
if ctx.unifier.unioned(n_ty, ctx.primitives.int32) {
ctx.builder.build_int_s_extend(n, llvm_i64, "sext").map(Into::into).unwrap()
@@ -167,9 +173,11 @@ pub fn call_int64<'ctx, G: CodeGenerator + ?Sized>(
}
BasicValueEnum::IntValue(n) if n.get_type().get_bit_width() == 64 => {
debug_assert!([ctx.primitives.int64, ctx.primitives.uint64,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.int64, ctx.primitives.uint64,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
n.into()
}
@@ -222,9 +230,11 @@ pub fn call_uint32<'ctx, G: CodeGenerator + ?Sized>(
}
BasicValueEnum::IntValue(n) if n.get_type().get_bit_width() == 32 => {
debug_assert!([ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
n.into()
}
@@ -293,9 +303,11 @@ pub fn call_uint64<'ctx, G: CodeGenerator + ?Sized>(
Ok(match n {
BasicValueEnum::IntValue(n) if matches!(n.get_type().get_bit_width(), 1 | 8 | 32) => {
debug_assert!([ctx.primitives.bool, ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.bool, ctx.primitives.int32, ctx.primitives.uint32,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
if ctx.unifier.unioned(n_ty, ctx.primitives.int32) {
ctx.builder.build_int_s_extend(n, llvm_i64, "sext").map(Into::into).unwrap()
@@ -305,9 +317,11 @@ pub fn call_uint64<'ctx, G: CodeGenerator + ?Sized>(
}
BasicValueEnum::IntValue(n) if n.get_type().get_bit_width() == 64 => {
debug_assert!([ctx.primitives.int64, ctx.primitives.uint64,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[ctx.primitives.int64, ctx.primitives.uint64,]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
n.into()
}
@@ -359,15 +373,17 @@ pub fn call_float<'ctx, G: CodeGenerator + ?Sized>(
Ok(match n {
BasicValueEnum::IntValue(n) if matches!(n.get_type().get_bit_width(), 1 | 8 | 32 | 64) => {
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
if [ctx.primitives.bool, ctx.primitives.int32, ctx.primitives.int64]
.iter()
@@ -515,14 +531,16 @@ pub fn call_bool<'ctx, G: CodeGenerator + ?Sized>(
}
BasicValueEnum::IntValue(n) => {
debug_assert!([
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty)));
debug_assert!(
[
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(n_ty, *ty))
);
ctx.builder
.build_int_compare(IntPredicate::NE, n, n.get_type().const_zero(), FN_NAME)
@@ -683,15 +701,17 @@ pub fn call_min<'ctx>(
match (m, n) {
(BasicValueEnum::IntValue(m), BasicValueEnum::IntValue(n)) => {
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty, *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty, *ty))
);
if [ctx.primitives.int32, ctx.primitives.int64]
.iter()
@@ -726,16 +746,18 @@ pub fn call_numpy_minimum<'ctx, G: CodeGenerator + ?Sized>(
Ok(match (x1, x2) {
(BasicValueEnum::IntValue(x1), BasicValueEnum::IntValue(x2)) => {
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
ctx.primitives.float,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty.unwrap(), *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
ctx.primitives.float,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty.unwrap(), *ty))
);
call_min(ctx, (x1_ty, x1.into()), (x2_ty, x2.into()))
}
@@ -800,15 +822,17 @@ pub fn call_max<'ctx>(
match (m, n) {
(BasicValueEnum::IntValue(m), BasicValueEnum::IntValue(n)) => {
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty, *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty, *ty))
);
if [ctx.primitives.int32, ctx.primitives.int64]
.iter()
@@ -845,16 +869,18 @@ pub fn call_numpy_max_min<'ctx, G: CodeGenerator + ?Sized>(
Ok(match a {
BasicValueEnum::IntValue(_) | BasicValueEnum::FloatValue(_) => {
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
ctx.primitives.float,
]
.iter()
.any(|ty| ctx.unifier.unioned(a_ty, *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
ctx.primitives.float,
]
.iter()
.any(|ty| ctx.unifier.unioned(a_ty, *ty))
);
match fn_name {
"np_argmin" | "np_argmax" => llvm_int64.const_zero().into(),
@@ -986,16 +1012,18 @@ pub fn call_numpy_maximum<'ctx, G: CodeGenerator + ?Sized>(
Ok(match (x1, x2) {
(BasicValueEnum::IntValue(x1), BasicValueEnum::IntValue(x2)) => {
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
ctx.primitives.float,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty.unwrap(), *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
ctx.primitives.float,
]
.iter()
.any(|ty| ctx.unifier.unioned(common_ty.unwrap(), *ty))
);
call_max(ctx, (x1_ty, x1.into()), (x2_ty, x2.into()))
}
@@ -1101,15 +1129,17 @@ pub fn call_abs<'ctx, G: CodeGenerator + ?Sized>(
&|_ctx, elem_ty| elem_ty,
&|_generator, ctx, val_ty, val| match val {
BasicValueEnum::IntValue(n) => Some({
debug_assert!([
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(val_ty, *ty)));
debug_assert!(
[
ctx.primitives.bool,
ctx.primitives.int32,
ctx.primitives.uint32,
ctx.primitives.int64,
ctx.primitives.uint64,
]
.iter()
.any(|ty| ctx.unifier.unioned(val_ty, *ty))
);
if [ctx.primitives.int32, ctx.primitives.int64]
.iter()

2
nac3core/src/codegen/concrete_type.rs
View File

@@ -10,7 +10,7 @@ use crate::{
typecheck::{
type_inferencer::PrimitiveStore,
typedef::{
into_var_map, FunSignature, FuncArg, Type, TypeEnum, TypeVar, TypeVarId, Unifier,
FunSignature, FuncArg, Type, TypeEnum, TypeVar, TypeVarId, Unifier, into_var_map,
},
},
};

29
nac3core/src/codegen/expr.rs
View File

@@ -6,12 +6,12 @@ use std::{
};
use inkwell::{
AddressSpace, IntPredicate, OptimizationLevel,
attributes::{Attribute, AttributeLoc},
types::{AnyType, BasicType, BasicTypeEnum},
values::{BasicValueEnum, CallSiteValue, FunctionValue, IntValue, PointerValue, StructValue},
AddressSpace, IntPredicate, OptimizationLevel,
};
use itertools::{izip, Either, Itertools};
use itertools::{Either, Itertools, izip};
use nac3parser::ast::{
self, Boolop, Cmpop, Comprehension, Constant, Expr, ExprKind, Location, Operator, StrRef,
@@ -19,6 +19,7 @@ use nac3parser::ast::{
};
use super::{
CodeGenContext, CodeGenTask, CodeGenerator,
concrete_type::{ConcreteFuncArg, ConcreteTypeEnum, ConcreteTypeStore},
gen_in_range_check, get_llvm_abi_type, get_llvm_type, get_va_count_arg_name,
irrt::*,
@@ -33,21 +34,20 @@ use super::{
gen_var,
},
types::{
ndarray::NDArrayType, ExceptionType, ListType, OptionType, RangeType, StringType, TupleType,
ExceptionType, ListType, OptionType, RangeType, StringType, TupleType, ndarray::NDArrayType,
},
values::{
ndarray::{NDArrayOut, RustNDIndex, ScalarOrNDArray},
ArrayLikeIndexer, ArrayLikeValue, ListValue, ProxyValue, RangeValue,
UntypedArrayLikeAccessor,
ndarray::{NDArrayOut, RustNDIndex, ScalarOrNDArray},
},
CodeGenContext, CodeGenTask, CodeGenerator,
};
use crate::{
symbol_resolver::{SymbolValue, ValueEnum},
toplevel::{
helper::{arraylike_flatten_element_type, extract_ndims, PrimDef},
numpy::unpack_ndarray_var_tys,
DefinitionId, TopLevelDef,
helper::{PrimDef, arraylike_flatten_element_type, extract_ndims},
numpy::unpack_ndarray_var_tys,
},
typecheck::{
magic_methods::{Binop, BinopVariant, HasOpInfo},
@@ -137,7 +137,7 @@ impl<'ctx> CodeGenContext<'ctx, '_> {
(field_index.0, None)
} else {
let attribute_index = attributes.iter().find_position(|x| x.0 == attr).unwrap();
(attribute_index.0, Some(attribute_index.1 .2.clone()))
(attribute_index.0, Some(attribute_index.1.2.clone()))
}
} else if let TopLevelDef::Module { attributes, .. } = &*def.read() {
(attributes.iter().find_position(|x| x.0 == attr).unwrap().0, None)
@@ -782,7 +782,7 @@ pub fn gen_call<'ctx, G: CodeGenerator>(
) -> Result<Option<BasicValueEnum<'ctx>>, String> {
let llvm_usize = ctx.get_size_type();
let definition = ctx.top_level.definitions.read().get(fun.1 .0).cloned().unwrap();
let definition = ctx.top_level.definitions.read().get(fun.1.0).cloned().unwrap();
let id;
let key;
let param_vals;
@@ -865,9 +865,10 @@ pub fn gen_call<'ctx, G: CodeGenerator>(
} else {
mapping.insert(
k.name,
vec![ctx
.gen_symbol_val(generator, &k.default_value.unwrap(), k.ty)
.into()],
vec![
ctx.gen_symbol_val(generator, &k.default_value.unwrap(), k.ty)
.into(),
],
);
}
}
@@ -937,7 +938,7 @@ pub fn gen_call<'ctx, G: CodeGenerator>(
instance_to_symbol.get(&key).cloned().ok_or_else(String::new)
}
TopLevelDef::Class { .. } => {
return Ok(Some(generator.gen_constructor(ctx, fun.0, &def, params)?))
return Ok(Some(generator.gen_constructor(ctx, fun.0, &def, params)?));
}
TopLevelDef::Variable { .. } | TopLevelDef::Module { .. } => unreachable!(),
}
@@ -2590,7 +2591,7 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
}
ExprKind::UnaryOp { op, operand } => return gen_unaryop_expr(generator, ctx, *op, operand),
ExprKind::Compare { left, ops, comparators } => {
return gen_cmpop_expr(generator, ctx, left, ops, comparators)
return gen_cmpop_expr(generator, ctx, left, ops, comparators);
}
ExprKind::IfExp { test, body, orelse } => {
let test = match generator.gen_expr(ctx, test)? {

2
nac3core/src/codegen/extern_fns.rs
View File

@@ -3,7 +3,7 @@ use inkwell::{
values::{BasicValueEnum, FloatValue},
};
use super::{expr::infer_and_call_function, CodeGenContext};
use super::{CodeGenContext, expr::infer_and_call_function};
/// Macro to generate extern function
/// Both function return type and function parameter type are `FloatValue`

8
nac3core/src/codegen/generator.rs
View File

@@ -7,7 +7,7 @@ use inkwell::{
use nac3parser::ast::{Expr, Stmt, StrRef};
use super::{bool_to_int_type, expr::*, stmt::*, values::ArraySliceValue, CodeGenContext};
use super::{CodeGenContext, bool_to_int_type, expr::*, stmt::*, values::ArraySliceValue};
use crate::{
symbol_resolver::ValueEnum,
toplevel::{DefinitionId, TopLevelDef},
@@ -308,10 +308,6 @@ impl CodeGenerator for DefaultCodeGenerator {
fn get_size_type<'ctx>(&self, ctx: &'ctx Context) -> IntType<'ctx> {
// it should be unsigned, but we don't really need unsigned and this could save us from
// having to do a bit cast...
if self.size_t == 32 {
ctx.i32_type()
} else {
ctx.i64_type()
}
if self.size_t == 32 { ctx.i32_type() } else { ctx.i64_type() }
}
}

2
nac3core/src/codegen/irrt/cc_builtins.rs
View File

@@ -3,7 +3,7 @@ use inkwell::{
values::{BasicValueEnum, FloatValue, IntValue},
};
use crate::codegen::{expr::infer_and_call_function, CodeGenContext};
use crate::codegen::{CodeGenContext, expr::infer_and_call_function};
/// Generates a call to [`isinf`](https://en.cppreference.com/w/c/numeric/math/isinf) in IR. Returns
/// an `i1` representing the result.

4
nac3core/src/codegen/irrt/list.rs
View File

@@ -1,16 +1,16 @@
use inkwell::{
AddressSpace, IntPredicate,
types::BasicTypeEnum,
values::{BasicValueEnum, IntValue},
AddressSpace, IntPredicate,
};
use super::calculate_len_for_slice_range;
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
macros::codegen_unreachable,
stmt::gen_if_callback,
values::{ArrayLikeValue, ListValue},
CodeGenContext, CodeGenerator,
};
/// This function handles 'end' **inclusively**.

2
nac3core/src/codegen/irrt/math.rs
View File

@@ -1,6 +1,6 @@
use inkwell::{
values::{BasicValueEnum, FloatValue, IntValue},
IntPredicate,
values::{BasicValueEnum, FloatValue, IntValue},
};
use crate::codegen::{

2
nac3core/src/codegen/irrt/mod.rs
View File

@@ -1,10 +1,10 @@
use inkwell::{
IntPredicate,
attributes::{Attribute, AttributeLoc},
context::Context,
memory_buffer::MemoryBuffer,
module::Module,
values::{BasicValue, BasicValueEnum, IntValue},
IntPredicate,
};
use nac3parser::ast::Expr;

4
nac3core/src/codegen/irrt/ndarray/array.rs
View File

@@ -1,10 +1,10 @@
use inkwell::{types::BasicTypeEnum, values::IntValue};
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
values::{ndarray::NDArrayValue, ListValue, ProxyValue, TypedArrayLikeAccessor},
CodeGenContext, CodeGenerator,
values::{ListValue, ProxyValue, TypedArrayLikeAccessor, ndarray::NDArrayValue},
};
/// Generates a call to `__nac3_ndarray_array_set_and_validate_list_shape`.

6
nac3core/src/codegen/irrt/ndarray/basic.rs
View File

@@ -1,13 +1,13 @@
use inkwell::{
values::{BasicValueEnum, IntValue, PointerValue},
AddressSpace,
values::{BasicValueEnum, IntValue, PointerValue},
};
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
values::{ndarray::NDArrayValue, ProxyValue, TypedArrayLikeAccessor},
CodeGenContext, CodeGenerator,
values::{ProxyValue, TypedArrayLikeAccessor, ndarray::NDArrayValue},
};
/// Generates a call to `__nac3_ndarray_util_assert_shape_no_negative`.

20
nac3core/src/codegen/irrt/ndarray/broadcast.rs
View File

@@ -1,14 +1,14 @@
use inkwell::values::IntValue;
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
types::{ndarray::ShapeEntryType, ProxyType},
types::{ProxyType, ndarray::ShapeEntryType},
values::{
ndarray::NDArrayValue, ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAccessor,
TypedArrayLikeMutator,
ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeMutator,
ndarray::NDArrayValue,
},
CodeGenContext, CodeGenerator,
};
/// Generates a call to `__nac3_ndarray_broadcast_to`.
@@ -55,11 +55,13 @@ pub fn call_nac3_ndarray_broadcast_shapes<'ctx, G, Shape>(
let llvm_usize = ctx.get_size_type();
assert_eq!(num_shape_entries.get_type(), llvm_usize);
assert!(ShapeEntryType::is_representable(
shape_entries.base_ptr(ctx, generator).get_type(),
llvm_usize,
)
.is_ok());
assert!(
ShapeEntryType::is_representable(
shape_entries.base_ptr(ctx, generator).get_type(),
llvm_usize,
)
.is_ok()
);
assert_eq!(dst_ndims.get_type(), llvm_usize);
assert_eq!(dst_shape.element_type(ctx, generator), llvm_usize.into());

4
nac3core/src/codegen/irrt/ndarray/indexing.rs
View File

@@ -1,8 +1,8 @@
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
values::{ndarray::NDArrayValue, ArrayLikeValue, ArraySliceValue, ProxyValue},
CodeGenContext, CodeGenerator,
values::{ArrayLikeValue, ArraySliceValue, ProxyValue, ndarray::NDArrayValue},
};
/// Generates a call to `__nac3_ndarray_index`.

4
nac3core/src/codegen/irrt/ndarray/iter.rs
View File

@@ -1,13 +1,13 @@
use inkwell::values::{BasicValueEnum, IntValue};
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
values::{
ndarray::{NDArrayValue, NDIterValue},
ProxyValue, TypedArrayLikeAccessor,
ndarray::{NDArrayValue, NDIterValue},
},
CodeGenContext, CodeGenerator,
};
/// Generates a call to `__nac3_nditer_initialize`.

4
nac3core/src/codegen/irrt/ndarray/matmul.rs
View File

@@ -1,8 +1,8 @@
use inkwell::values::IntValue;
use crate::codegen::{
expr::infer_and_call_function, irrt::get_usize_dependent_function_name,
values::TypedArrayLikeAccessor, CodeGenContext, CodeGenerator,
CodeGenContext, CodeGenerator, expr::infer_and_call_function,
irrt::get_usize_dependent_function_name, values::TypedArrayLikeAccessor,
};
/// Generates a call to `__nac3_ndarray_matmul_calculate_shapes`.

2
nac3core/src/codegen/irrt/ndarray/reshape.rs
View File

@@ -1,10 +1,10 @@
use inkwell::values::IntValue;
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
values::{ArrayLikeValue, ArraySliceValue},
CodeGenContext, CodeGenerator,
};
/// Generates a call to `__nac3_ndarray_reshape_resolve_and_check_new_shape`.

6
nac3core/src/codegen/irrt/ndarray/transpose.rs
View File

@@ -1,10 +1,10 @@
use inkwell::{values::IntValue, AddressSpace};
use inkwell::{AddressSpace, values::IntValue};
use crate::codegen::{
CodeGenContext, CodeGenerator,
expr::infer_and_call_function,
irrt::get_usize_dependent_function_name,
values::{ndarray::NDArrayValue, ProxyValue, TypedArrayLikeAccessor},
CodeGenContext, CodeGenerator,
values::{ProxyValue, TypedArrayLikeAccessor, ndarray::NDArrayValue},
};
/// Generates a call to `__nac3_ndarray_transpose`.

4
nac3core/src/codegen/irrt/range.rs
View File

@@ -1,9 +1,9 @@
use inkwell::{
values::{BasicValueEnum, IntValue},
IntPredicate,
values::{BasicValueEnum, IntValue},
};
use crate::codegen::{expr::infer_and_call_function, CodeGenContext, CodeGenerator};
use crate::codegen::{CodeGenContext, CodeGenerator, expr::infer_and_call_function};
/// Invokes the `__nac3_range_slice_len` in IRRT.
///

2
nac3core/src/codegen/irrt/slice.rs
View File

@@ -3,7 +3,7 @@ use inkwell::values::{BasicValueEnum, IntValue};
use nac3parser::ast::Expr;
use crate::{
codegen::{expr::infer_and_call_function, CodeGenContext, CodeGenerator},
codegen::{CodeGenContext, CodeGenerator, expr::infer_and_call_function},
typecheck::typedef::Type,
};

2
nac3core/src/codegen/irrt/string.rs
View File

@@ -1,7 +1,7 @@
use inkwell::values::{BasicValueEnum, IntValue};
use super::get_usize_dependent_function_name;
use crate::codegen::{expr::infer_and_call_function, values::StringValue, CodeGenContext};
use crate::codegen::{CodeGenContext, expr::infer_and_call_function, values::StringValue};
/// Generates a call to string equality comparison. Returns an `i1` representing whether the strings are equal.
pub fn call_string_eq<'ctx>(

2
nac3core/src/codegen/llvm_intrinsics.rs
View File

@@ -1,8 +1,8 @@
use inkwell::{
AddressSpace,
intrinsics::Intrinsic,
types::AnyTypeEnum::IntType,
values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue},
AddressSpace,
};
use itertools::Either;

17
nac3core/src/codegen/mod.rs
View File

@@ -2,14 +2,15 @@ use std::{
cell::OnceCell,
collections::{HashMap, HashSet},
sync::{
atomic::{AtomicBool, Ordering},
Arc,
atomic::{AtomicBool, Ordering},
},
thread,
};
use crossbeam::channel::{unbounded, Receiver, Sender};
use crossbeam::channel::{Receiver, Sender, unbounded};
use inkwell::{
AddressSpace, IntPredicate, OptimizationLevel,
attributes::{Attribute, AttributeLoc},
basic_block::BasicBlock,
builder::Builder,
@@ -22,7 +23,6 @@ use inkwell::{
targets::{CodeModel, RelocMode, Target, TargetMachine, TargetTriple},
types::{AnyType, BasicType, BasicTypeEnum, IntType},
values::{BasicValueEnum, FunctionValue, IntValue, PhiValue, PointerValue},
AddressSpace, IntPredicate, OptimizationLevel,
};
use itertools::Itertools;
use parking_lot::{Condvar, Mutex};
@@ -32,9 +32,9 @@ use nac3parser::ast::{Location, Stmt, StrRef};
use crate::{
symbol_resolver::{StaticValue, SymbolResolver},
toplevel::{
helper::{extract_ndims, PrimDef},
numpy::unpack_ndarray_var_tys,
TopLevelContext, TopLevelDef,
helper::{PrimDef, extract_ndims},
numpy::unpack_ndarray_var_tys,
},
typecheck::{
type_inferencer::{CodeLocation, PrimitiveStore},
@@ -44,8 +44,8 @@ use crate::{
use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
pub use generator::{CodeGenerator, DefaultCodeGenerator};
use types::{
ndarray::NDArrayType, ExceptionType, ListType, OptionType, ProxyType, RangeType, StringType,
TupleType,
ExceptionType, ListType, OptionType, ProxyType, RangeType, StringType, TupleType,
ndarray::NDArrayType,
};
pub mod builtin_fns;
@@ -1028,8 +1028,7 @@ pub fn gen_func_impl<
);
let generator_llvm_usize = generator.get_size_type(context);
assert_eq!(
generator_llvm_usize,
target_llvm_usize,
generator_llvm_usize, target_llvm_usize,
"CodeGenerator (size_t = {generator_llvm_usize}) is not compatible with CodeGen Target (size_t = {target_llvm_usize})",
);

8
nac3core/src/codegen/numpy.rs
View File

@@ -1,23 +1,23 @@
use inkwell::{
values::{BasicValue, BasicValueEnum, PointerValue},
IntPredicate,
values::{BasicValue, BasicValueEnum, PointerValue},
};
use nac3parser::ast::StrRef;
use super::{
CodeGenContext, CodeGenerator,
macros::codegen_unreachable,
stmt::gen_for_callback,
types::ndarray::{NDArrayType, NDIterType},
values::{ndarray::shape::parse_numpy_int_sequence, ProxyValue},
CodeGenContext, CodeGenerator,
values::{ProxyValue, ndarray::shape::parse_numpy_int_sequence},
};
use crate::{
symbol_resolver::ValueEnum,
toplevel::{
DefinitionId,
helper::{arraylike_flatten_element_type, extract_ndims},
numpy::unpack_ndarray_var_tys,
DefinitionId,
},
typecheck::typedef::{FunSignature, Type},
};

14
nac3core/src/codegen/stmt.rs
View File

@@ -1,35 +1,35 @@
use inkwell::{
IntPredicate,
attributes::{Attribute, AttributeLoc},
basic_block::BasicBlock,
builder::Builder,
types::{BasicType, BasicTypeEnum},
values::{BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue},
IntPredicate,
};
use itertools::{izip, Itertools};
use itertools::{Itertools, izip};
use nac3parser::ast::{
Constant, ExcepthandlerKind, Expr, ExprKind, Location, Stmt, StmtKind, StrRef,
};
use super::{
CodeGenContext, CodeGenerator,
expr::{destructure_range, gen_binop_expr},
gen_in_range_check,
irrt::{handle_slice_indices, list_slice_assignment},
macros::codegen_unreachable,
types::{ndarray::NDArrayType, ExceptionType, RangeType},
types::{ExceptionType, RangeType, ndarray::NDArrayType},
values::{
ndarray::{RustNDIndex, ScalarOrNDArray},
ArrayLikeIndexer, ArraySliceValue, ExceptionValue, ListValue, ProxyValue,
ndarray::{RustNDIndex, ScalarOrNDArray},
},
CodeGenContext, CodeGenerator,
};
use crate::{
symbol_resolver::ValueEnum,
toplevel::{DefinitionId, TopLevelDef},
typecheck::{
magic_methods::Binop,
typedef::{iter_type_vars, FunSignature, Type, TypeEnum},
typedef::{FunSignature, Type, TypeEnum, iter_type_vars},
},
};
@@ -234,7 +234,7 @@ pub fn gen_assign_target_list<'ctx, G: CodeGenerator>(
let a = starred_target_index; // Number of RHS values before the starred target
let b = tuple_tys.len() - (targets.len() - 1 - starred_target_index); // Number of RHS values after the starred target
// Thus `tuple[a..b]` is assigned to the starred target.
// Thus `tuple[a..b]` is assigned to the starred target.
// Handle assignment before the starred target
for (target, val, val_ty) in

10
nac3core/src/codegen/test.rs
View File

@@ -7,26 +7,26 @@ use function_name::named;
use indexmap::IndexMap;
use indoc::indoc;
use inkwell::{
targets::{InitializationConfig, Target},
OptimizationLevel,
targets::{InitializationConfig, Target},
};
use nac3parser::{
ast::{fold::Fold, FileName, StrRef},
ast::{FileName, StrRef, fold::Fold},
parser::parse_program,
};
use parking_lot::RwLock;
use super::{
concrete_type::ConcreteTypeStore,
types::{ndarray::NDArrayType, ListType, ProxyType, RangeType},
CodeGenContext, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator,
DefaultCodeGenerator, WithCall, WorkerRegistry,
concrete_type::ConcreteTypeStore,
types::{ListType, ProxyType, RangeType, ndarray::NDArrayType},
};
use crate::{
symbol_resolver::{SymbolResolver, ValueEnum},
toplevel::{
composer::{ComposerConfig, TopLevelComposer},
DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
composer::{ComposerConfig, TopLevelComposer},
},
typecheck::{
type_inferencer::{FunctionData, IdentifierInfo, Inferencer, PrimitiveStore},

6
nac3core/src/codegen/types/exception.rs
View File

@@ -1,19 +1,19 @@
use inkwell::{
AddressSpace,
context::{AsContextRef, Context},
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
use nac3core_derive::StructFields;
use super::{
structure::{check_struct_type_matches_fields, StructField, StructFields, StructProxyType},
ProxyType,
structure::{StructField, StructFields, StructProxyType, check_struct_type_matches_fields},
};
use crate::{
codegen::{values::ExceptionValue, CodeGenContext, CodeGenerator},
codegen::{CodeGenContext, CodeGenerator, values::ExceptionValue},
typecheck::typedef::{Type, TypeEnum},
};

10
nac3core/src/codegen/types/list.rs
View File

@@ -1,8 +1,8 @@
use inkwell::{
AddressSpace, IntPredicate, OptimizationLevel,
context::Context,
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace, IntPredicate, OptimizationLevel,
};
use itertools::Itertools;
@@ -11,14 +11,14 @@ use nac3core_derive::StructFields;
use super::ProxyType;
use crate::{
codegen::{
CodeGenContext, CodeGenerator,
types::structure::{
check_struct_type_matches_fields, FieldIndexCounter, StructField, StructFields,
StructProxyType,
FieldIndexCounter, StructField, StructFields, StructProxyType,
check_struct_type_matches_fields,
},
values::ListValue,
CodeGenContext, CodeGenerator,
},
typecheck::typedef::{iter_type_vars, Type, TypeEnum},
typecheck::typedef::{Type, TypeEnum, iter_type_vars},
};
/// Proxy type for a `list` type in LLVM.

11
nac3core/src/codegen/types/ndarray/array.rs
View File

@@ -1,19 +1,18 @@
use inkwell::{
AddressSpace,
types::BasicTypeEnum,
values::{BasicValueEnum, IntValue},
AddressSpace,
};
use crate::{
codegen::{
irrt,
CodeGenContext, CodeGenerator, irrt,
stmt::gen_if_else_expr_callback,
types::{ndarray::NDArrayType, ListType, ProxyType},
types::{ListType, ProxyType, ndarray::NDArrayType},
values::{
ndarray::NDArrayValue, ArrayLikeValue, ArraySliceValue, ListValue, ProxyValue,
TypedArrayLikeAdapter, TypedArrayLikeMutator,
ArrayLikeValue, ArraySliceValue, ListValue, ProxyValue, TypedArrayLikeAdapter,
TypedArrayLikeMutator, ndarray::NDArrayValue,
},
CodeGenContext, CodeGenerator,
},
toplevel::helper::{arraylike_flatten_element_type, arraylike_get_ndims},
typecheck::typedef::{Type, TypeEnum},

6
nac3core/src/codegen/types/ndarray/broadcast.rs
View File

@@ -1,20 +1,20 @@
use inkwell::{
AddressSpace,
context::{AsContextRef, Context},
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
use nac3core_derive::StructFields;
use crate::codegen::{
CodeGenContext, CodeGenerator,
types::{
structure::{check_struct_type_matches_fields, StructField, StructFields, StructProxyType},
ProxyType,
structure::{StructField, StructFields, StructProxyType, check_struct_type_matches_fields},
},
values::ndarray::ShapeEntryValue,
CodeGenContext, CodeGenerator,
};
#[derive(Debug, PartialEq, Eq, Clone, Copy)]

12
nac3core/src/codegen/types/ndarray/contiguous.rs
View File

@@ -1,8 +1,8 @@
use inkwell::{
AddressSpace,
context::Context,
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
@@ -10,15 +10,15 @@ use nac3core_derive::StructFields;
use crate::{
codegen::{
CodeGenContext, CodeGenerator,
types::{
structure::{
check_struct_type_matches_fields, FieldIndexCounter, StructField, StructFields,
StructProxyType,
},
ProxyType,
structure::{
FieldIndexCounter, StructField, StructFields, StructProxyType,
check_struct_type_matches_fields,
},
},
values::ndarray::ContiguousNDArrayValue,
CodeGenContext, CodeGenerator,
},
toplevel::numpy::unpack_ndarray_var_tys,
typecheck::typedef::Type,

4
nac3core/src/codegen/types/ndarray/factory.rs
View File

@@ -1,12 +1,12 @@
use inkwell::{
values::{BasicValueEnum, IntValue},
IntPredicate,
values::{BasicValueEnum, IntValue},
};
use super::NDArrayType;
use crate::{
codegen::{
irrt, types::ProxyType, values::TypedArrayLikeAccessor, CodeGenContext, CodeGenerator,
CodeGenContext, CodeGenerator, irrt, types::ProxyType, values::TypedArrayLikeAccessor,
},
typecheck::typedef::Type,
};

8
nac3core/src/codegen/types/ndarray/indexing.rs
View File

@@ -1,23 +1,23 @@
use inkwell::{
AddressSpace,
context::{AsContextRef, Context},
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
use nac3core_derive::StructFields;
use crate::codegen::{
CodeGenContext, CodeGenerator,
types::{
structure::{check_struct_type_matches_fields, StructField, StructFields, StructProxyType},
ProxyType,
structure::{StructField, StructFields, StructProxyType, check_struct_type_matches_fields},
},
values::{
ndarray::{NDIndexValue, RustNDIndex},
ArrayLikeIndexer, ArraySliceValue,
ndarray::{NDIndexValue, RustNDIndex},
},
CodeGenContext, CodeGenerator,
};
#[derive(Debug, PartialEq, Eq, Clone, Copy)]

6
nac3core/src/codegen/types/ndarray/map.rs
View File

@@ -2,16 +2,16 @@ use inkwell::{types::BasicTypeEnum, values::BasicValueEnum};
use itertools::Itertools;
use crate::codegen::{
CodeGenContext, CodeGenerator,
stmt::gen_for_callback,
types::{
ndarray::{NDArrayType, NDIterType},
ProxyType,
ndarray::{NDArrayType, NDIterType},
},
values::{
ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
ArrayLikeValue, ProxyValue,
ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
},
CodeGenContext, CodeGenerator,
};
impl<'ctx> NDArrayType<'ctx> {

6
nac3core/src/codegen/types/ndarray/mod.rs
View File

@@ -1,20 +1,20 @@
use inkwell::{
AddressSpace,
context::{AsContextRef, Context},
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{BasicValue, IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
use nac3core_derive::StructFields;
use super::{
structure::{check_struct_type_matches_fields, StructField, StructFields, StructProxyType},
ProxyType,
structure::{StructField, StructFields, StructProxyType, check_struct_type_matches_fields},
};
use crate::{
codegen::{
values::{ndarray::NDArrayValue, TypedArrayLikeMutator},
values::{TypedArrayLikeMutator, ndarray::NDArrayValue},
{CodeGenContext, CodeGenerator},
},
toplevel::{helper::extract_ndims, numpy::unpack_ndarray_var_tys},

9
nac3core/src/codegen/types/ndarray/nditer.rs
View File

@@ -1,8 +1,8 @@
use inkwell::{
AddressSpace,
context::{AsContextRef, Context},
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
@@ -10,15 +10,14 @@ use nac3core_derive::StructFields;
use super::ProxyType;
use crate::codegen::{
irrt,
CodeGenContext, CodeGenerator, irrt,
types::structure::{
check_struct_type_matches_fields, StructField, StructFields, StructProxyType,
StructField, StructFields, StructProxyType, check_struct_type_matches_fields,
},
values::{
ndarray::{NDArrayValue, NDIterValue},
ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAdapter,
ndarray::{NDArrayValue, NDIterValue},
},
CodeGenContext, CodeGenerator,
};
#[derive(Debug, PartialEq, Eq, Clone, Copy)]

6
nac3core/src/codegen/types/option.rs
View File

@@ -1,14 +1,14 @@
use inkwell::{
AddressSpace,
context::Context,
types::{BasicType, BasicTypeEnum, IntType, PointerType},
values::{BasicValue, BasicValueEnum, PointerValue},
AddressSpace,
};
use super::ProxyType;
use crate::{
codegen::{values::OptionValue, CodeGenContext, CodeGenerator},
typecheck::typedef::{iter_type_vars, Type, TypeEnum},
codegen::{CodeGenContext, CodeGenerator, values::OptionValue},
typecheck::typedef::{Type, TypeEnum, iter_type_vars},
};
/// Proxy type for an `Option` type in LLVM.

2
nac3core/src/codegen/types/range.rs
View File

@@ -1,8 +1,8 @@
use inkwell::{
AddressSpace,
context::Context,
types::{AnyTypeEnum, ArrayType, BasicType, BasicTypeEnum, IntType, PointerType},
values::{ArrayValue, PointerValue},
AddressSpace,
};
use super::ProxyType;

6
nac3core/src/codegen/types/string.rs
View File

@@ -1,18 +1,18 @@
use inkwell::{
AddressSpace,
context::Context,
types::{BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{GlobalValue, IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
use nac3core_derive::StructFields;
use super::{
structure::{check_struct_type_matches_fields, StructField, StructFields},
ProxyType,
structure::{StructField, StructFields, check_struct_type_matches_fields},
};
use crate::codegen::{values::StringValue, CodeGenContext, CodeGenerator};
use crate::codegen::{CodeGenContext, CodeGenerator, values::StringValue};
/// Proxy type for a `str` type in LLVM.
#[derive(Debug, PartialEq, Eq, Clone, Copy)]

2
nac3core/src/codegen/types/structure.rs
View File

@@ -1,10 +1,10 @@
use std::marker::PhantomData;
use inkwell::{
AddressSpace,
context::AsContextRef,
types::{BasicTypeEnum, IntType, PointerType, StructType},
values::{AggregateValueEnum, BasicValue, BasicValueEnum, IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;

13
nac3core/src/codegen/types/tuple.rs
View File

@@ -7,7 +7,7 @@ use itertools::Itertools;
use super::ProxyType;
use crate::{
codegen::{values::TupleValue, CodeGenContext, CodeGenerator},
codegen::{CodeGenContext, CodeGenerator, values::TupleValue},
typecheck::typedef::{Type, TypeEnum},
};
@@ -110,7 +110,7 @@ impl<'ctx> TupleType<'ctx> {
/// The caller must ensure that the index is valid.
#[must_use]
pub unsafe fn type_at_index_unchecked(&self, index: u32) -> BasicTypeEnum<'ctx> {
self.ty.get_field_type_at_index_unchecked(index)
unsafe { self.ty.get_field_type_at_index_unchecked(index) }
}
/// Constructs a [`TupleValue`] from this type by zero-initializing the tuple value.
@@ -131,10 +131,11 @@ impl<'ctx> TupleType<'ctx> {
let values = objects.into_iter().collect_vec();
assert_eq!(values.len(), self.num_elements() as usize);
assert!(values
.iter()
.enumerate()
.all(|(i, v)| { v.get_type() == unsafe { self.type_at_index_unchecked(i as u32) } }));
assert!(
values.iter().enumerate().all(|(i, v)| {
v.get_type() == unsafe { self.type_at_index_unchecked(i as u32) }
})
);
let mut value = self.construct(name);
for (i, val) in values.into_iter().enumerate() {

12
nac3core/src/codegen/types/utils/slice.rs
View File

@@ -1,23 +1,23 @@
use inkwell::{
AddressSpace,
context::{AsContextRef, Context, ContextRef},
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
use nac3core_derive::StructFields;
use crate::codegen::{
CodeGenContext, CodeGenerator,
types::{
structure::{
check_struct_type_matches_fields, FieldIndexCounter, StructField, StructFields,
StructProxyType,
},
ProxyType,
structure::{
FieldIndexCounter, StructField, StructFields, StructProxyType,
check_struct_type_matches_fields,
},
},
values::utils::SliceValue,
CodeGenContext, CodeGenerator,
};
#[derive(Debug, PartialEq, Eq, Clone, Copy)]

2
nac3core/src/codegen/values/array.rs
View File

@@ -1,7 +1,7 @@
use inkwell::{
IntPredicate,
types::AnyTypeEnum,
values::{BasicValueEnum, IntValue, PointerValue},
IntPredicate,
};
use crate::codegen::{CodeGenContext, CodeGenerator};

10
nac3core/src/codegen/values/exception.rs
View File

@@ -6,13 +6,13 @@ use itertools::Itertools;
use nac3parser::ast::Location;
use super::{structure::StructProxyValue, ProxyValue, StringValue};
use super::{ProxyValue, StringValue, structure::StructProxyValue};
use crate::codegen::{
types::{
structure::{StructField, StructProxyType},
ExceptionType,
},
CodeGenContext, CodeGenerator,
types::{
ExceptionType,
structure::{StructField, StructProxyType},
},
};
/// Proxy type for accessing an `Exception` value in LLVM.

8
nac3core/src/codegen/values/list.rs
View File

@@ -1,17 +1,17 @@
use inkwell::{
AddressSpace, IntPredicate,
types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType},
values::{BasicValueEnum, IntValue, PointerValue, StructValue},
AddressSpace, IntPredicate,
};
use super::{
structure::StructProxyValue, ArrayLikeIndexer, ArrayLikeValue, ProxyValue,
UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
ArrayLikeIndexer, ArrayLikeValue, ProxyValue, UntypedArrayLikeAccessor,
UntypedArrayLikeMutator, structure::StructProxyValue,
};
use crate::codegen::{
types::{
structure::{StructField, StructProxyType},
ListType, ProxyType,
structure::{StructField, StructProxyType},
},
{CodeGenContext, CodeGenerator},
};

2
nac3core/src/codegen/values/mod.rs
View File

@@ -1,6 +1,6 @@
use inkwell::{types::IntType, values::BasicValue};
use super::{types::ProxyType, CodeGenContext};
use super::{CodeGenContext, types::ProxyType};
pub use array::*;
pub use exception::*;
pub use list::*;

19
nac3core/src/codegen/values/ndarray/broadcast.rs
View File

@@ -5,18 +5,17 @@ use inkwell::{
use itertools::Itertools;
use crate::codegen::{
irrt,
CodeGenContext, CodeGenerator, irrt,
types::{
ProxyType,
ndarray::{NDArrayType, ShapeEntryType},
structure::{StructField, StructProxyType},
ProxyType,
},
values::{
ndarray::NDArrayValue, structure::StructProxyValue, ArrayLikeIndexer, ArrayLikeValue,
ArraySliceValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
TypedArrayLikeMutator,
ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAccessor,
TypedArrayLikeAdapter, TypedArrayLikeMutator, ndarray::NDArrayValue,
structure::StructProxyValue,
},
CodeGenContext, CodeGenerator,
};
#[derive(Copy, Clone)]
@@ -168,9 +167,11 @@ fn broadcast_shapes<'ctx, G, Shape>(
let llvm_usize = ctx.get_size_type();
let llvm_shape_ty = ShapeEntryType::new(ctx);
assert!(in_shape_entries
.iter()
.all(|entry| entry.0.element_type(ctx, generator) == llvm_usize.into()));
assert!(
in_shape_entries
.iter()
.all(|entry| entry.0.element_type(ctx, generator) == llvm_usize.into())
);
assert_eq!(broadcast_shape.element_type(ctx, generator), llvm_usize.into());
// Prepare input shape entries to be passed to `call_nac3_ndarray_broadcast_shapes`.

6
nac3core/src/codegen/values/ndarray/contiguous.rs
View File

@@ -1,18 +1,18 @@
use inkwell::{
AddressSpace,
types::{BasicType, BasicTypeEnum, IntType},
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use super::NDArrayValue;
use crate::codegen::{
CodeGenContext, CodeGenerator,
stmt::gen_if_callback,
types::{
ndarray::{ContiguousNDArrayType, NDArrayType},
structure::{StructField, StructProxyType},
},
values::{structure::StructProxyValue, ArrayLikeValue, ProxyValue},
CodeGenContext, CodeGenerator,
values::{ArrayLikeValue, ProxyValue, structure::StructProxyValue},
};
#[derive(Copy, Clone)]

4
nac3core/src/codegen/values/ndarray/fold.rs
View File

@@ -2,9 +2,9 @@ use inkwell::values::{BasicValue, BasicValueEnum};
use super::{NDArrayValue, NDIterValue, ScalarOrNDArray};
use crate::codegen::{
stmt::{gen_for_callback, BreakContinueHooks},
types::ndarray::NDIterType,
CodeGenContext, CodeGenerator,
stmt::{BreakContinueHooks, gen_for_callback},
types::ndarray::NDIterType,
};
impl<'ctx> NDArrayValue<'ctx> {

7
nac3core/src/codegen/values/ndarray/indexing.rs
View File

@@ -1,7 +1,7 @@
use inkwell::{
AddressSpace,
types::IntType,
values::{IntValue, PointerValue, StructValue},
AddressSpace,
};
use itertools::Itertools;
@@ -9,16 +9,15 @@ use nac3parser::ast::{Expr, ExprKind};
use crate::{
codegen::{
irrt,
CodeGenContext, CodeGenerator, irrt,
types::{
ndarray::{NDArrayType, NDIndexType},
structure::{StructField, StructProxyType},
utils::SliceType,
},
values::{
ndarray::NDArrayValue, structure::StructProxyValue, utils::RustSlice, ProxyValue,
ProxyValue, ndarray::NDArrayValue, structure::StructProxyValue, utils::RustSlice,
},
CodeGenContext, CodeGenerator,
},
typecheck::typedef::Type,
};

8
nac3core/src/codegen/values/ndarray/map.rs
View File

@@ -1,11 +1,11 @@
use inkwell::{types::BasicTypeEnum, values::BasicValueEnum};
use crate::codegen::{
values::{
ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
ProxyValue,
},
CodeGenContext, CodeGenerator,
values::{
ProxyValue,
ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
},
};
impl<'ctx> NDArrayValue<'ctx> {

2
nac3core/src/codegen/values/ndarray/matmul.rs
View File

@@ -5,6 +5,7 @@ use nac3parser::ast::Operator;
use super::{NDArrayOut, NDArrayValue, RustNDIndex};
use crate::{
codegen::{
CodeGenContext, CodeGenerator,
expr::gen_binop_expr_with_values,
irrt,
stmt::gen_for_callback_incrementing,
@@ -13,7 +14,6 @@ use crate::{
ArrayLikeValue, ArraySliceValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
},
CodeGenContext, CodeGenerator,
},
toplevel::helper::arraylike_flatten_element_type,
typecheck::{magic_methods::Binop, typedef::Type},

13
nac3core/src/codegen/values/ndarray/mod.rs
View File

@@ -1,29 +1,28 @@
use std::iter::repeat_n;
use inkwell::{
AddressSpace, IntPredicate,
types::{AnyType, AnyTypeEnum, BasicType, BasicTypeEnum, IntType},
values::{BasicValue, BasicValueEnum, IntValue, PointerValue, StructValue},
AddressSpace, IntPredicate,
};
use itertools::Itertools;
use super::{
structure::StructProxyValue, ArrayLikeIndexer, ArrayLikeValue, ProxyValue, TupleValue,
TypedArrayLikeAccessor, TypedArrayLikeAdapter, TypedArrayLikeMutator, UntypedArrayLikeAccessor,
UntypedArrayLikeMutator,
ArrayLikeIndexer, ArrayLikeValue, ProxyValue, TupleValue, TypedArrayLikeAccessor,
TypedArrayLikeAdapter, TypedArrayLikeMutator, UntypedArrayLikeAccessor,
UntypedArrayLikeMutator, structure::StructProxyValue,
};
use crate::{
codegen::{
irrt,
CodeGenContext, CodeGenerator, irrt,
llvm_intrinsics::{call_int_umin, call_memcpy_generic_array},
stmt::gen_for_callback_incrementing,
type_aligned_alloca,
types::{
TupleType,
ndarray::NDArrayType,
structure::{StructField, StructProxyType},
TupleType,
},
CodeGenContext, CodeGenerator,
},
typecheck::typedef::{Type, TypeEnum},
};

9
nac3core/src/codegen/values/ndarray/nditer.rs
View File

@@ -1,19 +1,18 @@
use inkwell::{
AddressSpace,
types::{BasicType, IntType},
values::{BasicValueEnum, IntValue, PointerValue, StructValue},
AddressSpace,
};
use super::NDArrayValue;
use crate::codegen::{
irrt,
stmt::{gen_for_callback, BreakContinueHooks},
CodeGenContext, CodeGenerator, irrt,
stmt::{BreakContinueHooks, gen_for_callback},
types::{
ndarray::NDIterType,
structure::{StructField, StructProxyType},
},
values::{structure::StructProxyValue, ArraySliceValue, ProxyValue, TypedArrayLikeAdapter},
CodeGenContext, CodeGenerator,
values::{ArraySliceValue, ProxyValue, TypedArrayLikeAdapter, structure::StructProxyValue},
};
#[derive(Copy, Clone)]

4
nac3core/src/codegen/values/ndarray/shape.rs
View File

@@ -2,13 +2,13 @@ use inkwell::values::{BasicValueEnum, IntValue};
use crate::{
codegen::{
CodeGenContext, CodeGenerator,
stmt::gen_for_callback_incrementing,
types::{ListType, TupleType},
values::{
ArraySliceValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
TypedArrayLikeMutator, UntypedArrayLikeAccessor,
},
CodeGenContext, CodeGenerator,
},
typecheck::typedef::{Type, TypeEnum},
};
@@ -29,7 +29,7 @@ pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>(
generator: &mut G,
ctx: &mut CodeGenContext<'ctx, '_>,
(input_seq_ty, input_seq): (Type, BasicValueEnum<'ctx>),
) -> impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>> {
) -> impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>> + use<'ctx, G> {
let llvm_usize = ctx.get_size_type();
let zero = llvm_usize.const_zero();
let one = llvm_usize.const_int(1, false);

5
nac3core/src/codegen/values/ndarray/view.rs
View File

@@ -4,14 +4,13 @@ use inkwell::values::{IntValue, PointerValue};
use itertools::Itertools;
use crate::codegen::{
irrt,
CodeGenContext, CodeGenerator, irrt,
stmt::gen_if_callback,
types::ndarray::NDArrayType,
values::{
ndarray::{NDArrayValue, RustNDIndex},
ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
ndarray::{NDArrayValue, RustNDIndex},
},
CodeGenContext, CodeGenerator,
};
impl<'ctx> NDArrayValue<'ctx> {

2
nac3core/src/codegen/values/option.rs
View File

@@ -4,7 +4,7 @@ use inkwell::{
};
use super::ProxyValue;
use crate::codegen::{types::OptionType, CodeGenContext};
use crate::codegen::{CodeGenContext, types::OptionType};
/// Proxy type for accessing a `Option` value in LLVM.
#[derive(Copy, Clone)]

2
nac3core/src/codegen/values/range.rs
View File

@@ -4,7 +4,7 @@ use inkwell::{
};
use super::ProxyValue;
use crate::codegen::{types::RangeType, CodeGenContext, CodeGenerator};
use crate::codegen::{CodeGenContext, CodeGenerator, types::RangeType};
/// Proxy type for accessing a `range` value in LLVM.
#[derive(Copy, Clone)]

4
nac3core/src/codegen/values/string.rs
View File

@@ -4,9 +4,9 @@ use inkwell::{
};
use crate::codegen::{
types::{structure::StructField, StringType},
values::ProxyValue,
CodeGenContext,
types::{StringType, structure::StructField},
values::ProxyValue,
};
/// Proxy type for accessing a `str` value in LLVM.

2
nac3core/src/codegen/values/structure.rs
View File

@@ -1,7 +1,7 @@
use inkwell::values::{BasicValueEnum, PointerValue, StructValue};
use super::ProxyValue;
use crate::codegen::{types::structure::StructProxyType, CodeGenContext};
use crate::codegen::{CodeGenContext, types::structure::StructProxyType};
/// An LLVM value that is used to represent a corresponding structure-like value in NAC3.
pub trait StructProxyValue<'ctx>:

2
nac3core/src/codegen/values/tuple.rs
View File

@@ -4,7 +4,7 @@ use inkwell::{
};
use super::ProxyValue;
use crate::codegen::{types::TupleType, CodeGenContext};
use crate::codegen::{CodeGenContext, types::TupleType};
#[derive(Copy, Clone)]
pub struct TupleValue<'ctx> {

4
nac3core/src/codegen/values/utils/slice.rs
View File

@@ -7,12 +7,12 @@ use nac3parser::ast::Expr;
use crate::{
codegen::{
CodeGenContext, CodeGenerator,
types::{
structure::{StructField, StructProxyType},
utils::SliceType,
},
values::{structure::StructProxyValue, ProxyValue},
CodeGenContext, CodeGenerator,
values::{ProxyValue, structure::StructProxyValue},
},
typecheck::typedef::Type,
};

4
nac3core/src/symbol_resolver.rs
View File

@@ -6,14 +6,14 @@ use std::{
};
use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
use itertools::{izip, Itertools};
use itertools::{Itertools, izip};
use parking_lot::RwLock;
use nac3parser::ast::{Constant, Expr, Location, StrRef};
use crate::{
codegen::{CodeGenContext, CodeGenerator},
toplevel::{type_annotation::TypeAnnotation, DefinitionId, TopLevelDef},
toplevel::{DefinitionId, TopLevelDef, type_annotation::TypeAnnotation},
typecheck::{
type_inferencer::PrimitiveStore,
typedef::{Type, TypeEnum, Unifier, VarMap},

16
nac3core/src/toplevel/builtins.rs
View File

@@ -1,13 +1,13 @@
use std::iter::once;
use indexmap::IndexMap;
use inkwell::{values::BasicValue, IntPredicate};
use inkwell::{IntPredicate, values::BasicValue};
use strum::IntoEnumIterator;
use super::{
helper::{
arraylike_flatten_element_type, debug_assert_prim_is_allowed, extract_ndims,
make_exception_fields, PrimDef, PrimDefDetails,
PrimDef, PrimDefDetails, arraylike_flatten_element_type, debug_assert_prim_is_allowed,
extract_ndims, make_exception_fields,
},
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
*,
@@ -17,14 +17,14 @@ use crate::{
builtin_fns,
numpy::*,
stmt::{exn_constructor, gen_if_callback},
types::{ndarray::NDArrayType, RangeType},
types::{RangeType, ndarray::NDArrayType},
values::{
ndarray::{shape::parse_numpy_int_sequence, ScalarOrNDArray},
ProxyValue,
ndarray::{ScalarOrNDArray, shape::parse_numpy_int_sequence},
},
},
symbol_resolver::SymbolValue,
typecheck::typedef::{into_var_map, iter_type_vars, TypeVar, VarMap},
typecheck::typedef::{TypeVar, VarMap, into_var_map, iter_type_vars},
};
type BuiltinInfo = Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>;
@@ -479,7 +479,9 @@ impl<'a> BuiltinBuilder<'a> {
assert_eq!(simple_name, &exp_simple_name.into());
}
_ => {
panic!("Class/function variant of the constructed TopLevelDef of PrimDef {prim:?} is different than what is defined by {prim:?}")
panic!(
"Class/function variant of the constructed TopLevelDef of PrimDef {prim:?} is different than what is defined by {prim:?}"
)
}
}
}

62
nac3core/src/toplevel/composer.rs
View File

@@ -1,7 +1,7 @@
use std::rc::Rc;
use indexmap::IndexMap;
use nac3parser::ast::{fold::Fold, ExprKind, Ident};
use nac3parser::ast::{ExprKind, Ident, fold::Fold};
use super::*;
use crate::{
@@ -265,8 +265,7 @@ impl TopLevelComposer {
if self.keyword_list.contains(class_name) {
return Err(format!(
"cannot use keyword `{}` as a class name (at {})",
class_name,
ast.location
class_name, ast.location
));
}
let fully_qualified_class_name = if mod_path.is_empty() {
@@ -277,8 +276,7 @@ impl TopLevelComposer {
if !defined_names.insert(fully_qualified_class_name.into()) {
return Err(format!(
"duplicate definition of class `{}` (at {})",
class_name,
ast.location
class_name, ast.location
));
}
@@ -294,7 +292,7 @@ impl TopLevelComposer {
resolver.clone(),
fully_qualified_class_name,
Some(constructor_ty),
Some(ast.location)
Some(ast.location),
))),
None,
);
@@ -321,8 +319,7 @@ impl TopLevelComposer {
if self.keyword_list.contains(method_name) {
return Err(format!(
"cannot use keyword `{}` as a method name (at {})",
method_name,
b.location
method_name, b.location
));
}
let global_class_method_name = Self::make_class_method_name(
@@ -332,8 +329,7 @@ impl TopLevelComposer {
if !defined_names.insert(global_class_method_name.clone()) {
return Err(format!(
"class method `{}` defined twice (at {})",
global_class_method_name,
b.location
global_class_method_name, b.location
));
}
let method_def_id = self.definition_ast_list.len() + {
@@ -380,7 +376,11 @@ impl TopLevelComposer {
self.definition_ast_list.push((def, Some(ast)));
}
let result_ty = if allow_no_constructor || contains_constructor { Some(constructor_ty) } else { None };
let result_ty = if allow_no_constructor || contains_constructor {
Some(constructor_ty)
} else {
None
};
Ok((class_name, DefinitionId(class_def_id), result_ty))
}
@@ -393,8 +393,7 @@ impl TopLevelComposer {
if !defined_names.insert(global_fun_name.clone()) {
return Err(format!(
"top level function `{}` defined twice (at {})",
global_fun_name,
ast.location
global_fun_name, ast.location
));
}
@@ -408,7 +407,7 @@ impl TopLevelComposer {
// dummy here, unify with correct type later
ty_to_be_unified,
resolver,
Some(ast.location)
Some(ast.location),
))
.into(),
Some(ast),
@@ -432,7 +431,10 @@ impl TopLevelComposer {
// Make callers use `register_top_level_var` instead, as it provides more
// fine-grained control over which symbols to register, while also simplifying the
// usage of this function.
panic!("Registration of top-level Assign statements must use TopLevelComposer::register_top_level_var (at {})", ast.location);
panic!(
"Registration of top-level Assign statements must use TopLevelComposer::register_top_level_var (at {})",
ast.location
);
}
ast::StmtKind::AnnAssign { target, annotation, .. } => {
@@ -1405,14 +1407,14 @@ impl TopLevelComposer {
);
if !ok {
return Err(HashSet::from([format!(
"method {class_method_name} has same name as ancestors' method, but incompatible type"),
]));
"method {class_method_name} has same name as ancestors' method, but incompatible type"
)]));
}
}
}
class_methods_def.clear();
class_methods_def
.extend(new_child_methods.iter().map(|f| (*f.0, f.1 .0, f.1 .1)).collect_vec());
.extend(new_child_methods.iter().map(|f| (*f.0, f.1.0, f.1.1)).collect_vec());
// handle class fields
let mut new_child_fields: IndexMap<StrRef, (Type, bool)> =
@@ -1441,10 +1443,10 @@ impl TopLevelComposer {
class_fields_def.clear();
class_fields_def
.extend(new_child_fields.iter().map(|f| (*f.0, f.1 .0, f.1 .1)).collect_vec());
.extend(new_child_fields.iter().map(|f| (*f.0, f.1.0, f.1.1)).collect_vec());
class_attribute_def.clear();
class_attribute_def.extend(
new_child_attributes.iter().map(|f| (*f.0, f.1 .0, f.1 .1.clone())).collect_vec(),
new_child_attributes.iter().map(|f| (*f.0, f.1.0, f.1.1.clone())).collect_vec(),
);
Ok(())
}
@@ -1621,14 +1623,10 @@ impl TopLevelComposer {
)?;
for (f, _, _) in fields {
if !all_inited.contains(f) {
return Err(HashSet::from([
format!(
"fields `{}` of class `{}` not fully initialized in the initializer (at {})",
f,
class_name,
body[0].location,
),
]));
return Err(HashSet::from([format!(
"fields `{}` of class `{}` not fully initialized in the initializer (at {})",
f, class_name, body[0].location,
)]));
}
}
}
@@ -1900,8 +1898,8 @@ impl TopLevelComposer {
let base_repr = inferencer.unifier.stringify(*base);
let subtype_repr = inferencer.unifier.stringify(*subtype);
return Err(HashSet::from([format!(
"Expected a subtype of {base_repr}, but got {subtype_repr} (at {loc})"),
]));
"Expected a subtype of {base_repr}, but got {subtype_repr} (at {loc})"
)]));
}
};
let subtype_entry = defs[subtype_id.0].read();
@@ -1915,8 +1913,8 @@ impl TopLevelComposer {
let base_repr = inferencer.unifier.stringify(*base);
let subtype_repr = inferencer.unifier.stringify(*subtype);
return Err(HashSet::from([format!(
"Expected a subtype of {base_repr}, but got {subtype_repr} (at {loc})"),
]));
"Expected a subtype of {base_repr}, but got {subtype_repr} (at {loc})"
)]));
}
}
}

13
nac3core/src/toplevel/helper.rs
View File

@@ -8,7 +8,7 @@ use nac3parser::ast::{Constant, ExprKind, Location};
use super::{numpy::unpack_ndarray_var_tys, *};
use crate::{
symbol_resolver::SymbolValue,
typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap},
typecheck::typedef::{Mapping, TypeVarId, VarMap, into_var_map, iter_type_vars},
};
/// All primitive types and functions in nac3core.
@@ -757,7 +757,7 @@ impl TopLevelComposer {
return Err(HashSet::from([format!(
"redundant type annotation for class fields at {}",
s.location
)]))
)]));
}
ast::StmtKind::Assign { targets, .. } => {
for t in targets {
@@ -1038,7 +1038,10 @@ impl TopLevelComposer {
}
ast::ExprKind::Name { .. } | ast::ExprKind::Subscript { .. } => {
if has_base {
return Err(HashSet::from([format!("a class definition can only have at most one base class declaration and one generic declaration (at {})", b.location )]));
return Err(HashSet::from([format!(
"a class definition can only have at most one base class declaration and one generic declaration (at {})",
b.location
)]));
}
has_base = true;
// the function parse_ast_to make sure that no type var occurred in
@@ -1233,7 +1236,9 @@ pub fn arraylike_get_ndims(unifier: &mut Unifier, ty: Type) -> u64 {
};
if values.len() > 1 {
todo!("Getting num of dimensions for ndarray with more than one ndim bound is unimplemented")
todo!(
"Getting num of dimensions for ndarray with more than one ndim bound is unimplemented"
)
}
u64::try_from(values[0].clone()).unwrap()

4
nac3core/src/toplevel/test.rs
View File

@@ -5,11 +5,11 @@ use parking_lot::Mutex;
use test_case::test_case;
use nac3parser::{
ast::{fold::Fold, FileName},
ast::{FileName, fold::Fold},
parser::parse_program,
};
use super::{helper::PrimDef, DefinitionId, *};
use super::{DefinitionId, helper::PrimDef, *};
use crate::{
codegen::CodeGenContext,
symbol_resolver::{SymbolResolver, ValueEnum},

16
nac3core/src/toplevel/type_annotation.rs
View File

@@ -43,11 +43,7 @@ impl TypeAnnotation {
format!("{}{}", class_name, {
let param_list =
params.iter().map(|p| p.stringify(unifier)).collect_vec().join(", ");
if param_list.is_empty() {
String::new()
} else {
format!("[{param_list}]")
}
if param_list.is_empty() { String::new() } else { format!("[{param_list}]") }
})
}
Literal(values) => {
@@ -214,12 +210,10 @@ pub fn parse_ast_to_type_annotation_kinds<T, S: std::hash::BuildHasher + Clone>(
if no_type_var {
result
} else {
return Err(HashSet::from([
format!(
"application of type vars to generic class is not currently supported (at {})",
params_ast[0].location
),
]));
return Err(HashSet::from([format!(
"application of type vars to generic class is not currently supported (at {})",
params_ast[0].location
)]));
}
};
Ok(TypeAnnotation::CustomClass { id: obj_id, params: param_type_infos })

16
nac3core/src/typecheck/function_check.rs
View File

@@ -139,7 +139,7 @@ impl Inferencer<'_> {
return Err(HashSet::from([format!(
"type error at identifier `{}` ({}) at {}",
id, e, expr.location
)]))
)]));
}
}
}
@@ -376,13 +376,11 @@ impl Inferencer<'_> {
}
if !self.check_return_value_ty(ret_ty) {
return Err(HashSet::from([
format!(
"return value of type {} must be a primitive or a tuple of primitives at {}",
self.unifier.stringify(ret_ty),
value.location,
),
]));
return Err(HashSet::from([format!(
"return value of type {} must be a primitive or a tuple of primitives at {}",
self.unifier.stringify(ret_ty),
value.location,
)]));
}
}
}
@@ -425,7 +423,7 @@ impl Inferencer<'_> {
return Err(HashSet::from([format!(
"type error at identifier `{}` ({}) at {}",
id, e, stmt.location
)]))
)]));
}
}
}

18
nac3core/src/typecheck/magic_methods.rs
View File

@@ -1,18 +1,18 @@
use std::{cmp::max, collections::HashMap, rc::Rc};
use itertools::{iproduct, Itertools};
use itertools::{Itertools, iproduct};
use strum::IntoEnumIterator;
use nac3parser::ast::{Cmpop, Operator, StrRef, Unaryop};
use super::{
type_inferencer::*,
typedef::{into_var_map, FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap, into_var_map},
};
use crate::{
symbol_resolver::SymbolValue,
toplevel::{
helper::{extract_ndims, PrimDef},
helper::{PrimDef, extract_ndims},
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
},
};
@@ -498,11 +498,7 @@ pub fn typeof_binop(
));
}
if is_left_list {
lhs
} else {
rhs
}
if is_left_list { lhs } else { rhs }
} else if is_left_ndarray || is_right_ndarray {
typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?
} else if unifier.unioned(lhs, rhs) {
@@ -526,7 +522,9 @@ pub fn typeof_binop(
_ => {
let lhs_str = unifier.stringify(lhs);
let rhs_str = unifier.stringify(rhs);
return Err(format!("ndarray.__matmul__ only accepts ndarray operands, but left operand has type {lhs_str}, and right operand has type {rhs_str}"));
return Err(format!(
"ndarray.__matmul__ only accepts ndarray operands, but left operand has type {lhs_str}, and right operand has type {rhs_str}"
));
}
}
@@ -552,7 +550,7 @@ pub fn typeof_binop(
(0, _) | (_, 0) => {
return Err(
"ndarray.__matmul__ does not allow unsized ndarray input".to_string()
)
);
}
(1, 1) => 0,
(1, _) => rhs_ndims - 1,

20
nac3core/src/typecheck/type_error.rs
View File

@@ -108,7 +108,10 @@ impl Display for DisplayTypeError<'_> {
let expected_count = expected_min_count; // or expected_max_count
write!(f, "Too many arguments. Expected {expected_count} but got {got_count}")
} else {
write!(f, "Too many arguments. Expected {expected_min_count} to {expected_max_count} arguments but got {got_count}")
write!(
f,
"Too many arguments. Expected {expected_min_count} to {expected_max_count} arguments but got {got_count}"
)
}
}
MissingArgs { missing_arg_names } => {
@@ -123,7 +126,10 @@ impl Display for DisplayTypeError<'_> {
let expected_rhs_type_str =
self.unifier.stringify_with_notes(*expected_rhs_type, &mut notes);
write!(f, "Unsupported operand type(s) for {op_symbol}: '{lhs_type_str}' and '{rhs_type_str}' (right operand should have type {expected_rhs_type_str})")
write!(
f,
"Unsupported operand type(s) for {op_symbol}: '{lhs_type_str}' and '{rhs_type_str}' (right operand should have type {expected_rhs_type_str})"
)
}
UnsupportedComparsionOpTypes { operator, lhs_type, rhs_type, expected_rhs_type } => {
let op_symbol = operator.op_info().symbol;
@@ -133,7 +139,10 @@ impl Display for DisplayTypeError<'_> {
let expected_rhs_type_str =
self.unifier.stringify_with_notes(*expected_rhs_type, &mut notes);
write!(f, "'{op_symbol}' not supported between instances of '{lhs_type_str}' and '{rhs_type_str}' (right operand should have type {expected_rhs_type_str})")
write!(
f,
"'{op_symbol}' not supported between instances of '{lhs_type_str}' and '{rhs_type_str}' (right operand should have type {expected_rhs_type_str})"
)
}
UnknownArgName(name) => {
write!(f, "Unknown argument name: {name}")
@@ -141,7 +150,10 @@ impl Display for DisplayTypeError<'_> {
IncorrectArgType { name, expected, got } => {
let expected = self.unifier.stringify_with_notes(*expected, &mut notes);
let got = self.unifier.stringify_with_notes(*got, &mut notes);
write!(f, "Incorrect argument type for parameter {name}. Expected {expected}, but got {got}")
write!(
f,
"Incorrect argument type for parameter {name}. Expected {expected}, but got {got}"
)
}
FieldUnificationError { field, types, loc } => {
let lhs = self.unifier.stringify_with_notes(types.0, &mut notes);

35
nac3core/src/typecheck/type_inferencer/mod.rs
View File

@@ -7,29 +7,28 @@ use std::{
sync::Arc,
};
use itertools::{izip, Itertools};
use itertools::{Itertools, izip};
use nac3parser::ast::{
self,
self, Arguments, Comprehension, ExprContext, ExprKind, Ident, Located, Location, StrRef,
fold::{self, Fold},
Arguments, Comprehension, ExprContext, ExprKind, Ident, Located, Location, StrRef,
};
use super::{
magic_methods::*,
type_error::{TypeError, TypeErrorKind},
typedef::{
into_var_map, iter_type_vars, Call, CallId, FunSignature, FuncArg, Mapping, OperatorInfo,
RecordField, RecordKey, Type, TypeEnum, TypeVar, Unifier, VarMap,
Call, CallId, FunSignature, FuncArg, Mapping, OperatorInfo, RecordField, RecordKey, Type,
TypeEnum, TypeVar, Unifier, VarMap, into_var_map, iter_type_vars,
},
};
use crate::{
symbol_resolver::{SymbolResolver, SymbolValue},
toplevel::{
helper::{arraylike_flatten_element_type, arraylike_get_ndims, PrimDef},
TopLevelContext, TopLevelDef,
helper::{PrimDef, arraylike_flatten_element_type, arraylike_get_ndims},
numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
type_annotation::TypeAnnotation,
TopLevelContext, TopLevelDef,
},
};
@@ -1018,13 +1017,11 @@ impl Inferencer<'_> {
// This means the user is passing an expression of type `List`,
// but it is done so indirectly (like putting a variable referencing a `List`)
// rather than writing a List literal. We need to report an error.
return Err(HashSet::from([
format!(
"Expected list literal, tuple, or int32 for argument {arg_num} of {id} at {location}. Input argument is of type list but not a list literal.",
arg_num = arg_index + 1,
location = shape.location
)
]));
return Err(HashSet::from([format!(
"Expected list literal, tuple, or int32 for argument {arg_num} of {id} at {location}. Input argument is of type list but not a list literal.",
arg_num = arg_index + 1,
location = shape.location
)]));
}
}
TypeEnum::TTuple { ty: tuple_element_types, .. } => {
@@ -1143,7 +1140,7 @@ impl Inferencer<'_> {
)
.as_str(),
obj.location,
)
);
}
}
@@ -2277,7 +2274,7 @@ impl Inferencer<'_> {
targets.len() - 1,
rhs_tys.len()
),
*target_list_location
*target_list_location,
);
}
@@ -2335,7 +2332,7 @@ impl Inferencer<'_> {
targets.len() - 1,
rhs_tys.len()
),
*target_list_location
*target_list_location,
);
}
@@ -2562,7 +2559,9 @@ impl Inferencer<'_> {
if new_ndims_values.iter().any(|v| *v == 0) {
// TODO: Difficult to implement since now the return may both be a scalar type, or an ndarray type.
unimplemented!("Inference for ndarray subscript operator with Literal[0, ...] bound unimplemented")
unimplemented!(
"Inference for ndarray subscript operator with Literal[0, ...] bound unimplemented"
)
}
let new_ndarray_ty =

2
nac3core/src/typecheck/type_inferencer/test.rs
View File

@@ -11,7 +11,7 @@ use super::*;
use crate::{
codegen::{CodeGenContext, CodeGenerator},
symbol_resolver::ValueEnum,
toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
toplevel::{DefinitionId, TopLevelDef, helper::PrimDef},
typecheck::{magic_methods::with_fields, typedef::*},
};

10
nac3core/src/typecheck/typedef/mod.rs
View File

@@ -21,7 +21,7 @@ use super::{
};
use crate::{
symbol_resolver::SymbolValue,
toplevel::{helper::PrimDef, DefinitionId, TopLevelContext, TopLevelDef},
toplevel::{DefinitionId, TopLevelContext, TopLevelDef, helper::PrimDef},
};
#[cfg(test)]
@@ -410,11 +410,7 @@ impl Unifier {
pub fn get_call_signature(&mut self, id: CallId) -> Option<FunSignature> {
let fun = self.calls.get(id.0).unwrap().fun.borrow().unwrap();
if let TypeEnum::TFunc(sign) = &*self.get_ty(fun) {
Some(sign.clone())
} else {
None
}
if let TypeEnum::TFunc(sign) = &*self.get_ty(fun) { Some(sign.clone()) } else { None }
}
#[must_use]
@@ -1224,7 +1220,7 @@ impl Unifier {
return Err(TypeError::new(
TypeErrorKind::NoSuchField(*k, b),
field.loc,
))
));
}
}
}

2
nac3core/src/typecheck/typedef/test.rs
View File

@@ -357,7 +357,7 @@ fn test_invalid_unification(
pairs.push((t1, t2));
}
let (t1, t2) =
(env.parse(erroneous_pair.0 .0, &mapping), env.parse(erroneous_pair.0 .1, &mapping));
(env.parse(erroneous_pair.0.0, &mapping), env.parse(erroneous_pair.0.1, &mapping));
for (a, b) in pairs {
env.unifier.unify(a, b).unwrap();
}

4
nac3core/src/typecheck/unification_table.rs
View File

@@ -121,7 +121,7 @@ impl<V> UnificationTable<V> {
let (log_len, generation) = snapshot;
assert!(self.log.len() >= log_len, "snapshot restoration error");
assert!(
matches!(self.log[log_len - 1], Action::Marker { generation: gen } if gen == generation),
matches!(self.log[log_len - 1], Action::Marker { generation: r#gen } if r#gen == generation),
"snapshot restoration error"
);
for action in self.log.drain(log_len - 1..).rev() {
@@ -144,7 +144,7 @@ impl<V> UnificationTable<V> {
let (log_len, generation) = snapshot;
assert!(self.log.len() >= log_len, "snapshot discard error");
assert!(
matches!(self.log[log_len - 1], Action::Marker { generation: gen } if gen == generation),
matches!(self.log[log_len - 1], Action::Marker { generation: r#gen } if r#gen == generation),
"snapshot discard error"
);
self.log.clear();

2
nac3ld/Cargo.toml
View File

@@ -2,7 +2,7 @@
name = "nac3ld"
version = "0.1.0"
authors = ["M-Labs"]
edition = "2021"
edition = "2024"
[dependencies]
byteorder = { version = "1.5", default-features = false }

6
nac3ld/src/dwarf.rs
View File

@@ -192,11 +192,7 @@ fn read_encoded_pointer_with_pc(reader: &mut DwarfReader, encoding: u8) -> Resul
#[inline]
fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
if align.is_power_of_two() {
Ok((unrounded + align - 1) & !(align - 1))
} else {
Err(())
}
if align.is_power_of_two() { Ok((unrounded + align - 1) & !(align - 1)) } else { Err(()) }
}
/// Minimalistic structure to store everything needed for parsing FDEs to synthesize `.eh_frame_hdr`

2
nac3parser/Cargo.toml
View File

@@ -5,7 +5,7 @@ description = "Parser for python code."
authors = [ "RustPython Team", "M-Labs" ]
build = "build.rs"
license = "MIT"
edition = "2021"
edition = "2024"
[build-dependencies]
lalrpop = "0.22"

23
nac3parser/src/config_comment_helper.rs
View File

@@ -17,12 +17,10 @@ pub fn make_config_comment(
return Err(ParseError::User {
error: LexicalError {
location: com_loc,
error: LexicalErrorType::OtherError(
format!(
"config comment at top must have the same indentation with what it applies (comment at {com_loc}, statement at {stmt_loc})",
)
)
}
error: LexicalErrorType::OtherError(format!(
"config comment at top must have the same indentation with what it applies (comment at {com_loc}, statement at {stmt_loc})",
)),
},
});
};
Ok(nac3com_above
@@ -42,14 +40,11 @@ pub fn handle_small_stmt<U>(
return Err(ParseError::User {
error: LexicalError {
location: com_above_loc,
error: LexicalErrorType::OtherError(
format!(
"config comment at top must have the same indentation with what it applies (comment at {}, statement at {})",
com_above_loc,
stmts[0].location,
)
)
}
error: LexicalErrorType::OtherError(format!(
"config comment at top must have the same indentation with what it applies (comment at {}, statement at {})",
com_above_loc, stmts[0].location,
)),
},
});
}
apply_config_comments(&mut stmts[0], nac3com_above.into_iter().map(|(com, _)| com).collect());

18
nac3parser/src/fstring.rs
View File

@@ -161,14 +161,16 @@ impl<'a> FStringParser<'a> {
return Err(EmptyExpression);
}
let ret = if pred_expression_text.is_empty() {
vec![self.expr(ExprKind::FormattedValue {
value: Box::new(
parse_fstring_expr(&expression)
.map_err(|e| InvalidExpression(Box::new(e.error)))?,
),
conversion,
format_spec: spec,
})]
vec![
self.expr(ExprKind::FormattedValue {
value: Box::new(
parse_fstring_expr(&expression)
.map_err(|e| InvalidExpression(Box::new(e.error)))?,
),
conversion,
format_spec: spec,
}),
]
} else {
vec![
self.expr(ExprKind::Constant {

18
nac3parser/src/lexer.rs
View File

@@ -281,7 +281,7 @@ where
return Err(LexicalError {
error: LexicalErrorType::OtherError(format!("{e:?}")),
location: start_pos,
})
});
}
},
};
@@ -380,11 +380,7 @@ where
fn take_number(&mut self, radix: u32) -> Option<char> {
let take_char = Lexer::<T>::is_digit_of_radix(self.chr0, radix);
if take_char {
Some(self.next_char().unwrap())
} else {
None
}
if take_char { Some(self.next_char().unwrap()) } else { None }
}
/// Test if a digit is of a certain radix.
@@ -490,7 +486,7 @@ where
return Err(LexicalError {
error: LexicalErrorType::StringError,
location: start_pos,
})
});
}
}
let start_pos = self.get_pos();
@@ -503,7 +499,7 @@ where
return Err(LexicalError {
error: LexicalErrorType::StringError,
location: self.get_pos(),
})
});
}
}
}
@@ -1269,9 +1265,7 @@ where
let token = self.inner_next();
trace!(
"Lex token {:?}, nesting={:?}, indent stack: {:?}",
token,
self.nesting,
self.indentation_stack
token, self.nesting, self.indentation_stack
);
match token {
@@ -1283,7 +1277,7 @@ where
#[cfg(test)]
mod tests {
use super::{make_tokenizer, NewlineHandler, Tok};
use super::{NewlineHandler, Tok, make_tokenizer};
use nac3ast::FileName;
const WINDOWS_EOL: &str = "\r\n";

2
nac3standalone/Cargo.toml
View File

@@ -2,7 +2,7 @@
name = "nac3standalone"
version = "0.1.0"
authors = ["M-Labs"]
edition = "2021"
edition = "2024"
[features]
no-escape-analysis = ["nac3core/no-escape-analysis"]

2
nac3standalone/demo/linalg/Cargo.toml
View File

@@ -1,7 +1,7 @@
[package]
name = "linalg"
version = "0.1.0"
edition = "2021"
edition = "2024"
[lib]
crate-type = ["staticlib"]

74
nac3standalone/demo/linalg/src/lib.rs
View File

@@ -37,10 +37,10 @@ impl InputMatrix {
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_cholesky(mat1: *mut InputMatrix, out: *mut InputMatrix) {
let mat1 = mat1.as_mut().unwrap();
let out = out.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out = unsafe { out.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -80,15 +80,15 @@ pub unsafe extern "C" fn np_linalg_cholesky(mat1: *mut InputMatrix, out: *mut In
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_qr(
mat1: *mut InputMatrix,
out_q: *mut InputMatrix,
out_r: *mut InputMatrix,
) {
let mat1 = mat1.as_mut().unwrap();
let out_q = out_q.as_mut().unwrap();
let out_r = out_r.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out_q = unsafe { out_q.as_mut().unwrap() };
let out_r = unsafe { out_r.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -117,17 +117,17 @@ pub unsafe extern "C" fn np_linalg_qr(
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_svd(
mat1: *mut InputMatrix,
outu: *mut InputMatrix,
outs: *mut InputMatrix,
outvh: *mut InputMatrix,
) {
let mat1 = mat1.as_mut().unwrap();
let outu = outu.as_mut().unwrap();
let outs = outs.as_mut().unwrap();
let outvh = outvh.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let outu = unsafe { outu.as_mut().unwrap() };
let outs = unsafe { outs.as_mut().unwrap() };
let outvh = unsafe { outvh.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -155,10 +155,10 @@ pub unsafe extern "C" fn np_linalg_svd(
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_inv(mat1: *mut InputMatrix, out: *mut InputMatrix) {
let mat1 = mat1.as_mut().unwrap();
let out = out.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out = unsafe { out.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -194,10 +194,10 @@ pub unsafe extern "C" fn np_linalg_inv(mat1: *mut InputMatrix, out: *mut InputMa
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_pinv(mat1: *mut InputMatrix, out: *mut InputMatrix) {
let mat1 = mat1.as_mut().unwrap();
let out = out.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out = unsafe { out.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -225,15 +225,15 @@ pub unsafe extern "C" fn np_linalg_pinv(mat1: *mut InputMatrix, out: *mut InputM
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_matrix_power(
mat1: *mut InputMatrix,
mat2: *mut InputMatrix,
out: *mut InputMatrix,
) {
let mat1 = mat1.as_mut().unwrap();
let mat2 = mat2.as_mut().unwrap();
let out = out.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let mat2 = unsafe { mat2.as_mut().unwrap() };
let out = unsafe { out.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D", mat1.ndims);
@@ -270,10 +270,10 @@ pub unsafe extern "C" fn np_linalg_matrix_power(
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn np_linalg_det(mat1: *mut InputMatrix, out: *mut InputMatrix) {
let mat1 = mat1.as_mut().unwrap();
let out = out.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out = unsafe { out.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -295,15 +295,15 @@ pub unsafe extern "C" fn np_linalg_det(mat1: *mut InputMatrix, out: *mut InputMa
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn sp_linalg_lu(
mat1: *mut InputMatrix,
out_l: *mut InputMatrix,
out_u: *mut InputMatrix,
) {
let mat1 = mat1.as_mut().unwrap();
let out_l = out_l.as_mut().unwrap();
let out_u = out_u.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out_l = unsafe { out_l.as_mut().unwrap() };
let out_u = unsafe { out_u.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -328,15 +328,15 @@ pub unsafe extern "C" fn sp_linalg_lu(
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn sp_linalg_schur(
mat1: *mut InputMatrix,
out_t: *mut InputMatrix,
out_z: *mut InputMatrix,
) {
let mat1 = mat1.as_mut().unwrap();
let out_t = out_t.as_mut().unwrap();
let out_z = out_z.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out_t = unsafe { out_t.as_mut().unwrap() };
let out_z = unsafe { out_z.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
@@ -368,15 +368,15 @@ pub unsafe extern "C" fn sp_linalg_schur(
/// # Safety
///
/// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
#[no_mangle]
#[unsafe(no_mangle)]
pub unsafe extern "C" fn sp_linalg_hessenberg(
mat1: *mut InputMatrix,
out_h: *mut InputMatrix,
out_q: *mut InputMatrix,
) {
let mat1 = mat1.as_mut().unwrap();
let out_h = out_h.as_mut().unwrap();
let out_q = out_q.as_mut().unwrap();
let mat1 = unsafe { mat1.as_mut().unwrap() };
let out_h = unsafe { out_h.as_mut().unwrap() };
let out_q = unsafe { out_q.as_mut().unwrap() };
if mat1.ndims != 2 {
let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);

Some files were not shown because too many files have changed in this diff Show More