From 843cdecbfb83d7596967f78faa8eeda9f81ba551 Mon Sep 17 00:00:00 2001 From: Edgar Date: Thu, 18 Jan 2024 17:33:14 +0100 Subject: [PATCH 1/4] check --- Cargo.lock | 16 ++- Cargo.toml | 2 +- crates/concrete_ast/src/common.rs | 8 ++ crates/concrete_ast/src/imports.rs | 3 +- crates/concrete_ast/src/modules.rs | 3 +- crates/concrete_check/Cargo.toml | 13 +++ crates/concrete_check/src/ast_helper.rs | 127 +++++++++++++++++++++ crates/concrete_check/src/lib.rs | 101 ++++++++++++++++ crates/concrete_driver/Cargo.toml | 1 + crates/concrete_driver/src/lib.rs | 12 ++ crates/concrete_parser/src/grammar.lalrpop | 8 +- crates/concrete_type_checker/Cargo.toml | 8 -- crates/concrete_type_checker/src/lib.rs | 1 - examples/missing_import.con | 8 ++ 14 files changed, 292 insertions(+), 19 deletions(-) create mode 100644 crates/concrete_check/Cargo.toml create mode 100644 crates/concrete_check/src/ast_helper.rs create mode 100644 crates/concrete_check/src/lib.rs delete mode 100644 crates/concrete_type_checker/Cargo.toml delete mode 100644 crates/concrete_type_checker/src/lib.rs create mode 100644 examples/missing_import.con diff --git a/Cargo.lock b/Cargo.lock index 25c2bd6..60fadbe 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" @@ -379,6 +390,7 @@ dependencies = [ "ariadne", "clap", "concrete_ast", + "concrete_check", "concrete_codegen_mlir", "concrete_parser", "concrete_session", @@ -409,10 +421,6 @@ dependencies = [ "ariadne", ] -[[package]] -name = "concrete_type_checker" -version = "0.1.0" - [[package]] name = "convert_case" version = "0.6.0" 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/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_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_check/src/ast_helper.rs b/crates/concrete_check/src/ast_helper.rs new file mode 100644 index 0000000..0d8c6bd --- /dev/null +++ b/crates/concrete_check/src/ast_helper.rs @@ -0,0 +1,127 @@ +use std::collections::HashMap; + +use concrete_ast::{ + common::Ident, + constants::ConstantDef, + functions::FunctionDef, + modules::{Module, ModuleDefItem}, + structs::StructDecl, + types::TypeDecl, + Program, +}; + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct ModuleInfo<'p> { + pub name: String, + pub functions: HashMap, + pub constants: HashMap, + pub structs: HashMap, + pub types: HashMap, + pub modules: HashMap>, +} + +impl<'p> ModuleInfo<'p> { + pub fn get_module_from_import(&self, import: &[Ident]) -> Option<&ModuleInfo<'p>> { + let next = import.first()?; + let module = self.modules.get(&next.name)?; + + if import.len() > 1 { + module.get_module_from_import(&import[1..]) + } else { + Some(module) + } + } + + /// Returns the symbol name from a local name. + pub fn get_symbol_name(&self, local_name: &str) -> String { + if local_name == "main" { + return local_name.to_string(); + } + + let mut result = self.name.clone(); + + result.push_str("::"); + result.push_str(local_name); + + result + } +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct AstHelper<'p> { + pub root: &'p Program, + pub modules: HashMap>, +} + +impl<'p> AstHelper<'p> { + pub fn new(root: &'p Program) -> Self { + let mut modules = HashMap::default(); + + for module in &root.modules { + modules.insert( + module.name.name.clone(), + Self::create_module_info(module, None), + ); + } + + Self { root, modules } + } + + pub fn get_module_from_import(&self, import: &[Ident]) -> Option<&ModuleInfo<'p>> { + let next = import.first()?; + let module = self.modules.get(&next.name)?; + + if import.len() > 1 { + module.get_module_from_import(&import[1..]) + } else { + Some(module) + } + } + + fn create_module_info(module: &Module, parent_name: Option) -> ModuleInfo<'_> { + let mut functions = HashMap::default(); + let mut constants = HashMap::default(); + let mut structs = HashMap::default(); + let mut types = HashMap::default(); + let mut child_modules = HashMap::default(); + let mut name = parent_name.clone().unwrap_or_default(); + + if name.is_empty() { + name = module.name.name.clone(); + } else { + name.push_str(&format!("::{}", module.name.name)); + } + + for stmt in &module.contents { + match stmt { + ModuleDefItem::Constant(info) => { + constants.insert(info.decl.name.name.clone(), info); + } + ModuleDefItem::Function(info) => { + functions.insert(info.decl.name.name.clone(), info); + } + ModuleDefItem::Struct(info) => { + structs.insert(info.name.name.clone(), info); + } + ModuleDefItem::Type(info) => { + types.insert(info.name.name.clone(), info); + } + ModuleDefItem::Module(info) => { + child_modules.insert( + info.name.name.clone(), + Self::create_module_info(info, Some(name.clone())), + ); + } + } + } + + ModuleInfo { + name, + functions, + structs, + constants, + types, + modules: child_modules, + } + } +} diff --git a/crates/concrete_check/src/lib.rs b/crates/concrete_check/src/lib.rs new file mode 100644 index 0000000..2dbeb84 --- /dev/null +++ b/crates/concrete_check/src/lib.rs @@ -0,0 +1,101 @@ +use std::{collections::HashMap, ops::Range}; + +use ariadne::{ColorGenerator, Label, Report, ReportKind}; +use ast_helper::AstHelper; +use concrete_ast::{imports::ImportStmt, modules::Module, Program}; +use concrete_session::Session; +use itertools::Itertools; +use thiserror::Error; + +mod ast_helper; + +#[derive(Error, Debug, Clone)] +pub enum CheckError<'p> { + #[error("import not found {:?} in module {}", import, module.name.name)] + ImportModuleMissing { + module: &'p Module, + import: &'p ImportStmt, + }, +} + +impl<'p> CheckError<'p> { + 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("Failed to find import.") + .finish() + } + } + } +} + +pub fn check_program<'p>( + program: &'p Program, + _session: &Session, +) -> Result<(), Vec>> { + let helper = AstHelper::new(program); + + let mut errors = Vec::new(); + + for module in &program.modules { + // let info = helper.modules.get(&module.name.name).unwrap(); + + let mut imports = HashMap::new(); + + 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, import }); + continue; + } + + let target_module = target_module.unwrap(); + + for symbol in &import.symbols { + // todo: check if symbol exists. + imports.insert(symbol.name.clone(), target_module); + } + } + } + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} 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 e293af0..cb29140 100644 --- a/crates/concrete_driver/src/lib.rs +++ b/crates/concrete_driver/src/lib.rs @@ -88,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, &session) { + 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_parser/src/grammar.lalrpop b/crates/concrete_parser/src/grammar.lalrpop index 7bcda21..5bb7c78 100644 --- a/crates/concrete_parser/src/grammar.lalrpop +++ b/crates/concrete_parser/src/grammar.lalrpop @@ -188,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, + span: Span::new(lo, hi), } } } @@ -208,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), } } } 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/missing_import.con b/examples/missing_import.con new file mode 100644 index 0000000..f299ba0 --- /dev/null +++ b/examples/missing_import.con @@ -0,0 +1,8 @@ +mod Simple { + import Other.{hello1}; + import Other.Deep.{hello2}; + + fn main() -> i64 { + return hello1(2) + hello2(2); + } +} From ffbf029ede7f6b4e102bedec074446a8f0d9a969 Mon Sep 17 00:00:00 2001 From: Edgar Date: Sat, 20 Jan 2024 23:46:49 +0100 Subject: [PATCH 2/4] more checks --- Cargo.lock | 1 + crates/concrete_check/src/lib.rs | 54 +++++++- crates/concrete_codegen_mlir/Cargo.toml | 1 + .../concrete_codegen_mlir/src/ast_helper.rs | 127 ------------------ crates/concrete_codegen_mlir/src/codegen.rs | 3 +- crates/concrete_codegen_mlir/src/lib.rs | 1 - crates/concrete_parser/src/grammar.lalrpop | 8 +- crates/concrete_parser/src/lib.rs | 27 +++- examples/missing_import.con | 11 ++ 9 files changed, 92 insertions(+), 141 deletions(-) delete mode 100644 crates/concrete_codegen_mlir/src/ast_helper.rs diff --git a/Cargo.lock b/Cargo.lock index 60fadbe..0b34ba8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -375,6 +375,7 @@ dependencies = [ "bumpalo", "cc", "concrete_ast", + "concrete_check", "concrete_session", "itertools 0.12.0", "llvm-sys", diff --git a/crates/concrete_check/src/lib.rs b/crates/concrete_check/src/lib.rs index 2dbeb84..9ea6c0e 100644 --- a/crates/concrete_check/src/lib.rs +++ b/crates/concrete_check/src/lib.rs @@ -2,12 +2,12 @@ use std::{collections::HashMap, ops::Range}; use ariadne::{ColorGenerator, Label, Report, ReportKind}; use ast_helper::AstHelper; -use concrete_ast::{imports::ImportStmt, modules::Module, Program}; +use concrete_ast::{common::Ident, imports::ImportStmt, modules::Module, Program}; use concrete_session::Session; use itertools::Itertools; use thiserror::Error; -mod ast_helper; +pub mod ast_helper; #[derive(Error, Debug, Clone)] pub enum CheckError<'p> { @@ -16,6 +16,12 @@ pub enum CheckError<'p> { module: &'p Module, import: &'p ImportStmt, }, + #[error("import symbol {:?} not found in module {}", symbol, module.name.name)] + ImportSymbolMissing { + module: &'p Module, + import: &'p ImportStmt, + symbol: &'p Ident, + }, } impl<'p> CheckError<'p> { @@ -59,6 +65,32 @@ impl<'p> CheckError<'p> { .with_message("Failed to find 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("E1") + .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("Failed to find import.") + .finish() + } } } } @@ -76,6 +108,7 @@ pub fn check_program<'p>( let mut imports = HashMap::new(); + // check modules for import in &module.imports { let target_module = helper.get_module_from_import(&import.module); @@ -86,8 +119,23 @@ pub fn check_program<'p>( let target_module = target_module.unwrap(); + // check if symbol exists for symbol in &import.symbols { - // todo: check if symbol exists. + 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, + import, + symbol, + }); + continue; + } + imports.insert(symbol.name.clone(), target_module); } } diff --git a/crates/concrete_codegen_mlir/Cargo.toml b/crates/concrete_codegen_mlir/Cargo.toml index 9df9c6f..6013882 100644 --- a/crates/concrete_codegen_mlir/Cargo.toml +++ b/crates/concrete_codegen_mlir/Cargo.toml @@ -8,6 +8,7 @@ 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" diff --git a/crates/concrete_codegen_mlir/src/ast_helper.rs b/crates/concrete_codegen_mlir/src/ast_helper.rs deleted file mode 100644 index 0d8c6bd..0000000 --- a/crates/concrete_codegen_mlir/src/ast_helper.rs +++ /dev/null @@ -1,127 +0,0 @@ -use std::collections::HashMap; - -use concrete_ast::{ - common::Ident, - constants::ConstantDef, - functions::FunctionDef, - modules::{Module, ModuleDefItem}, - structs::StructDecl, - types::TypeDecl, - Program, -}; - -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct ModuleInfo<'p> { - pub name: String, - pub functions: HashMap, - pub constants: HashMap, - pub structs: HashMap, - pub types: HashMap, - pub modules: HashMap>, -} - -impl<'p> ModuleInfo<'p> { - pub fn get_module_from_import(&self, import: &[Ident]) -> Option<&ModuleInfo<'p>> { - let next = import.first()?; - let module = self.modules.get(&next.name)?; - - if import.len() > 1 { - module.get_module_from_import(&import[1..]) - } else { - Some(module) - } - } - - /// Returns the symbol name from a local name. - pub fn get_symbol_name(&self, local_name: &str) -> String { - if local_name == "main" { - return local_name.to_string(); - } - - let mut result = self.name.clone(); - - result.push_str("::"); - result.push_str(local_name); - - result - } -} - -#[derive(Clone, Debug, Eq, PartialEq)] -pub struct AstHelper<'p> { - pub root: &'p Program, - pub modules: HashMap>, -} - -impl<'p> AstHelper<'p> { - pub fn new(root: &'p Program) -> Self { - let mut modules = HashMap::default(); - - for module in &root.modules { - modules.insert( - module.name.name.clone(), - Self::create_module_info(module, None), - ); - } - - Self { root, modules } - } - - pub fn get_module_from_import(&self, import: &[Ident]) -> Option<&ModuleInfo<'p>> { - let next = import.first()?; - let module = self.modules.get(&next.name)?; - - if import.len() > 1 { - module.get_module_from_import(&import[1..]) - } else { - Some(module) - } - } - - fn create_module_info(module: &Module, parent_name: Option) -> ModuleInfo<'_> { - let mut functions = HashMap::default(); - let mut constants = HashMap::default(); - let mut structs = HashMap::default(); - let mut types = HashMap::default(); - let mut child_modules = HashMap::default(); - let mut name = parent_name.clone().unwrap_or_default(); - - if name.is_empty() { - name = module.name.name.clone(); - } else { - name.push_str(&format!("::{}", module.name.name)); - } - - for stmt in &module.contents { - match stmt { - ModuleDefItem::Constant(info) => { - constants.insert(info.decl.name.name.clone(), info); - } - ModuleDefItem::Function(info) => { - functions.insert(info.decl.name.name.clone(), info); - } - ModuleDefItem::Struct(info) => { - structs.insert(info.name.name.clone(), info); - } - ModuleDefItem::Type(info) => { - types.insert(info.name.name.clone(), info); - } - ModuleDefItem::Module(info) => { - child_modules.insert( - info.name.name.clone(), - Self::create_module_info(info, Some(name.clone())), - ); - } - } - } - - ModuleInfo { - name, - functions, - structs, - constants, - types, - modules: child_modules, - } - } -} diff --git a/crates/concrete_codegen_mlir/src/codegen.rs b/crates/concrete_codegen_mlir/src/codegen.rs index 0db203f..13e74ad 100644 --- a/crates/concrete_codegen_mlir/src/codegen.rs +++ b/crates/concrete_codegen_mlir/src/codegen.rs @@ -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, 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_parser/src/grammar.lalrpop b/crates/concrete_parser/src/grammar.lalrpop index 5bb7c78..dc0b675 100644 --- a/crates/concrete_parser/src/grammar.lalrpop +++ b/crates/concrete_parser/src/grammar.lalrpop @@ -188,12 +188,12 @@ 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), } } @@ -270,7 +270,7 @@ pub(crate) Param: ast::functions::Param = { pub(crate) FunctionDef: ast::functions::FunctionDef = { "fn" "(" > ")" "{" - + "}" => { ast::functions::FunctionDef { decl: ast::functions::FunctionDecl { @@ -280,7 +280,7 @@ pub(crate) FunctionDef: ast::functions::FunctionDef = { params, ret_type, }, - body: statements + body: statements.unwrap_or_else(Vec::new) } } } 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/examples/missing_import.con b/examples/missing_import.con index f299ba0..3987d99 100644 --- a/examples/missing_import.con +++ b/examples/missing_import.con @@ -1,8 +1,19 @@ mod Simple { import Other.{hello1}; import Other.Deep.{hello2}; + import Hello.{world}; fn main() -> i64 { return hello1(2) + hello2(2); } } + +mod Hello { + fn a() { + return 1; + } +} + +mod A { + +} From bb99fd4cf4c14697bdd1834147943ece158f384e Mon Sep 17 00:00:00 2001 From: Edgar Date: Sun, 21 Jan 2024 10:35:26 +0100 Subject: [PATCH 3/4] more checks --- crates/concrete_ast/src/functions.rs | 3 +- crates/concrete_ast/src/types.rs | 8 + crates/concrete_check/src/lib.rs | 333 +++++++++++++++--- crates/concrete_codegen_mlir/src/codegen.rs | 22 +- crates/concrete_driver/src/lib.rs | 2 +- crates/concrete_parser/src/grammar.lalrpop | 7 +- .../{missing_import.con => check_errors.con} | 4 + 7 files changed, 327 insertions(+), 52 deletions(-) rename examples/{missing_import.con => check_errors.con} (87%) 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/types.rs b/crates/concrete_ast/src/types.rs index 2ae7c87..6454c4a 100644 --- a/crates/concrete_ast/src/types.rs +++ b/crates/concrete_ast/src/types.rs @@ -35,6 +35,14 @@ impl TypeSpec { 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/src/lib.rs b/crates/concrete_check/src/lib.rs index 9ea6c0e..91f6227 100644 --- a/crates/concrete_check/src/lib.rs +++ b/crates/concrete_check/src/lib.rs @@ -1,8 +1,17 @@ use std::{collections::HashMap, ops::Range}; use ariadne::{ColorGenerator, Label, Report, ReportKind}; -use ast_helper::AstHelper; -use concrete_ast::{common::Ident, imports::ImportStmt, modules::Module, Program}; +use ast_helper::{AstHelper, ModuleInfo}; +use concrete_ast::{ + common::{Ident, Span}, + constants::{ConstantDecl, ConstantDef}, + functions::{FunctionDecl, FunctionDef}, + imports::ImportStmt, + modules::{Module, ModuleDefItem}, + statements::Statement, + types::TypeSpec, + Program, +}; use concrete_session::Session; use itertools::Itertools; use thiserror::Error; @@ -10,21 +19,20 @@ use thiserror::Error; pub mod ast_helper; #[derive(Error, Debug, Clone)] -pub enum CheckError<'p> { +pub enum CheckError { #[error("import not found {:?} in module {}", import, module.name.name)] - ImportModuleMissing { - module: &'p Module, - import: &'p ImportStmt, - }, + ImportModuleMissing { module: Module, import: ImportStmt }, #[error("import symbol {:?} not found in module {}", symbol, module.name.name)] ImportSymbolMissing { - module: &'p Module, - import: &'p ImportStmt, - symbol: &'p Ident, + module: Module, + import: ImportStmt, + symbol: Ident, }, + #[error("type not found {:?}", type_spec)] + TypeNotFound { type_spec: TypeSpec }, } -impl<'p> CheckError<'p> { +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(); @@ -62,7 +70,7 @@ impl<'p> CheckError<'p> { )) .with_color(colors.next()), ) - .with_message("Failed to find import.") + .with_message("Unresolved import.") .finish() } CheckError::ImportSymbolMissing { @@ -74,7 +82,7 @@ impl<'p> CheckError<'p> { let import_span = import.span; let offset = symbol.span.from; Report::build(ReportKind::Error, path.clone(), offset) - .with_code("E1") + .with_code("E2") .with_label( Label::new((path.clone(), contex_module_span.into())) .with_message(format!("In module {:?}.", module.name.name)), @@ -88,56 +96,248 @@ impl<'p> CheckError<'p> { .with_message(format!("Failed to find symbol {:?}", symbol.name)) .with_color(colors.next()), ) - .with_message("Failed to find import.") + .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() } } } } -pub fn check_program<'p>( - program: &'p Program, - _session: &Session, -) -> Result<(), Vec>> { +#[derive(Debug, Clone)] +struct ScopeContext<'parent> { + pub locals: HashMap, + pub function: Option, + pub imports: HashMap>, + pub module_info: &'parent ModuleInfo<'parent>, +} + +#[derive(Debug, Clone)] +struct LocalVar { + pub type_spec: TypeSpec, +} + +impl<'parent> ScopeContext<'parent> { + /// Returns the symbol name from a local name. + pub fn get_symbol_name(&self, local_name: &str) -> String { + if local_name == "main" { + return local_name.to_string(); + } + + if let Some(module) = self.imports.get(local_name) { + // a import + module.get_symbol_name(local_name) + } else { + let mut result = self.module_info.name.clone(); + + result.push_str("::"); + result.push_str(local_name); + + result + } + } + + 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") + } + } + } + + 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::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::Generic { name, .. } => signed.contains(&name.name.as_str()), + TypeSpec::Array { .. } => unreachable!(), + } + } +} + +pub fn check_program(program: &Program) -> Result<(), Vec> { let helper = AstHelper::new(program); let mut errors = Vec::new(); for module in &program.modules { - // let info = helper.modules.get(&module.name.name).unwrap(); + let module_info = helper.modules.get(&module.name.name).unwrap(); + if let Err(e) = check_module(module, &helper, module_info) { + errors.extend(e); + } + } - let mut imports = HashMap::new(); + 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(); - // check modules - for import in &module.imports { - let target_module = helper.get_module_from_import(&import.module); + 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; + } - if target_module.is_none() { - errors.push(CheckError::ImportModuleMissing { module, import }); + 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; } - 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, - import, - symbol, - }); - continue; - } + scope_ctx.imports.insert(symbol.name.clone(), target_module); + } + } - 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(), + }) } } @@ -147,3 +347,48 @@ pub fn check_program<'p>( Err(errors) } } + +fn check_constant<'p>( + info: &ConstantDef, + scope_ctx: &ScopeContext<'p>, + helper: &AstHelper<'p>, + module_info: &ModuleInfo<'p>, +) -> Result<(), Vec> { + let mut 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 mut errors = Vec::new(); + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} + +fn check_template<'p>( + function: &FunctionDecl, + scope_ctx: &mut ScopeContext<'p>, + helper: &AstHelper<'_>, + module_info: &ModuleInfo<'_>, +) -> Result<(), Vec> { + let mut errors = Vec::new(); + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } +} diff --git a/crates/concrete_codegen_mlir/src/codegen.rs b/crates/concrete_codegen_mlir/src/codegen.rs index 13e74ad..4bcae6f 100644 --- a/crates/concrete_codegen_mlir/src/codegen.rs +++ b/crates/concrete_codegen_mlir/src/codegen.rs @@ -135,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, + )? + } + } }) } @@ -197,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(); diff --git a/crates/concrete_driver/src/lib.rs b/crates/concrete_driver/src/lib.rs index cb29140..e959e44 100644 --- a/crates/concrete_driver/src/lib.rs +++ b/crates/concrete_driver/src/lib.rs @@ -91,7 +91,7 @@ pub fn main() -> Result<(), Box> { tracing::debug!("Compiling with session: {:#?}", session); - if let Err(errors) = concrete_check::check_program(&program, &session) { + if let Err(errors) = concrete_check::check_program(&program) { for error in &errors { let path = session.file_path.display().to_string(); error diff --git a/crates/concrete_parser/src/grammar.lalrpop b/crates/concrete_parser/src/grammar.lalrpop index dc0b675..e9ffbd8 100644 --- a/crates/concrete_parser/src/grammar.lalrpop +++ b/crates/concrete_parser/src/grammar.lalrpop @@ -269,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, @@ -280,7 +280,8 @@ pub(crate) FunctionDef: ast::functions::FunctionDef = { params, ret_type, }, - body: statements.unwrap_or_else(Vec::new) + body: statements.unwrap_or_else(Vec::new), + span: Span::new(lo, hi), } } } diff --git a/examples/missing_import.con b/examples/check_errors.con similarity index 87% rename from examples/missing_import.con rename to examples/check_errors.con index 3987d99..47fb23f 100644 --- a/examples/missing_import.con +++ b/examples/check_errors.con @@ -6,6 +6,10 @@ mod Simple { fn main() -> i64 { return hello1(2) + hello2(2); } + + fn lol(a: x) -> b { + + } } mod Hello { From b6f342061c72f04a1926ce9d15b11bff77518f8a Mon Sep 17 00:00:00 2001 From: Edgar Date: Mon, 22 Jan 2024 09:34:48 -0300 Subject: [PATCH 4/4] fmt --- crates/concrete_check/src/lib.rs | 87 +++++++------------------------- 1 file changed, 19 insertions(+), 68 deletions(-) diff --git a/crates/concrete_check/src/lib.rs b/crates/concrete_check/src/lib.rs index 91f6227..a5f02c7 100644 --- a/crates/concrete_check/src/lib.rs +++ b/crates/concrete_check/src/lib.rs @@ -3,9 +3,9 @@ use std::{collections::HashMap, ops::Range}; use ariadne::{ColorGenerator, Label, Report, ReportKind}; use ast_helper::{AstHelper, ModuleInfo}; use concrete_ast::{ - common::{Ident, Span}, - constants::{ConstantDecl, ConstantDef}, - functions::{FunctionDecl, FunctionDef}, + common::Ident, + constants::ConstantDef, + functions::FunctionDef, imports::ImportStmt, modules::{Module, ModuleDefItem}, statements::Statement, @@ -119,6 +119,7 @@ impl CheckError { } } +#[allow(unused)] #[derive(Debug, Clone)] struct ScopeContext<'parent> { pub locals: HashMap, @@ -127,31 +128,14 @@ struct ScopeContext<'parent> { pub module_info: &'parent ModuleInfo<'parent>, } +#[allow(unused)] #[derive(Debug, Clone)] struct LocalVar { pub type_spec: TypeSpec, } +#[allow(unused)] impl<'parent> ScopeContext<'parent> { - /// Returns the symbol name from a local name. - pub fn get_symbol_name(&self, local_name: &str) -> String { - if local_name == "main" { - return local_name.to_string(); - } - - if let Some(module) = self.imports.get(local_name) { - // a import - module.get_symbol_name(local_name) - } else { - let mut result = self.module_info.name.clone(); - - result.push_str("::"); - result.push_str(local_name); - - result - } - } - pub fn get_function(&self, local_name: &str) -> Option<&FunctionDef> { if let Some(module) = self.imports.get(local_name) { // a import @@ -198,24 +182,6 @@ impl<'parent> ScopeContext<'parent> { } } } - - 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::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::Generic { name, .. } => signed.contains(&name.name.as_str()), - TypeSpec::Array { .. } => unreachable!(), - } - } } pub fn check_program(program: &Program) -> Result<(), Vec> { @@ -320,8 +286,8 @@ pub fn check_module<'p, 'x: 'p>( fn check_function<'p>( info: &FunctionDef, scope_ctx: &ScopeContext<'p>, - helper: &AstHelper<'p>, - module_info: &ModuleInfo<'p>, + _helper: &AstHelper<'p>, + _module_info: &ModuleInfo<'p>, ) -> Result<(), Vec> { let mut errors = Vec::new(); @@ -349,12 +315,12 @@ fn check_function<'p>( } fn check_constant<'p>( - info: &ConstantDef, - scope_ctx: &ScopeContext<'p>, - helper: &AstHelper<'p>, - module_info: &ModuleInfo<'p>, + _info: &ConstantDef, + _scope_ctx: &ScopeContext<'p>, + _helper: &AstHelper<'p>, + _module_info: &ModuleInfo<'p>, ) -> Result<(), Vec> { - let mut errors = Vec::new(); + let errors = Vec::new(); if errors.is_empty() { Ok(()) @@ -363,28 +329,13 @@ fn check_constant<'p>( } } -fn check_statement<'p>( - info: &Statement, - scope_ctx: &mut ScopeContext<'p>, - helper: &AstHelper<'p>, - module_info: &ModuleInfo<'p>, +fn _check_statement<'p>( + _info: &Statement, + _scope_ctx: &mut ScopeContext<'p>, + _helper: &AstHelper<'p>, + _module_info: &ModuleInfo<'p>, ) -> Result<(), Vec> { - let mut errors = Vec::new(); - - if errors.is_empty() { - Ok(()) - } else { - Err(errors) - } -} - -fn check_template<'p>( - function: &FunctionDecl, - scope_ctx: &mut ScopeContext<'p>, - helper: &AstHelper<'_>, - module_info: &ModuleInfo<'_>, -) -> Result<(), Vec> { - let mut errors = Vec::new(); + let errors = Vec::new(); if errors.is_empty() { Ok(())