diff --git a/Cargo.lock b/Cargo.lock index 4523aa7..0b34ba8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -357,6 +357,17 @@ dependencies = [ "tracing", ] +[[package]] +name = "concrete_check" +version = "0.1.0" +dependencies = [ + "ariadne", + "concrete_ast", + "concrete_session", + "itertools 0.12.0", + "thiserror", +] + [[package]] name = "concrete_codegen_mlir" version = "0.1.0" @@ -364,6 +375,7 @@ dependencies = [ "bumpalo", "cc", "concrete_ast", + "concrete_check", "concrete_session", "itertools 0.12.0", "llvm-sys", @@ -379,6 +391,7 @@ dependencies = [ "ariadne", "clap", "concrete_ast", + "concrete_check", "concrete_codegen_mlir", "concrete_parser", "concrete_session", @@ -409,10 +422,6 @@ dependencies = [ "ariadne", ] -[[package]] -name = "concrete_type_checker" -version = "0.1.0" - [[package]] name = "convert_case" version = "0.6.0" @@ -978,9 +987,9 @@ dependencies = [ [[package]] name = "melior" -version = "0.15.1" +version = "0.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "758bbd4448db9e994578ab48a6da5210512378f70ac1632cc8c2ae0fbd6c21b5" +checksum = "878012ddccd6fdd099a4d98cebdecbaed9bc5eb325d0778ab9d4f4a52c67c18e" dependencies = [ "dashmap", "melior-macro", diff --git a/Cargo.toml b/Cargo.toml index d8e9029..27930ee 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [workspace] resolver = "2" -members = [ "crates/concrete","crates/concrete_ast", "crates/concrete_codegen_mlir", "crates/concrete_driver", "crates/concrete_parser", "crates/concrete_session", "crates/concrete_type_checker"] +members = [ "crates/concrete","crates/concrete_ast", "crates/concrete_codegen_mlir", "crates/concrete_driver", "crates/concrete_parser", "crates/concrete_session", "crates/concrete_check"] [profile.release] lto = true diff --git a/crates/concrete_ast/src/common.rs b/crates/concrete_ast/src/common.rs index c94d349..ef7a45f 100644 --- a/crates/concrete_ast/src/common.rs +++ b/crates/concrete_ast/src/common.rs @@ -1,3 +1,5 @@ +use std::ops::Range; + #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Span { pub from: usize, @@ -10,6 +12,12 @@ impl Span { } } +impl From for Range { + fn from(val: Span) -> Self { + val.from..val.to + } +} + #[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)] pub struct DocString { contents: String, diff --git a/crates/concrete_ast/src/expressions.rs b/crates/concrete_ast/src/expressions.rs index 0abd876..12f8752 100644 --- a/crates/concrete_ast/src/expressions.rs +++ b/crates/concrete_ast/src/expressions.rs @@ -1,8 +1,12 @@ -use crate::{common::Ident, statements::Statement, types::TypeSpec}; +use crate::{ + common::Ident, + statements::Statement, + types::{RefType, TypeSpec}, +}; #[derive(Clone, Debug, Eq, PartialEq)] pub enum Expression { - Simple(SimpleExpr), + Value(ValueExpr), FnCall(FnCallOp), Match(MatchExpr), If(IfExpr), @@ -10,15 +14,16 @@ pub enum Expression { BinaryOp(Box, BinaryOp, Box), } -// needed for match variants and array accesses #[derive(Clone, Debug, Eq, PartialEq)] -pub enum SimpleExpr { +pub enum ValueExpr { ConstBool(bool), ConstChar(char), ConstInt(u64), ConstFloat(()), ConstStr(String), Path(PathOp), + Deref(PathOp), + AsRef { path: PathOp, ref_type: RefType }, } #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -83,14 +88,14 @@ pub struct IfExpr { #[derive(Clone, Debug, Eq, PartialEq)] pub struct MatchVariant { - pub case: SimpleExpr, + pub case: ValueExpr, pub block: Vec, } #[derive(Clone, Debug, Eq, PartialEq)] pub enum PathSegment { FieldAccess(Ident), - ArrayIndex(SimpleExpr), + ArrayIndex(ValueExpr), } #[derive(Clone, Debug, Eq, PartialEq)] diff --git a/crates/concrete_ast/src/functions.rs b/crates/concrete_ast/src/functions.rs index 3635665..c0e1539 100644 --- a/crates/concrete_ast/src/functions.rs +++ b/crates/concrete_ast/src/functions.rs @@ -1,5 +1,5 @@ use crate::{ - common::{DocString, GenericParam, Ident}, + common::{DocString, GenericParam, Ident, Span}, statements::Statement, types::TypeSpec, }; @@ -17,6 +17,7 @@ pub struct FunctionDecl { pub struct FunctionDef { pub decl: FunctionDecl, pub body: Vec, + pub span: Span, } #[derive(Clone, Debug, Eq, Hash, PartialEq)] diff --git a/crates/concrete_ast/src/imports.rs b/crates/concrete_ast/src/imports.rs index f158b9b..615230c 100644 --- a/crates/concrete_ast/src/imports.rs +++ b/crates/concrete_ast/src/imports.rs @@ -1,7 +1,8 @@ -use crate::common::Ident; +use crate::common::{Ident, Span}; #[derive(Clone, Debug, Eq, Hash, PartialEq)] pub struct ImportStmt { pub module: Vec, pub symbols: Vec, + pub span: Span, } diff --git a/crates/concrete_ast/src/modules.rs b/crates/concrete_ast/src/modules.rs index d67b590..5ed22cf 100644 --- a/crates/concrete_ast/src/modules.rs +++ b/crates/concrete_ast/src/modules.rs @@ -1,5 +1,5 @@ use crate::{ - common::{DocString, Ident}, + common::{DocString, Ident, Span}, constants::ConstantDef, functions::FunctionDef, imports::ImportStmt, @@ -13,6 +13,7 @@ pub struct Module { pub imports: Vec, pub name: Ident, pub contents: Vec, + pub span: Span, } #[derive(Clone, Debug, Eq, PartialEq)] diff --git a/crates/concrete_ast/src/types.rs b/crates/concrete_ast/src/types.rs index 450f8ee..6454c4a 100644 --- a/crates/concrete_ast/src/types.rs +++ b/crates/concrete_ast/src/types.rs @@ -1,15 +1,48 @@ use crate::common::{DocString, Ident, Span}; +#[derive(Clone, Debug, Eq, Hash, PartialEq, Copy)] +pub enum RefType { + Borrow, + MutBorrow, +} + #[derive(Clone, Debug, Eq, Hash, PartialEq)] pub enum TypeSpec { Simple { name: Ident, + is_ref: Option, + span: Span, }, Generic { name: Ident, + is_ref: Option, type_params: Vec, span: Span, }, + Array { + of_type: Box, + size: Option, + is_ref: Option, + span: Span, + }, +} + +impl TypeSpec { + pub fn is_ref(&self) -> Option { + match self { + TypeSpec::Simple { is_ref, .. } => *is_ref, + TypeSpec::Generic { is_ref, .. } => *is_ref, + TypeSpec::Array { is_ref, .. } => *is_ref, + } + } + + pub fn get_name(&self) -> String { + match self { + TypeSpec::Simple { name, .. } => name.name.clone(), + TypeSpec::Generic { name, .. } => name.name.clone(), + TypeSpec::Array { of_type, .. } => format!("[{}]", of_type.get_name()), + } + } } #[derive(Clone, Debug, Eq, Hash, PartialEq)] diff --git a/crates/concrete_check/Cargo.toml b/crates/concrete_check/Cargo.toml new file mode 100644 index 0000000..b326b82 --- /dev/null +++ b/crates/concrete_check/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "concrete_check" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +ariadne = { version = "0.4.0", features = ["auto-color"] } +concrete_ast = { version = "0.1.0", path = "../concrete_ast" } +concrete_session = { version = "0.1.0", path = "../concrete_session" } +itertools = "0.12.0" +thiserror = "1.0.56" diff --git a/crates/concrete_codegen_mlir/src/ast_helper.rs b/crates/concrete_check/src/ast_helper.rs similarity index 100% rename from crates/concrete_codegen_mlir/src/ast_helper.rs rename to crates/concrete_check/src/ast_helper.rs diff --git a/crates/concrete_check/src/lib.rs b/crates/concrete_check/src/lib.rs new file mode 100644 index 0000000..a5f02c7 --- /dev/null +++ b/crates/concrete_check/src/lib.rs @@ -0,0 +1,345 @@ +use std::{collections::HashMap, ops::Range}; + +use ariadne::{ColorGenerator, Label, Report, ReportKind}; +use ast_helper::{AstHelper, ModuleInfo}; +use concrete_ast::{ + common::Ident, + constants::ConstantDef, + functions::FunctionDef, + imports::ImportStmt, + modules::{Module, ModuleDefItem}, + statements::Statement, + types::TypeSpec, + Program, +}; +use concrete_session::Session; +use itertools::Itertools; +use thiserror::Error; + +pub mod ast_helper; + +#[derive(Error, Debug, Clone)] +pub enum CheckError { + #[error("import not found {:?} in module {}", import, module.name.name)] + ImportModuleMissing { module: Module, import: ImportStmt }, + #[error("import symbol {:?} not found in module {}", symbol, module.name.name)] + ImportSymbolMissing { + module: Module, + import: ImportStmt, + symbol: Ident, + }, + #[error("type not found {:?}", type_spec)] + TypeNotFound { type_spec: TypeSpec }, +} + +impl CheckError { + pub fn to_report<'s>(&self, session: &'s Session) -> Report<'s, (String, Range)> { + let path = session.file_path.display().to_string(); + let mut colors = ColorGenerator::new(); + colors.next(); + + match self { + CheckError::ImportModuleMissing { module, import } => { + let contex_module_span = module.span; + let span = { + let mut span = import + .module + .first() + .expect("module path can't be empty") + .span; + span.to = import + .module + .last() + .expect("module path can't be empty") + .span + .to; + span + }; + let offset = import.module[0].span.from; + Report::build(ReportKind::Error, path.clone(), offset) + .with_code("E1") + .with_label( + Label::new((path.clone(), contex_module_span.into())) + .with_message(format!("In module {:?}.", module.name.name)), + ) + .with_label( + Label::new((path, span.into())) + .with_message(format!( + "Module {:?} not found.", + import.module.iter().map(|x| &x.name).join(".") + )) + .with_color(colors.next()), + ) + .with_message("Unresolved import.") + .finish() + } + CheckError::ImportSymbolMissing { + module, + import, + symbol, + } => { + let contex_module_span = module.span; + let import_span = import.span; + let offset = symbol.span.from; + Report::build(ReportKind::Error, path.clone(), offset) + .with_code("E2") + .with_label( + Label::new((path.clone(), contex_module_span.into())) + .with_message(format!("In module {:?}.", module.name.name)), + ) + .with_label( + Label::new((path.clone(), import_span.into())) + .with_message("In this import statement"), + ) + .with_label( + Label::new((path, symbol.span.into())) + .with_message(format!("Failed to find symbol {:?}", symbol.name)) + .with_color(colors.next()), + ) + .with_message("Unresolved import.") + .finish() + } + CheckError::TypeNotFound { type_spec } => { + let span = match type_spec { + TypeSpec::Simple { span, .. } => span, + TypeSpec::Generic { span, .. } => span, + TypeSpec::Array { span, .. } => span, + }; + Report::build(ReportKind::Error, path.clone(), span.from) + .with_code("E3") + .with_label( + Label::new((path, (*span).into())) + .with_message(format!("Failed to find type {:?}", type_spec.get_name())) + .with_color(colors.next()), + ) + .with_message(format!("Unresolved type {:?}.", type_spec.get_name())) + .finish() + } + } + } +} + +#[allow(unused)] +#[derive(Debug, Clone)] +struct ScopeContext<'parent> { + pub locals: HashMap, + pub function: Option, + pub imports: HashMap>, + pub module_info: &'parent ModuleInfo<'parent>, +} + +#[allow(unused)] +#[derive(Debug, Clone)] +struct LocalVar { + pub type_spec: TypeSpec, +} + +#[allow(unused)] +impl<'parent> ScopeContext<'parent> { + pub fn get_function(&self, local_name: &str) -> Option<&FunctionDef> { + if let Some(module) = self.imports.get(local_name) { + // a import + module.functions.get(local_name).copied() + } else { + self.module_info.functions.get(local_name).copied() + } + } + + fn resolve_type(&self, name: &str) -> Option { + Some(match name { + "u64" | "i64" => name.to_string(), + "u32" | "i32" => name.to_string(), + "u16" | "i16" => name.to_string(), + "u8" | "i8" => name.to_string(), + "f32" => name.to_string(), + "f64" => name.to_string(), + "bool" => name.to_string(), + name => { + if let Some(module) = self.imports.get(name) { + // a import + self.resolve_type_spec(&module.types.get(name)?.value)? + } else { + self.resolve_type_spec(&self.module_info.types.get(name)?.value)? + } + } + }) + } + + fn resolve_type_spec(&self, spec: &TypeSpec) -> Option { + match spec.is_ref() { + Some(_) => Some(format!("&{}", self.resolve_type_spec_ref(spec)?)), + None => self.resolve_type_spec_ref(spec), + } + } + + /// Resolves the type this ref points to. + fn resolve_type_spec_ref(&self, spec: &TypeSpec) -> Option { + match spec { + TypeSpec::Simple { name, .. } => self.resolve_type(&name.name), + TypeSpec::Generic { name, .. } => self.resolve_type(&name.name), + TypeSpec::Array { .. } => { + todo!("implement arrays") + } + } + } +} + +pub fn check_program(program: &Program) -> Result<(), Vec> { + let helper = AstHelper::new(program); + + let mut errors = Vec::new(); + + for module in &program.modules { + let module_info = helper.modules.get(&module.name.name).unwrap(); + if let Err(e) = check_module(module, &helper, module_info) { + errors.extend(e); + } + } + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} + +pub fn check_module<'p, 'x: 'p>( + module: &Module, + helper: &AstHelper<'p>, + module_info: &ModuleInfo<'p>, +) -> Result<(), Vec> { + let mut errors = Vec::new(); + + let mut scope_ctx = ScopeContext { + locals: HashMap::new(), + function: None, + imports: HashMap::new(), + module_info, + }; + + // check modules + for import in &module.imports { + let target_module = helper.get_module_from_import(&import.module); + + if target_module.is_none() { + errors.push(CheckError::ImportModuleMissing { + module: module.clone(), + import: import.clone(), + }); + continue; + } + + let target_module = target_module.unwrap(); + + // check if symbol exists + for symbol in &import.symbols { + let name = &symbol.name; + let exists = target_module.functions.get(name).is_some() + || target_module.constants.get(name).is_some() + || target_module.structs.get(name).is_some() + || target_module.types.get(name).is_some(); + + if !exists { + errors.push(CheckError::ImportSymbolMissing { + module: module.clone(), + import: import.clone(), + symbol: symbol.clone(), + }); + continue; + } + + scope_ctx.imports.insert(symbol.name.clone(), target_module); + } + } + + for stmt in &module.contents { + match stmt { + ModuleDefItem::Constant(info) => { + if let Err(e) = check_constant(info, &scope_ctx, helper, module_info) { + errors.extend(e); + } + } + ModuleDefItem::Function(info) => { + scope_ctx.function = Some(info.clone()); + if let Err(e) = check_function(info, &scope_ctx, helper, module_info) { + errors.extend(e); + } + } + ModuleDefItem::Struct(_) => {} + ModuleDefItem::Type(_) => {} + ModuleDefItem::Module(info) => { + let module_info = module_info.modules.get(&info.name.name).unwrap(); + if let Err(e) = check_module(info, helper, module_info) { + errors.extend(e); + } + } + } + } + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} + +fn check_function<'p>( + info: &FunctionDef, + scope_ctx: &ScopeContext<'p>, + _helper: &AstHelper<'p>, + _module_info: &ModuleInfo<'p>, +) -> Result<(), Vec> { + let mut errors = Vec::new(); + + for param in &info.decl.params { + if scope_ctx.resolve_type_spec(¶m.r#type).is_none() { + errors.push(CheckError::TypeNotFound { + type_spec: param.r#type.clone(), + }) + } + } + + if let Some(ret_type) = info.decl.ret_type.as_ref() { + if scope_ctx.resolve_type_spec(ret_type).is_none() { + errors.push(CheckError::TypeNotFound { + type_spec: ret_type.clone(), + }) + } + } + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} + +fn check_constant<'p>( + _info: &ConstantDef, + _scope_ctx: &ScopeContext<'p>, + _helper: &AstHelper<'p>, + _module_info: &ModuleInfo<'p>, +) -> Result<(), Vec> { + let errors = Vec::new(); + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} + +fn _check_statement<'p>( + _info: &Statement, + _scope_ctx: &mut ScopeContext<'p>, + _helper: &AstHelper<'p>, + _module_info: &ModuleInfo<'p>, +) -> Result<(), Vec> { + let errors = Vec::new(); + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} diff --git a/crates/concrete_codegen_mlir/Cargo.toml b/crates/concrete_codegen_mlir/Cargo.toml index 19ce13e..6013882 100644 --- a/crates/concrete_codegen_mlir/Cargo.toml +++ b/crates/concrete_codegen_mlir/Cargo.toml @@ -8,10 +8,11 @@ edition = "2021" [dependencies] bumpalo = { version = "3.14.0", features = ["std"] } concrete_ast = { path = "../concrete_ast"} +concrete_check = { version = "0.1.0", path = "../concrete_check" } concrete_session = { path = "../concrete_session"} itertools = "0.12.0" llvm-sys = "170.0.1" -melior = { version = "0.15.0", features = ["ods-dialects"] } +melior = { version = "0.15.2", features = ["ods-dialects"] } mlir-sys = "0.2.1" tracing.workspace = true diff --git a/crates/concrete_codegen_mlir/src/codegen.rs b/crates/concrete_codegen_mlir/src/codegen.rs index a4f10bd..4bcae6f 100644 --- a/crates/concrete_codegen_mlir/src/codegen.rs +++ b/crates/concrete_codegen_mlir/src/codegen.rs @@ -3,7 +3,7 @@ use std::{collections::HashMap, error::Error}; use bumpalo::Bump; use concrete_ast::{ expressions::{ - ArithOp, BinaryOp, CmpOp, Expression, FnCallOp, IfExpr, LogicOp, PathOp, SimpleExpr, + ArithOp, BinaryOp, CmpOp, Expression, FnCallOp, IfExpr, LogicOp, PathOp, ValueExpr, }, functions::FunctionDef, modules::{Module, ModuleDefItem}, @@ -11,6 +11,7 @@ use concrete_ast::{ types::TypeSpec, Program, }; +use concrete_check::ast_helper::{AstHelper, ModuleInfo}; use concrete_session::Session; use melior::{ dialect::{ @@ -26,8 +27,6 @@ use melior::{ Context as MeliorContext, }; -use crate::ast_helper::{AstHelper, ModuleInfo}; - pub fn compile_program( session: &Session, ctx: &MeliorContext, @@ -136,7 +135,25 @@ impl<'ctx, 'parent> ScopeContext<'ctx, 'parent> { "f32" => Type::float32(context), "f64" => Type::float64(context), "bool" => IntegerType::new(context, 1).into(), - _ => todo!("custom type lookup"), + name => { + if let Some(module) = self.imports.get(name) { + // a import + self.resolve_type_spec( + context, + &module.types.get(name).expect("failed to find type").value, + )? + } else { + self.resolve_type_spec( + context, + &self + .module_info + .types + .get(name) + .expect("failed to find type") + .value, + )? + } + } }) } @@ -144,26 +161,48 @@ impl<'ctx, 'parent> ScopeContext<'ctx, 'parent> { &self, context: &'ctx MeliorContext, spec: &TypeSpec, + ) -> Result, Box> { + match spec.is_ref() { + Some(_) => { + Ok( + MemRefType::new(self.resolve_type_spec_ref(context, spec)?, &[], None, None) + .into(), + ) + } + None => self.resolve_type_spec_ref(context, spec), + } + } + + /// Resolves the type this ref points to. + fn resolve_type_spec_ref( + &self, + context: &'ctx MeliorContext, + spec: &TypeSpec, ) -> Result, Box> { Ok(match spec { - TypeSpec::Simple { name } => self.resolve_type(context, &name.name)?, + TypeSpec::Simple { name, .. } => self.resolve_type(context, &name.name)?, TypeSpec::Generic { name, .. } => self.resolve_type(context, &name.name)?, + TypeSpec::Array { .. } => { + todo!("implement arrays") + } }) } fn is_type_signed(&self, type_info: &TypeSpec) -> bool { let signed = ["i8", "i16", "i32", "i64", "i128"]; match type_info { - TypeSpec::Simple { name } => signed.contains(&name.name.as_str()), + TypeSpec::Simple { name, .. } => signed.contains(&name.name.as_str()), TypeSpec::Generic { name, .. } => signed.contains(&name.name.as_str()), + TypeSpec::Array { .. } => unreachable!(), } } fn is_float(&self, type_info: &TypeSpec) -> bool { let signed = ["f32", "f64"]; match type_info { - TypeSpec::Simple { name } => signed.contains(&name.name.as_str()), + TypeSpec::Simple { name, .. } => signed.contains(&name.name.as_str()), TypeSpec::Generic { name, .. } => signed.contains(&name.name.as_str()), + TypeSpec::Array { .. } => unreachable!(), } } } @@ -176,8 +215,6 @@ fn compile_module( module_info: &ModuleInfo<'_>, module: &Module, ) -> Result<(), Box> { - // todo: handle imports - let body = mlir_module.body(); let mut imports = HashMap::new(); @@ -508,6 +545,8 @@ fn compile_let_stmt<'ctx, 'parent: 'ctx>( ) -> Result<(), Box> { match &info.target { LetStmtTarget::Simple { name, r#type } => { + let location = get_location(context, session, name.span.from); + let value = compile_expression( session, context, @@ -517,10 +556,7 @@ fn compile_let_stmt<'ctx, 'parent: 'ctx>( &info.value, Some(r#type), )?; - - let location = get_location(context, session, name.span.from); - - let memref_type = MemRefType::new(value.r#type(), &[1], None, None); + let memref_type = MemRefType::new(value.r#type(), &[], None, None); let alloca: Value = block .append_operation(memref::alloca( @@ -533,15 +569,8 @@ fn compile_let_stmt<'ctx, 'parent: 'ctx>( )) .result(0)? .into(); - let k0 = block - .append_operation(arith::constant( - context, - IntegerAttribute::new(0, Type::index(context)).into(), - location, - )) - .result(0)? - .into(); - block.append_operation(memref::store(value, alloca, &[k0], location)); + + block.append_operation(memref::store(value, alloca, &[], location)); scope_ctx .locals @@ -583,15 +612,7 @@ fn compile_assign_stmt<'ctx, 'parent: 'ctx>( Some(&local.type_spec), )?; - let k0 = block - .append_operation(arith::constant( - context, - IntegerAttribute::new(0, Type::index(context)).into(), - location, - )) - .result(0)? - .into(); - block.append_operation(memref::store(value, local.value, &[k0], location)); + block.append_operation(memref::store(value, local.value, &[], location)); Ok(()) } @@ -635,39 +656,9 @@ fn compile_expression<'ctx, 'parent: 'ctx>( ) -> Result, Box> { let location = Location::unknown(context); match info { - Expression::Simple(simple) => match simple { - SimpleExpr::ConstBool(value) => { - let value = - IntegerAttribute::new((*value).into(), IntegerType::new(context, 1).into()); - Ok(block - .append_operation(arith::constant(context, value.into(), location)) - .result(0)? - .into()) - } - SimpleExpr::ConstChar(value) => { - let value = - IntegerAttribute::new((*value) as i64, IntegerType::new(context, 32).into()); - Ok(block - .append_operation(arith::constant(context, value.into(), location)) - .result(0)? - .into()) - } - SimpleExpr::ConstInt(value) => { - let int_type = if let Some(type_info) = type_info { - scope_ctx.resolve_type_spec(context, type_info)? - } else { - IntegerType::new(context, 64).into() - }; - let value = IntegerAttribute::new((*value) as i64, int_type); - Ok(block - .append_operation(arith::constant(context, value.into(), location)) - .result(0)? - .into()) - } - SimpleExpr::ConstFloat(_) => todo!(), - SimpleExpr::ConstStr(_) => todo!(), - SimpleExpr::Path(value) => compile_path_op(session, context, scope_ctx, block, value), - }, + Expression::Value(value) => compile_value_expr( + session, context, scope_ctx, _helper, block, value, type_info, + ), Expression::FnCall(value) => { compile_fn_call(session, context, scope_ctx, _helper, block, value) } @@ -798,6 +789,59 @@ fn compile_expression<'ctx, 'parent: 'ctx>( } } +fn compile_value_expr<'ctx, 'parent: 'ctx>( + session: &Session, + context: &'ctx MeliorContext, + scope_ctx: &mut ScopeContext<'ctx, 'parent>, + _helper: &BlockHelper<'ctx, 'parent>, + block: &'parent Block<'ctx>, + value: &ValueExpr, + type_info: Option<&TypeSpec>, +) -> Result, Box> { + tracing::debug!("compiling value_expr for {:?}", value); + let location = Location::unknown(context); + match value { + ValueExpr::ConstBool(value) => { + let value = IntegerAttribute::new((*value).into(), IntegerType::new(context, 1).into()); + Ok(block + .append_operation(arith::constant(context, value.into(), location)) + .result(0)? + .into()) + } + ValueExpr::ConstChar(value) => { + let value = + IntegerAttribute::new((*value) as i64, IntegerType::new(context, 32).into()); + Ok(block + .append_operation(arith::constant(context, value.into(), location)) + .result(0)? + .into()) + } + ValueExpr::ConstInt(value) => { + let int_type = if let Some(type_info) = type_info { + scope_ctx.resolve_type_spec(context, type_info)? + } else { + IntegerType::new(context, 64).into() + }; + let value = IntegerAttribute::new((*value) as i64, int_type); + Ok(block + .append_operation(arith::constant(context, value.into(), location)) + .result(0)? + .into()) + } + ValueExpr::ConstFloat(_) => todo!(), + ValueExpr::ConstStr(_) => todo!(), + ValueExpr::Path(value) => { + compile_path_op(session, context, scope_ctx, _helper, block, value) + } + ValueExpr::Deref(value) => { + compile_deref(session, context, scope_ctx, _helper, block, value) + } + ValueExpr::AsRef { path, ref_type: _ } => { + compile_asref(session, context, scope_ctx, _helper, block, path) + } + } +} + fn compile_fn_call<'ctx, 'parent: 'ctx>( session: &Session, context: &'ctx MeliorContext, @@ -806,6 +850,7 @@ fn compile_fn_call<'ctx, 'parent: 'ctx>( block: &'parent Block<'ctx>, info: &FnCallOp, ) -> Result, Box> { + tracing::debug!("compiling fncall: {:?}", info); let mut args = Vec::with_capacity(info.args.len()); let location = get_location(context, session, info.target.span.from); @@ -857,34 +902,84 @@ fn compile_path_op<'ctx, 'parent: 'ctx>( session: &Session, context: &'ctx MeliorContext, scope_ctx: &mut ScopeContext<'ctx, 'parent>, + _helper: &BlockHelper<'ctx, 'parent>, block: &'parent Block<'ctx>, path: &PathOp, ) -> Result, Box> { - // For now only simple variables work. + tracing::debug!("compiling pathop {:?}", path); + // For now only simple and array variables work. // TODO: implement properly, this requires having structs implemented. let local = scope_ctx .locals .get(&path.first.name) - .expect("local not found"); + .unwrap_or_else(|| panic!("local {} not found", path.first.name)) + .clone(); let location = get_location(context, session, path.first.span.from); - if local.alloca { - let k0 = block - .append_operation(arith::constant( - context, - IntegerAttribute::new(0, Type::index(context)).into(), - location, - )) + let value = if local.alloca { + block + .append_operation(memref::load(local.value, &[], location)) .result(0)? - .into(); - let value = block - .append_operation(memref::load(local.value, &[k0], location)) + .into() + } else { + local.value + }; + + Ok(value) +} + +fn compile_deref<'ctx, 'parent: 'ctx>( + session: &Session, + context: &'ctx MeliorContext, + scope_ctx: &mut ScopeContext<'ctx, 'parent>, + _helper: &BlockHelper<'ctx, 'parent>, + block: &'parent Block<'ctx>, + path: &PathOp, +) -> Result, Box> { + tracing::debug!("compiling deref for {:?}", path); + let local = scope_ctx + .locals + .get(&path.first.name) + .expect("local not found") + .clone(); + + let location = get_location(context, session, path.first.span.from); + + let mut value = block + .append_operation(memref::load(local.value, &[], location)) + .result(0)? + .into(); + + if local.alloca { + value = block + .append_operation(memref::load(value, &[], location)) .result(0)? .into(); - Ok(value) - } else { - Ok(local.value) } + + Ok(value) +} + +fn compile_asref<'ctx, 'parent: 'ctx>( + _session: &Session, + _context: &'ctx MeliorContext, + scope_ctx: &mut ScopeContext<'ctx, 'parent>, + _helper: &BlockHelper<'ctx, 'parent>, + _block: &'parent Block<'ctx>, + path: &PathOp, +) -> Result, Box> { + tracing::debug!("compiling asref for {:?}", path); + let local = scope_ctx + .locals + .get(&path.first.name) + .expect("local not found") + .clone(); + + if !local.alloca { + panic!("can only take refs to non register values"); + } + + Ok(local.value) } diff --git a/crates/concrete_codegen_mlir/src/lib.rs b/crates/concrete_codegen_mlir/src/lib.rs index 372e73f..959807b 100644 --- a/crates/concrete_codegen_mlir/src/lib.rs +++ b/crates/concrete_codegen_mlir/src/lib.rs @@ -29,7 +29,6 @@ use llvm_sys::{ }; use module::MLIRModule; -mod ast_helper; mod codegen; mod context; mod error; diff --git a/crates/concrete_driver/Cargo.toml b/crates/concrete_driver/Cargo.toml index 35b9084..865d496 100644 --- a/crates/concrete_driver/Cargo.toml +++ b/crates/concrete_driver/Cargo.toml @@ -15,6 +15,7 @@ concrete_session = { path = "../concrete_session"} concrete_codegen_mlir = { path = "../concrete_codegen_mlir"} salsa = { git = "https://github.com/salsa-rs/salsa.git", package = "salsa-2022" } ariadne = { version = "0.4.0", features = ["auto-color"] } +concrete_check = { version = "0.1.0", path = "../concrete_check" } [dev-dependencies] tempfile = "3.9.0" diff --git a/crates/concrete_driver/src/lib.rs b/crates/concrete_driver/src/lib.rs index 8c4735d..e959e44 100644 --- a/crates/concrete_driver/src/lib.rs +++ b/crates/concrete_driver/src/lib.rs @@ -23,6 +23,10 @@ pub struct CompilerArgs { /// Build as a library. #[arg(short, long, default_value_t = false)] library: bool, + + /// Prints the ast. + #[arg(long, default_value_t = false)] + print_ast: bool, } pub fn main() -> Result<(), Box> { @@ -53,6 +57,10 @@ pub fn main() -> Result<(), Box> { } }; + if args.print_ast { + println!("{:#?}", program); + } + let cwd = std::env::current_dir()?; // todo: find a better name, "target" would clash with rust if running in the source tree. let target_dir = cwd.join("build_artifacts/"); @@ -80,8 +88,20 @@ pub fn main() -> Result<(), Box> { target_dir, output_file, }; + tracing::debug!("Compiling with session: {:#?}", session); + if let Err(errors) = concrete_check::check_program(&program) { + for error in &errors { + let path = session.file_path.display().to_string(); + error + .to_report(&session) + .eprint((path, session.source.clone()))?; + } + + std::process::exit(1); + } + let object_path = concrete_codegen_mlir::compile(&session, &program)?; if session.library { diff --git a/crates/concrete_driver/tests/programs.rs b/crates/concrete_driver/tests/programs.rs index 14cee5e..fecc2f3 100644 --- a/crates/concrete_driver/tests/programs.rs +++ b/crates/concrete_driver/tests/programs.rs @@ -130,3 +130,31 @@ fn test_import() { let code = output.status.code().unwrap(); assert_eq!(code, 8); } + +#[test] +fn test_reference() { + let source = r#" + mod Simple { + fn main(argc: i64) -> i64 { + let x: i64 = argc; + return references(x) + dereference(&x); + } + + fn dereference(a: &i64) -> i64 { + return *a; + } + + fn references(a: i64) -> i64 { + let x: i64 = a; + let y: &i64 = &x; + return *y; + } + } + "#; + + let result = compile_program(source, "references", false).expect("failed to compile"); + + let output = run_program(&result.binary_file).expect("failed to run"); + let code = output.status.code().unwrap(); + assert_eq!(code, 2); +} diff --git a/crates/concrete_parser/src/grammar.lalrpop b/crates/concrete_parser/src/grammar.lalrpop index d8b1cbe..e9ffbd8 100644 --- a/crates/concrete_parser/src/grammar.lalrpop +++ b/crates/concrete_parser/src/grammar.lalrpop @@ -66,7 +66,7 @@ extern { "!" => Token::OperatorNot, "~" => Token::OperatorBitwiseNot, "^" => Token::OperatorBitwiseXor, - "&" => Token::OperatorBitwiseAnd, + "&" => Token::Ampersand, "|" => Token::OperatorBitwiseOr, } } @@ -131,13 +131,27 @@ pub(crate) Ident: ast::common::Ident = { } } +pub(crate) RefType: ast::types::RefType = { + "&" => ast::types::RefType::Borrow, + "&" "mut" => ast::types::RefType::MutBorrow, +} + pub(crate) TypeSpec: ast::types::TypeSpec = { - => ast::types::TypeSpec::Simple { - name + => ast::types::TypeSpec::Simple { + name, + is_ref, + span: Span::new(lo, hi), }, - "<" > ">" => ast::types::TypeSpec::Generic { + "<" > ">" => ast::types::TypeSpec::Generic { name, type_params, + is_ref, + span: Span::new(lo, hi), + }, + "[" )?> "]" => ast::types::TypeSpec::Array { + of_type: Box::new(of_type), + size, + is_ref, span: Span::new(lo, hi), } } @@ -174,12 +188,13 @@ pub Program: ast::Program = { // Modules pub(crate) Module: ast::modules::Module = { - "mod" "{" "}" => { + "mod" "{" "}" => { ast::modules::Module { doc_string: None, imports: imports.unwrap_or_else(Vec::new), name, - contents + contents: contents.unwrap_or_else(Vec::new), + span: Span::new(lo, hi), } } } @@ -194,10 +209,11 @@ pub(crate) ImportList: Vec = { pub(crate) ImportStmt: ast::imports::ImportStmt = { - "import" > "{" > "}" ";" => { + "import" > "{" > "}" ";" => { ast::imports::ImportStmt { module, symbols, + span: Span::new(lo, hi), } } } @@ -253,9 +269,9 @@ pub(crate) Param: ast::functions::Param = { } pub(crate) FunctionDef: ast::functions::FunctionDef = { - "fn" "(" > ")" "{" - - "}" => { + "fn" "(" > ")" "{" + + "}" => { ast::functions::FunctionDef { decl: ast::functions::FunctionDecl { doc_string: None, @@ -264,7 +280,8 @@ pub(crate) FunctionDef: ast::functions::FunctionDef = { params, ret_type, }, - body: statements + body: statements.unwrap_or_else(Vec::new), + span: Span::new(lo, hi), } } } @@ -272,7 +289,7 @@ pub(crate) FunctionDef: ast::functions::FunctionDef = { // Expressions pub(crate) Term: ast::expressions::Expression = { - => ast::expressions::Expression::Simple(<>), + => ast::expressions::Expression::Value(<>), => ast::expressions::Expression::FnCall(<>), => ast::expressions::Expression::Match(<>), => ast::expressions::Expression::If(<>), @@ -339,14 +356,18 @@ pub UnaryOp: ast::expressions::UnaryOp = { "~" => ast::expressions::UnaryOp::BitwiseNot, } -pub(crate) SimpleExpr: ast::expressions::SimpleExpr = { - <"integer"> => ast::expressions::SimpleExpr::ConstInt(<>), - <"boolean"> => ast::expressions::SimpleExpr::ConstBool(<>), - <"string"> => ast::expressions::SimpleExpr::ConstStr(<>), - => ast::expressions::SimpleExpr::Path(<>), +pub(crate) ValueExpr: ast::expressions::ValueExpr = { + <"integer"> => ast::expressions::ValueExpr::ConstInt(<>), + <"boolean"> => ast::expressions::ValueExpr::ConstBool(<>), + <"string"> => ast::expressions::ValueExpr::ConstStr(<>), + => ast::expressions::ValueExpr::Path(<>), + "*" => ast::expressions::ValueExpr::Deref(<>), + => ast::expressions::ValueExpr::AsRef { + path, + ref_type + }, } - pub(crate) IfExpr: ast::expressions::IfExpr = { "if" "{" "}" "}")?> => { @@ -369,14 +390,14 @@ pub(crate) MatchExpr: ast::expressions::MatchExpr = { pub(crate) MatchVariant: ast::expressions::MatchVariant = { // 0 -> 1 - "->" => { + "->" => { ast::expressions::MatchVariant { case, block: vec![stmt] } }, // x -> { ... } - "->" "{" "}" => { + "->" "{" "}" => { ast::expressions::MatchVariant { case, block: stmts @@ -393,7 +414,7 @@ pub(crate) PathOp: ast::expressions::PathOp = { pub(crate) PathSegment: ast::expressions::PathSegment = { "." => ast::expressions::PathSegment::FieldAccess(<>), - "[" "]" => ast::expressions::PathSegment::ArrayIndex(e), + "[" "]" => ast::expressions::PathSegment::ArrayIndex(e), } pub PathSegments: Vec = { diff --git a/crates/concrete_parser/src/lib.rs b/crates/concrete_parser/src/lib.rs index d0b4e1b..f6fcb16 100644 --- a/crates/concrete_parser/src/lib.rs +++ b/crates/concrete_parser/src/lib.rs @@ -89,7 +89,7 @@ mod ModuleName { "##; let lexer = Lexer::new(source); let parser = grammar::ProgramParser::new(); - dbg!(parser.parse(lexer).unwrap()); + parser.parse(lexer).unwrap(); } #[test] @@ -104,7 +104,7 @@ mod ModuleName { }"##; let lexer = Lexer::new(source); let parser = grammar::ProgramParser::new(); - dbg!(parser.parse(lexer).unwrap()); + parser.parse(lexer).unwrap(); } #[test] @@ -116,7 +116,7 @@ mod ModuleName { }"##; let lexer = Lexer::new(source); let parser = grammar::ProgramParser::new(); - dbg!(parser.parse(lexer).unwrap()); + parser.parse(lexer).unwrap(); } #[test] @@ -128,6 +128,25 @@ mod ModuleName { }"##; let lexer = Lexer::new(source); let parser = grammar::ProgramParser::new(); - dbg!(parser.parse(lexer).unwrap()); + parser.parse(lexer).unwrap(); + } + + #[test] + fn parse_empty_mod() { + let source = r##"mod MyMod { +}"##; + let lexer = Lexer::new(source); + let parser = grammar::ProgramParser::new(); + parser.parse(lexer).unwrap(); + } + + #[test] + fn parse_empty_fn() { + let source = r##"mod MyMod { + fn hello() {} +}"##; + let lexer = Lexer::new(source); + let parser = grammar::ProgramParser::new(); + parser.parse(lexer).unwrap(); } } diff --git a/crates/concrete_parser/src/tokens.rs b/crates/concrete_parser/src/tokens.rs index 9e06b3f..316a74d 100644 --- a/crates/concrete_parser/src/tokens.rs +++ b/crates/concrete_parser/src/tokens.rs @@ -122,7 +122,7 @@ pub enum Token { #[token("^")] OperatorBitwiseXor, #[token("&")] - OperatorBitwiseAnd, + Ampersand, #[token("|")] OperatorBitwiseOr, } diff --git a/crates/concrete_type_checker/Cargo.toml b/crates/concrete_type_checker/Cargo.toml deleted file mode 100644 index 44762dd..0000000 --- a/crates/concrete_type_checker/Cargo.toml +++ /dev/null @@ -1,8 +0,0 @@ -[package] -name = "concrete_type_checker" -version = "0.1.0" -edition = "2021" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] diff --git a/crates/concrete_type_checker/src/lib.rs b/crates/concrete_type_checker/src/lib.rs deleted file mode 100644 index 8b13789..0000000 --- a/crates/concrete_type_checker/src/lib.rs +++ /dev/null @@ -1 +0,0 @@ - diff --git a/examples/borrow.con b/examples/borrow.con new file mode 100644 index 0000000..1f99c91 --- /dev/null +++ b/examples/borrow.con @@ -0,0 +1,16 @@ +mod Simple { + fn main(argc: i64) -> i64 { + let x: i64 = argc; + return references(x) + dereference(&x); + } + + fn dereference(a: &i64) -> i64 { + return *a; + } + + fn references(a: i64) -> i64 { + let x: i64 = a; + let y: &i64 = &x; + return *y; + } +} diff --git a/examples/check_errors.con b/examples/check_errors.con new file mode 100644 index 0000000..47fb23f --- /dev/null +++ b/examples/check_errors.con @@ -0,0 +1,23 @@ +mod Simple { + import Other.{hello1}; + import Other.Deep.{hello2}; + import Hello.{world}; + + fn main() -> i64 { + return hello1(2) + hello2(2); + } + + fn lol(a: x) -> b { + + } +} + +mod Hello { + fn a() { + return 1; + } +} + +mod A { + +}