From 4dc5bb1121f76519c3ffebe43a902a31c3572731 Mon Sep 17 00:00:00 2001 From: dark64 Date: Mon, 17 May 2021 13:24:02 +0200 Subject: [PATCH] refactor imports --- zokrates_core/src/absy/from_ast.rs | 114 +++++---- zokrates_core/src/absy/mod.rs | 104 +------- zokrates_core/src/absy/node.rs | 3 +- zokrates_core/src/imports.rs | 396 +++++++++++------------------ zokrates_core/src/semantics.rs | 151 ++++++----- 5 files changed, 290 insertions(+), 478 deletions(-) diff --git a/zokrates_core/src/absy/from_ast.rs b/zokrates_core/src/absy/from_ast.rs index 4b7a7852..e788dd46 100644 --- a/zokrates_core/src/absy/from_ast.rs +++ b/zokrates_core/src/absy/from_ast.rs @@ -6,63 +6,65 @@ use zokrates_pest_ast as pest; impl<'ast> From> for absy::Module<'ast> { fn from(file: pest::File<'ast>) -> absy::Module<'ast> { - absy::Module::with_symbols(file.declarations.into_iter().map(|d| match d { - pest::SymbolDeclaration::Import(i) => i.into(), - pest::SymbolDeclaration::Constant(c) => c.into(), - pest::SymbolDeclaration::Struct(s) => s.into(), - pest::SymbolDeclaration::Function(f) => f.into(), + absy::Module::with_symbols(file.declarations.into_iter().flat_map(|d| match d { + pest::SymbolDeclaration::Import(i) => import_directive_to_symbol_vec(i), + pest::SymbolDeclaration::Constant(c) => vec![c.into()], + pest::SymbolDeclaration::Struct(s) => vec![s.into()], + pest::SymbolDeclaration::Function(f) => vec![f.into()], })) } } -impl<'ast> From> for absy::SymbolDeclarationNode<'ast> { - fn from(import: pest::ImportDirective<'ast>) -> absy::SymbolDeclarationNode<'ast> { - use crate::absy::NodeValue; +fn import_directive_to_symbol_vec( + import: pest::ImportDirective, +) -> Vec { + use crate::absy::NodeValue; - match import { - pest::ImportDirective::Main(import) => { - let span = import.span; - let source = Path::new(import.source.span.as_str()); + match import { + pest::ImportDirective::Main(import) => { + let span = import.span; + let source = Path::new(import.source.span.as_str()); + let id = "main"; - let import = absy::MainImport { - source, - alias: import.alias.map(|a| a.span.as_str()), - } - .span(span.clone()); - - absy::SymbolDeclaration { - id: None, - symbol: absy::Symbol::Here(absy::SymbolDefinition::Import( - absy::ImportDirective::Main(import), - )), - } - .span(span) + let import = absy::CanonicalImport { + source, + id: absy::SymbolIdentifier::from(id).alias(import.alias.map(|a| a.span.as_str())), } - pest::ImportDirective::From(import) => { - let span = import.span; - let source = Path::new(import.source.span.as_str()); + .span(span.clone()); - let import = absy::FromImport { - source, - symbols: import - .symbols - .into_iter() - .map(|symbol| absy::SymbolIdentifier { - id: symbol.id.span.as_str(), - alias: symbol.alias.map(|a| a.span.as_str()), - }) - .collect(), - } - .span(span.clone()); - - absy::SymbolDeclaration { - id: None, - symbol: absy::Symbol::Here(absy::SymbolDefinition::Import( - absy::ImportDirective::From(import), - )), - } - .span(span) + vec![absy::SymbolDeclaration { + id, + symbol: absy::Symbol::Here(absy::SymbolDefinition::Import(import)), } + .span(span.clone())] + } + pest::ImportDirective::From(import) => { + let span = import.span; + let source = Path::new(import.source.span.as_str()); + import + .symbols + .into_iter() + .map(|symbol| { + let alias = symbol + .alias + .as_ref() + .map(|a| a.span.as_str()) + .unwrap_or_else(|| symbol.id.span.as_str()); + + let import = absy::CanonicalImport { + source, + id: absy::SymbolIdentifier::from(symbol.id.span.as_str()) + .alias(Some(alias)), + } + .span(span.clone()); + + absy::SymbolDeclaration { + id: alias, + symbol: absy::Symbol::Here(absy::SymbolDefinition::Import(import)), + } + .span(span.clone()) + }) + .collect() } } } @@ -85,7 +87,7 @@ impl<'ast> From> for absy::SymbolDeclarationNode<'a .span(span.clone()); absy::SymbolDeclaration { - id: Some(id), + id, symbol: absy::Symbol::Here(absy::SymbolDefinition::Struct(ty)), } .span(span) @@ -120,7 +122,7 @@ impl<'ast> From> for absy::SymbolDeclarationNode< .span(span.clone()); absy::SymbolDeclaration { - id: Some(id), + id, symbol: absy::Symbol::Here(absy::SymbolDefinition::Constant(ty)), } .span(span) @@ -176,7 +178,7 @@ impl<'ast> From> for absy::SymbolDeclarationNode< .span(span.clone()); absy::SymbolDeclaration { - id: Some(id), + id, symbol: absy::Symbol::Here(absy::SymbolDefinition::Function(function)), } .span(span) @@ -782,7 +784,7 @@ mod tests { let ast = pest::generate_ast(&source).unwrap(); let expected: absy::Module = absy::Module { symbols: vec![absy::SymbolDeclaration { - id: Some(&source[4..8]), + id: &source[4..8], symbol: absy::Symbol::Here(absy::SymbolDefinition::Function( absy::Function { arguments: vec![], @@ -813,7 +815,7 @@ mod tests { let ast = pest::generate_ast(&source).unwrap(); let expected: absy::Module = absy::Module { symbols: vec![absy::SymbolDeclaration { - id: Some(&source[4..8]), + id: &source[4..8], symbol: absy::Symbol::Here(absy::SymbolDefinition::Function( absy::Function { arguments: vec![], @@ -843,7 +845,7 @@ mod tests { let expected: absy::Module = absy::Module { symbols: vec![absy::SymbolDeclaration { - id: Some(&source[4..8]), + id: &source[4..8], symbol: absy::Symbol::Here(absy::SymbolDefinition::Function( absy::Function { arguments: vec![ @@ -896,7 +898,7 @@ mod tests { fn wrap(ty: UnresolvedType<'static>) -> absy::Module<'static> { absy::Module { symbols: vec![absy::SymbolDeclaration { - id: Some("main"), + id: "main", symbol: absy::Symbol::Here(absy::SymbolDefinition::Function( absy::Function { arguments: vec![absy::Parameter::private( @@ -969,7 +971,7 @@ mod tests { fn wrap(expression: absy::Expression<'static>) -> absy::Module { absy::Module { symbols: vec![absy::SymbolDeclaration { - id: Some("main"), + id: "main", symbol: absy::Symbol::Here(absy::SymbolDefinition::Function( absy::Function { arguments: vec![], diff --git a/zokrates_core/src/absy/mod.rs b/zokrates_core/src/absy/mod.rs index f3f986ef..c4ff8232 100644 --- a/zokrates_core/src/absy/mod.rs +++ b/zokrates_core/src/absy/mod.rs @@ -76,57 +76,16 @@ impl<'ast> fmt::Display for SymbolIdentifier<'ast> { } #[derive(Debug, Clone, PartialEq)] -pub struct MainImport<'ast> { +pub struct CanonicalImport<'ast> { pub source: &'ast Path, - pub alias: Option>, + pub id: SymbolIdentifier<'ast>, } -pub type MainImportNode<'ast> = Node>; +pub type CanonicalImportNode<'ast> = Node>; -impl<'ast> fmt::Display for MainImport<'ast> { +impl<'ast> fmt::Display for CanonicalImport<'ast> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.alias { - Some(ref alias) => write!(f, "import \"{}\" as {}", self.source.display(), alias), - None => write!(f, "import \"{}\"", self.source.display()), - } - } -} - -#[derive(Debug, Clone, PartialEq)] -pub struct FromImport<'ast> { - pub source: &'ast Path, - pub symbols: Vec>, -} - -pub type FromImportNode<'ast> = Node>; - -impl<'ast> fmt::Display for FromImport<'ast> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "from \"{}\" import {}", - self.source.display(), - self.symbols - .iter() - .map(|s| s.to_string()) - .collect::>() - .join(", ") - ) - } -} - -#[derive(Debug, Clone, PartialEq)] -pub enum ImportDirective<'ast> { - Main(MainImportNode<'ast>), - From(FromImportNode<'ast>), -} - -impl<'ast> fmt::Display for ImportDirective<'ast> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - ImportDirective::Main(main) => write!(f, "{}", main), - ImportDirective::From(from) => write!(f, "{}", from), - } + write!(f, "from \"{}\" import {}", self.source.display(), self.id) } } @@ -164,14 +123,14 @@ impl<'ast> fmt::Display for SymbolImport<'ast> { /// A declaration of a symbol #[derive(Debug, PartialEq, Clone)] pub struct SymbolDeclaration<'ast> { - pub id: Option>, + pub id: Identifier<'ast>, pub symbol: Symbol<'ast>, } #[allow(clippy::large_enum_variant)] #[derive(Debug, PartialEq, Clone)] pub enum SymbolDefinition<'ast> { - Import(ImportDirective<'ast>), + Import(CanonicalImportNode<'ast>), Struct(StructDefinitionNode<'ast>), Constant(ConstantDefinitionNode<'ast>), Function(FunctionNode<'ast>), @@ -189,26 +148,19 @@ impl<'ast> fmt::Display for SymbolDeclaration<'ast> { match &self.symbol { Symbol::Here(ref symbol) => match symbol { SymbolDefinition::Import(ref i) => write!(f, "{}", i), - SymbolDefinition::Struct(ref t) => write!(f, "struct {} {}", self.id.unwrap(), t), + SymbolDefinition::Struct(ref t) => write!(f, "struct {} {}", self.id, t), SymbolDefinition::Constant(ref c) => write!( f, "const {} {} = {}", - c.value.ty, - self.id.unwrap(), - c.value.expression + c.value.ty, self.id, c.value.expression ), SymbolDefinition::Function(ref func) => { - write!(f, "def {}{}", self.id.unwrap(), func) + write!(f, "def {}{}", self.id, func) } }, Symbol::There(ref i) => write!(f, "{}", i), Symbol::Flat(ref flat_fun) => { - write!( - f, - "def {}{}:\n\t// hidden", - self.id.unwrap(), - flat_fun.signature() - ) + write!(f, "def {}{}:\n\t// hidden", self.id, flat_fun.signature()) } } } @@ -284,40 +236,6 @@ impl<'ast> fmt::Display for ConstantDefinition<'ast> { } } -// /// An import -// #[derive(Debug, Clone, PartialEq)] -// pub struct SymbolImport<'ast> { -// /// the id of the symbol in the target module. Note: there may be many candidates as imports statements do not specify the signature. In that case they must all be functions however. -// pub symbol_id: Identifier<'ast>, -// /// the id of the module to import from -// pub module_id: OwnedModuleId, -// } -// -// type SymbolImportNode<'ast> = Node>; -// -// impl<'ast> SymbolImport<'ast> { -// pub fn with_id_in_module>, U: Into>( -// symbol_id: S, -// module_id: U, -// ) -> Self { -// SymbolImport { -// symbol_id: symbol_id.into(), -// module_id: module_id.into(), -// } -// } -// } -// -// impl<'ast> fmt::Display for SymbolImport<'ast> { -// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { -// write!( -// f, -// "from {} import {}", -// self.module_id.display().to_string(), -// self.symbol_id, -// ) -// } -// } - impl<'ast> fmt::Display for Module<'ast> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let res = self diff --git a/zokrates_core/src/absy/node.rs b/zokrates_core/src/absy/node.rs index cd63fb1f..8a5745c0 100644 --- a/zokrates_core/src/absy/node.rs +++ b/zokrates_core/src/absy/node.rs @@ -86,8 +86,7 @@ impl<'ast> NodeValue for StructDefinitionField<'ast> {} impl<'ast> NodeValue for ConstantDefinition<'ast> {} impl<'ast> NodeValue for Function<'ast> {} impl<'ast> NodeValue for Module<'ast> {} -impl<'ast> NodeValue for MainImport<'ast> {} -impl<'ast> NodeValue for FromImport<'ast> {} +impl<'ast> NodeValue for CanonicalImport<'ast> {} impl<'ast> NodeValue for SymbolImport<'ast> {} impl<'ast> NodeValue for Variable<'ast> {} impl<'ast> NodeValue for Parameter<'ast> {} diff --git a/zokrates_core/src/imports.rs b/zokrates_core/src/imports.rs index 996dacd0..dfe8a917 100644 --- a/zokrates_core/src/imports.rs +++ b/zokrates_core/src/imports.rs @@ -12,7 +12,7 @@ use crate::parser::Position; use std::collections::HashMap; use std::fmt; use std::io; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use typed_arena::Arena; use zokrates_common::Resolver; @@ -70,259 +70,153 @@ impl Importer { for symbol in destination.symbols { match symbol.value.symbol { - Symbol::Here(ref s) => match s { - SymbolDefinition::Import(ImportDirective::Main(main)) => { - let pos = main.pos(); - let module_id = &main.value.source; - - match resolver { - Some(res) => { - match res.resolve(location.clone(), module_id.to_path_buf()) { - Ok((source, new_location)) => { - // generate an alias from the imported path if none was given explicitly - let alias = main.value.alias.or( - module_id - .file_stem() - .ok_or_else(|| { - CompileErrors::from( - CompileErrorInner::ImportError(Error::new( - format!( - "Could not determine alias for import {}", - module_id.display() - ), - )) - .in_file(&location), - ) - })? - .to_str() - ); - - match modules.get(&new_location) { - Some(_) => {} - None => { - let source = arena.alloc(source); - - let compiled = compile_module::( - source, - new_location.clone(), - resolver, - modules, - &arena, - )?; - - assert!(modules - .insert(new_location.clone(), compiled) - .is_none()); - } - }; - - symbols.push( - SymbolDeclaration { - id: alias, - symbol: Symbol::There( - SymbolImport::with_id_in_module( - "main", - new_location, - ) - .start_end(pos.0, pos.1), - ), - } - .start_end(pos.0, pos.1), - ); - } - Err(err) => { - return Err(CompileErrorInner::ImportError( - err.into().with_pos(Some(pos)), - ) - .in_file(&location) - .into()); - } - } - } - None => { - return Err(CompileErrorInner::from(Error::new( - "Cannot resolve import without a resolver", - )) - .in_file(&location) - .into()); - } - } - } - SymbolDefinition::Import(ImportDirective::From(from)) => { - let pos = from.pos(); - let module_id = &from.value.source; - - match module_id.to_str().unwrap() { - "EMBED" => { - for symbol in &from.value.symbols { - match symbol.id { - #[cfg(feature = "bellman")] - "sha256round" => { - if T::id() != Bn128Field::id() { - return Err(CompileErrorInner::ImportError( - Error::new(format!( - "Embed sha256round cannot be used with curve {}", - T::name() - )) - .with_pos(Some(pos)), - ).in_file(&location).into()); - } else { - symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat( - FlatEmbed::Sha256Round, - ), - } - .start_end(pos.0, pos.1), - ) - } - } - "unpack" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::Unpack), - } - .start_end(pos.0, pos.1), - ), - "u64_to_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U64ToBits), - } - .start_end(pos.0, pos.1), - ), - "u32_to_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U32ToBits), - } - .start_end(pos.0, pos.1), - ), - "u16_to_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U16ToBits), - } - .start_end(pos.0, pos.1), - ), - "u8_to_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U8ToBits), - } - .start_end(pos.0, pos.1), - ), - "u64_from_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U64FromBits), - } - .start_end(pos.0, pos.1), - ), - "u32_from_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U32FromBits), - } - .start_end(pos.0, pos.1), - ), - "u16_from_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U16FromBits), - } - .start_end(pos.0, pos.1), - ), - "u8_from_bits" => symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::Flat(FlatEmbed::U8FromBits), - } - .start_end(pos.0, pos.1), - ), - s => { - return Err(CompileErrorInner::ImportError( - Error::new(format!("Embed {} not found", s)) - .with_pos(Some(pos)), - ) - .in_file(&location) - .into()) - } - } - } - } - _ => { - for symbol in &from.value.symbols { - match resolver { - Some(res) => { - match res - .resolve(location.clone(), module_id.to_path_buf()) - { - Ok((source, new_location)) => { - match modules.get(&new_location) { - Some(_) => {} - None => { - let source = arena.alloc(source); - - let compiled = compile_module::( - source, - new_location.clone(), - resolver, - modules, - &arena, - )?; - - assert!(modules - .insert( - new_location.clone(), - compiled - ) - .is_none()); - } - }; - - symbols.push( - SymbolDeclaration { - id: Some(symbol.get_alias()), - symbol: Symbol::There( - SymbolImport::with_id_in_module( - symbol.id, - new_location, - ) - .start_end(pos.0, pos.1), - ), - } - .start_end(pos.0, pos.1), - ); - } - Err(err) => { - return Err(CompileErrorInner::ImportError( - err.into().with_pos(Some(pos)), - ) - .in_file(&location) - .into()); - } - } - } - None => { - return Err(CompileErrorInner::from(Error::new( - "Cannot resolve import without a resolver", - )) - .in_file(&location) - .into()); - } - } - } - } - } - } - _ => symbols.push(symbol), - }, - _ => unreachable!(), + Symbol::Here(SymbolDefinition::Import(import)) => symbols.push( + Importer::resolve::(import, &location, resolver, modules, arena)?, + ), + _ => symbols.push(symbol), } } Ok(Module::with_symbols(symbols)) } + + fn resolve<'ast, T: Field, E: Into>( + import: CanonicalImportNode<'ast>, + location: &Path, + resolver: Option<&dyn Resolver>, + modules: &mut HashMap>, + arena: &'ast Arena, + ) -> Result, CompileErrors> { + let pos = import.pos(); + let module_id = import.value.source; + let symbol = import.value.id; + + let symbol_declaration = match module_id.to_str().unwrap() { + "EMBED" => match symbol.id { + #[cfg(feature = "bellman")] + "sha256round" => { + if T::id() != Bn128Field::id() { + return Err(CompileErrorInner::ImportError( + Error::new(format!( + "Embed sha256round cannot be used with curve {}", + T::name() + )) + .with_pos(Some(pos)), + ) + .in_file(location) + .into()); + } else { + SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::Sha256Round), + } + } + } + "unpack" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::Unpack), + }, + "u64_to_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U64ToBits), + }, + "u32_to_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U32ToBits), + }, + "u16_to_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U16ToBits), + }, + "u8_to_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U8ToBits), + }, + "u64_from_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U64FromBits), + }, + "u32_from_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U32FromBits), + }, + "u16_from_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U16FromBits), + }, + "u8_from_bits" => SymbolDeclaration { + id: symbol.get_alias(), + symbol: Symbol::Flat(FlatEmbed::U8FromBits), + }, + s => { + return Err(CompileErrorInner::ImportError( + Error::new(format!("Embed {} not found", s)).with_pos(Some(pos)), + ) + .in_file(location) + .into()); + } + }, + _ => match resolver { + Some(res) => match res.resolve(location.to_path_buf(), module_id.to_path_buf()) { + Ok((source, new_location)) => { + let alias = symbol.alias.unwrap_or( + module_id + .file_stem() + .ok_or_else(|| { + CompileErrors::from( + CompileErrorInner::ImportError(Error::new(format!( + "Could not determine alias for import {}", + module_id.display() + ))) + .in_file(location), + ) + })? + .to_str() + .unwrap(), + ); + + match modules.get(&new_location) { + Some(_) => {} + None => { + let source = arena.alloc(source); + let compiled = compile_module::( + source, + new_location.clone(), + resolver, + modules, + &arena, + )?; + + assert!(modules.insert(new_location.clone(), compiled).is_none()); + } + }; + + SymbolDeclaration { + id: &alias, + symbol: Symbol::There( + SymbolImport::with_id_in_module(symbol.id, new_location) + .start_end(pos.0, pos.1), + ), + } + } + Err(err) => { + return Err( + CompileErrorInner::ImportError(err.into().with_pos(Some(pos))) + .in_file(location) + .into(), + ); + } + }, + None => { + return Err(CompileErrorInner::from(Error::new( + "Cannot resolve import without a resolver", + )) + .in_file(location) + .into()); + } + }, + }; + + Ok(symbol_declaration.start_end(pos.0, pos.1)) + } } diff --git a/zokrates_core/src/semantics.rs b/zokrates_core/src/semantics.rs index e76e33b8..31a6b392 100644 --- a/zokrates_core/src/semantics.rs +++ b/zokrates_core/src/semantics.rs @@ -453,24 +453,23 @@ impl<'ast, T: Field> Checker<'ast, T> { let pos = declaration.pos(); let declaration = declaration.value; - let declaration_id = declaration.id.unwrap(); match declaration.symbol.clone() { Symbol::Here(SymbolDefinition::Struct(t)) => { match self.check_struct_type_declaration( - declaration_id.to_string(), + declaration.id.to_string(), t.clone(), module_id, state, ) { Ok(ty) => { - match symbol_unifier.insert_type(declaration_id) { + match symbol_unifier.insert_type(declaration.id) { false => errors.push( ErrorInner { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id + declaration.id ), } .in_file(module_id), @@ -481,7 +480,7 @@ impl<'ast, T: Field> Checker<'ast, T> { .types .entry(module_id.to_path_buf()) .or_default() - .insert(declaration_id.to_string(), ty) + .insert(declaration.id.to_string(), ty) .is_none()); } }; @@ -493,31 +492,31 @@ impl<'ast, T: Field> Checker<'ast, T> { } } Symbol::Here(SymbolDefinition::Constant(c)) => { - match self.check_constant_definition(declaration_id, c, module_id, state) { + match self.check_constant_definition(declaration.id, c, module_id, state) { Ok(c) => { - match symbol_unifier.insert_constant(declaration_id) { + match symbol_unifier.insert_constant(declaration.id) { false => errors.push( ErrorInner { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id + declaration.id ), } .in_file(module_id), ), true => { constants - .insert(declaration_id, TypedConstantSymbol::Here(c.clone())); + .insert(declaration.id, TypedConstantSymbol::Here(c.clone())); self.insert_into_scope(Variable::with_id_and_type( - declaration_id, + declaration.id, c.get_type(), )); assert!(state .constants .entry(module_id.to_path_buf()) .or_default() - .insert(declaration_id, c.get_type()) + .insert(declaration.id, c.get_type()) .is_none()); } }; @@ -531,14 +530,14 @@ impl<'ast, T: Field> Checker<'ast, T> { match self.check_function(f, module_id, state) { Ok(funct) => { match symbol_unifier - .insert_function(declaration_id, funct.signature.clone()) + .insert_function(declaration.id, funct.signature.clone()) { false => errors.push( ErrorInner { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id + declaration.id ), } .in_file(module_id), @@ -549,14 +548,14 @@ impl<'ast, T: Field> Checker<'ast, T> { self.functions.insert( DeclarationFunctionKey::with_location( module_id.to_path_buf(), - declaration_id, + declaration.id, ) .signature(funct.signature.clone()), ); functions.insert( DeclarationFunctionKey::with_location( module_id.to_path_buf(), - declaration_id, + declaration.id, ) .signature(funct.signature.clone()), TypedFunctionSymbol::Here(funct), @@ -613,7 +612,7 @@ impl<'ast, T: Field> Checker<'ast, T> { let t = match t { DeclarationType::Struct(t) => DeclarationType::Struct(DeclarationStructType { location: Some(StructLocation { - name: declaration_id.into(), + name: declaration.id.into(), module: module_id.to_path_buf() }), ..t @@ -622,7 +621,7 @@ impl<'ast, T: Field> Checker<'ast, T> { }; // we imported a type, so the symbol it gets bound to should not already exist - match symbol_unifier.insert_type(declaration_id) { + match symbol_unifier.insert_type(declaration.id) { false => { errors.push(Error { module_id: module_id.to_path_buf(), @@ -630,7 +629,7 @@ impl<'ast, T: Field> Checker<'ast, T> { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id, + declaration.id, ), }}); } @@ -640,10 +639,10 @@ impl<'ast, T: Field> Checker<'ast, T> { .types .entry(module_id.to_path_buf()) .or_default() - .insert(declaration_id.to_string(), t); + .insert(declaration.id.to_string(), t); } (0, None, Some(ty)) => { - match symbol_unifier.insert_constant(declaration_id) { + match symbol_unifier.insert_constant(declaration.id) { false => { errors.push(Error { module_id: module_id.to_path_buf(), @@ -651,19 +650,19 @@ impl<'ast, T: Field> Checker<'ast, T> { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id, + declaration.id, ), }}); } true => { - constants.insert(declaration_id, TypedConstantSymbol::There(import.module_id.to_path_buf(), symbol_id)); - self.insert_into_scope(Variable::with_id_and_type(declaration_id, ty.clone())); + constants.insert(declaration.id, TypedConstantSymbol::There(import.module_id.to_path_buf(), symbol_id)); + self.insert_into_scope(Variable::with_id_and_type(declaration.id, ty.clone())); state .constants .entry(module_id.to_path_buf()) .or_default() - .insert(declaration_id, ty); + .insert(declaration.id, ty); } }; } @@ -680,20 +679,20 @@ impl<'ast, T: Field> Checker<'ast, T> { _ => { for candidate in function_candidates { - match symbol_unifier.insert_function(declaration_id, candidate.signature.clone()) { + match symbol_unifier.insert_function(declaration.id, candidate.signature.clone()) { false => { errors.push(ErrorInner { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id, + declaration.id, ), }.in_file(module_id)); }, true => {} }; - let local_key = candidate.clone().id(declaration_id).module(module_id.to_path_buf()); + let local_key = candidate.clone().id(declaration.id).module(module_id.to_path_buf()); self.functions.insert(local_key.clone()); functions.insert( @@ -711,14 +710,14 @@ impl<'ast, T: Field> Checker<'ast, T> { }; } Symbol::Flat(funct) => { - match symbol_unifier.insert_function(declaration_id, funct.signature()) { + match symbol_unifier.insert_function(declaration.id, funct.signature()) { false => { errors.push( ErrorInner { pos: Some(pos), message: format!( "{} conflicts with another symbol", - declaration_id + declaration.id ), } .in_file(module_id), @@ -728,11 +727,11 @@ impl<'ast, T: Field> Checker<'ast, T> { }; self.functions.insert( - DeclarationFunctionKey::with_location(module_id.to_path_buf(), declaration_id) + DeclarationFunctionKey::with_location(module_id.to_path_buf(), declaration.id) .signature(funct.signature()), ); functions.insert( - DeclarationFunctionKey::with_location(module_id.to_path_buf(), declaration_id) + DeclarationFunctionKey::with_location(module_id.to_path_buf(), declaration.id) .signature(funct.signature()), TypedFunctionSymbol::Flat(funct), ); @@ -3267,7 +3266,7 @@ mod tests { let foo: Module = Module { symbols: vec![SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock()], @@ -3275,7 +3274,7 @@ mod tests { let bar: Module = Module { symbols: vec![SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::There(SymbolImport::with_id_in_module("main", "foo").mock()), } .mock()], @@ -3323,12 +3322,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock(), @@ -3401,12 +3400,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(f0)), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(f1)), } .mock(), @@ -3438,12 +3437,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock(), @@ -3490,12 +3489,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock(), @@ -3527,12 +3526,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(function1())), } .mock(), @@ -3576,12 +3575,12 @@ mod tests { let module: Module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Struct(struct0())), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Struct(struct1())), } .mock(), @@ -3612,12 +3611,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![] }.mock(), )), @@ -3653,7 +3652,7 @@ mod tests { // should fail let bar = Module::with_symbols(vec![SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock()]); @@ -3661,14 +3660,14 @@ mod tests { let main = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::There( SymbolImport::with_id_in_module("main", "bar").mock(), ), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Struct(struct0())), } .mock(), @@ -3701,7 +3700,7 @@ mod tests { // should fail let bar = Module::with_symbols(vec![SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(function0())), } .mock()]); @@ -3709,12 +3708,12 @@ mod tests { let main = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Struct(struct0())), } .mock(), SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::There( SymbolImport::with_id_in_module("main", "bar").mock(), ), @@ -3928,12 +3927,12 @@ mod tests { let symbols = vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("bar"), + id: "bar", symbol: Symbol::Here(SymbolDefinition::Function(bar)), } .mock(), @@ -4040,17 +4039,17 @@ mod tests { let symbols = vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("bar"), + id: "bar", symbol: Symbol::Here(SymbolDefinition::Function(bar)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main)), } .mock(), @@ -4430,12 +4429,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main)), } .mock(), @@ -4516,12 +4515,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main)), } .mock(), @@ -4631,12 +4630,12 @@ mod tests { let module = Module { symbols: vec![ SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main)), } .mock(), @@ -4929,12 +4928,12 @@ mod tests { let symbols = vec![ SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main1)), } .mock(), SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main2)), } .mock(), @@ -5040,7 +5039,7 @@ mod tests { ) -> (Checker, State) { let module: Module = Module { symbols: vec![SymbolDeclaration { - id: Some("Foo"), + id: "Foo", symbol: Symbol::Here(SymbolDefinition::Struct(s.mock())), } .mock()], @@ -5174,7 +5173,7 @@ mod tests { let module: Module = Module { symbols: vec![ SymbolDeclaration { - id: Some("Foo"), + id: "Foo", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![StructDefinitionField { @@ -5188,7 +5187,7 @@ mod tests { } .mock(), SymbolDeclaration { - id: Some("Bar"), + id: "Bar", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![StructDefinitionField { @@ -5242,7 +5241,7 @@ mod tests { let module: Module = Module { symbols: vec![SymbolDeclaration { - id: Some("Bar"), + id: "Bar", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![StructDefinitionField { @@ -5274,7 +5273,7 @@ mod tests { let module: Module = Module { symbols: vec![SymbolDeclaration { - id: Some("Foo"), + id: "Foo", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![StructDefinitionField { @@ -5308,7 +5307,7 @@ mod tests { let module: Module = Module { symbols: vec![ SymbolDeclaration { - id: Some("Foo"), + id: "Foo", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![StructDefinitionField { @@ -5322,7 +5321,7 @@ mod tests { } .mock(), SymbolDeclaration { - id: Some("Bar"), + id: "Bar", symbol: Symbol::Here(SymbolDefinition::Struct( StructDefinition { fields: vec![StructDefinitionField { @@ -5800,17 +5799,17 @@ mod tests { let m = Module::with_symbols(vec![ absy::SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo_field)), } .mock(), absy::SymbolDeclaration { - id: Some("foo"), + id: "foo", symbol: Symbol::Here(SymbolDefinition::Function(foo_u32)), } .mock(), absy::SymbolDeclaration { - id: Some("main"), + id: "main", symbol: Symbol::Here(SymbolDefinition::Function(main)), } .mock(),