From 4bb54dcd515b6dfc67e795818b4a5df2ec0375af Mon Sep 17 00:00:00 2001 From: TomAFrench Date: Wed, 26 Jul 2023 12:27:38 +0000 Subject: [PATCH] chore: fix compilation error --- crates/lsp/src/lib.rs | 4 +- crates/lsp/src/lib_hacky.rs | 4 +- .../src/monomorphization/mod.rs | 66 +++++++++---------- 3 files changed, 37 insertions(+), 37 deletions(-) diff --git a/crates/lsp/src/lib.rs b/crates/lsp/src/lib.rs index 1b93de288d9..bd4112218e4 100644 --- a/crates/lsp/src/lib.rs +++ b/crates/lsp/src/lib.rs @@ -194,7 +194,7 @@ fn on_code_lens_request( // We ignore the warnings and errors produced by compilation for producing codelenses // because we can still get the test functions even if compilation fails - let _ = check_crate(&mut context, crate_id, false, false); + let _ = check_crate(&mut context, crate_id, false); let fm = &context.file_manager; let files = fm.as_simple_files(); @@ -287,7 +287,7 @@ fn on_did_save_text_document( let mut diagnostics = Vec::new(); - let file_diagnostics = match check_crate(&mut context, crate_id, false, false) { + let file_diagnostics = match check_crate(&mut context, crate_id, false) { Ok(warnings) => warnings, Err(errors_and_warnings) => errors_and_warnings, }; diff --git a/crates/lsp/src/lib_hacky.rs b/crates/lsp/src/lib_hacky.rs index 5a12f0c3b6a..b8647639682 100644 --- a/crates/lsp/src/lib_hacky.rs +++ b/crates/lsp/src/lib_hacky.rs @@ -87,7 +87,7 @@ pub fn on_code_lens_request( // We ignore the warnings and errors produced by compilation for producing codelenses // because we can still get the test functions even if compilation fails - let _ = check_crate(&mut context, crate_id, false, false); + let _ = check_crate(&mut context, crate_id, false); let fm = &context.file_manager; let files = fm.as_simple_files(); @@ -206,7 +206,7 @@ pub fn on_did_save_text_document( Ok(res) => res, }; - let file_diagnostics = match check_crate(&mut context, crate_id, false, false) { + let file_diagnostics = match check_crate(&mut context, crate_id, false) { Ok(warnings) => warnings, Err(errors_and_warnings) => errors_and_warnings, }; diff --git a/crates/noirc_frontend/src/monomorphization/mod.rs b/crates/noirc_frontend/src/monomorphization/mod.rs index 0cdabcb7a4c..2001f9900e1 100644 --- a/crates/noirc_frontend/src/monomorphization/mod.rs +++ b/crates/noirc_frontend/src/monomorphization/mod.rs @@ -188,7 +188,7 @@ impl<'interner> Monomorphizer<'interner> { let meta = self.interner.function_meta(&f); let name = self.interner.function_name(&f).to_owned(); - let return_type = self.convert_type(meta.return_type()); + let return_type = Self::convert_type(meta.return_type()); let parameters = self.parameters(meta.parameters); let body = self.expr(*self.interner.function(&f).as_expr()); let unconstrained = meta.is_unconstrained; @@ -223,7 +223,7 @@ impl<'interner> Monomorphizer<'interner> { let new_id = self.next_local_id(); let definition = self.interner.definition(ident.id); let name = definition.name.clone(); - new_params.push((new_id, definition.mutable, name, self.convert_type(typ))); + new_params.push((new_id, definition.mutable, name, Self::convert_type(typ))); self.define_local(ident.id, new_id); } HirPattern::Mutable(pattern, _) => self.parameter(*pattern, typ, new_params), @@ -262,7 +262,7 @@ impl<'interner> Monomorphizer<'interner> { HirExpression::Literal(HirLiteral::Str(contents)) => Literal(Str(contents)), HirExpression::Literal(HirLiteral::Bool(value)) => Literal(Bool(value)), HirExpression::Literal(HirLiteral::Integer(value)) => { - let typ = self.convert_type(&self.interner.id_type(expr)); + let typ = Self::convert_type(&self.interner.id_type(expr)); Literal(Integer(value, typ)) } HirExpression::Literal(HirLiteral::Array(array)) => match array { @@ -277,7 +277,7 @@ impl<'interner> Monomorphizer<'interner> { HirExpression::Prefix(prefix) => ast::Expression::Unary(ast::Unary { operator: prefix.operator, rhs: Box::new(self.expr(prefix.rhs)), - result_type: self.convert_type(&self.interner.id_type(expr)), + result_type: Self::convert_type(&self.interner.id_type(expr)), }), HirExpression::Infix(infix) => { @@ -300,7 +300,7 @@ impl<'interner> Monomorphizer<'interner> { HirExpression::Cast(cast) => ast::Expression::Cast(ast::Cast { lhs: Box::new(self.expr(cast.lhs)), - r#type: self.convert_type(&cast.r#type), + r#type: Self::convert_type(&cast.r#type), }), HirExpression::For(for_expr) => { @@ -314,7 +314,7 @@ impl<'interner> Monomorphizer<'interner> { ast::Expression::For(ast::For { index_variable, index_name: self.interner.definition_name(for_expr.identifier.id).to_owned(), - index_type: self.convert_type(&self.interner.id_type(for_expr.start_range)), + index_type: Self::convert_type(&self.interner.id_type(for_expr.start_range)), start_range: Box::new(start), end_range: Box::new(end), block, @@ -329,7 +329,7 @@ impl<'interner> Monomorphizer<'interner> { condition: Box::new(cond), consequence: Box::new(then), alternative: else_, - typ: self.convert_type(&self.interner.id_type(expr)), + typ: Self::convert_type(&self.interner.id_type(expr)), }) } @@ -354,7 +354,7 @@ impl<'interner> Monomorphizer<'interner> { array_elements: Vec, ) -> ast::Expression { let element_type = - self.convert_type(&unwrap_array_element_type(&self.interner.id_type(array))); + Self::convert_type(&unwrap_array_element_type(&self.interner.id_type(array))); let contents = vecmap(array_elements, |id| self.expr(id)); self.aos_to_soa(contents, element_type) } @@ -364,7 +364,7 @@ impl<'interner> Monomorphizer<'interner> { repeated_element: node_interner::ExprId, length: HirType, ) -> ast::Expression { - let element_type = self.convert_type(&self.interner.id_type(repeated_element)); + let element_type = Self::convert_type(&self.interner.id_type(repeated_element)); let contents = self.expr(repeated_element); let length = length .evaluate_to_u64() @@ -384,14 +384,14 @@ impl<'interner> Monomorphizer<'interner> { array_contents: Vec, element_type: ast::Type, ) -> ast::Expression { - return ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { + ast::Expression::Literal(ast::Literal::Array(ast::ArrayLiteral { contents: array_contents, element_type, - })); + })) } fn index(&mut self, id: node_interner::ExprId, index: HirIndexExpression) -> ast::Expression { - let element_type = self.convert_type(&self.interner.id_type(id)); + let element_type = Self::convert_type(&self.interner.id_type(id)); let collection = Box::new(self.expr(index.collection)); let index = Box::new(self.expr(index.index)); @@ -408,7 +408,7 @@ impl<'interner> Monomorphizer<'interner> { element_type: ast::Type, location: Location, ) -> ast::Expression { - return ast::Expression::Index(ast::Index { collection, index, element_type, location }); + ast::Expression::Index(ast::Index { collection, index, element_type, location }) } fn statement(&mut self, id: StmtId) -> ast::Expression { @@ -450,7 +450,7 @@ impl<'interner> Monomorphizer<'interner> { for (field_name, expr_id) in constructor.fields { let new_id = self.next_local_id(); let field_type = field_type_map.get(&field_name.0.contents).unwrap(); - let typ = self.convert_type(field_type); + let typ = Self::convert_type(field_type); field_vars.insert(field_name.0.contents.clone(), (new_id, typ)); let expression = Box::new(self.expr(expr_id)); @@ -546,7 +546,7 @@ impl<'interner> Monomorphizer<'interner> { let mutable = false; let definition = Definition::Local(fresh_id); let name = i.to_string(); - let typ = self.convert_type(&field_type); + let typ = Self::convert_type(&field_type); let new_rhs = ast::Expression::Ident(ast::Ident { location, mutable, definition, name, typ }); @@ -566,7 +566,7 @@ impl<'interner> Monomorphizer<'interner> { let mutable = definition.mutable; let definition = self.lookup_local(ident.id)?; - let typ = self.convert_type(&self.interner.id_type(ident.id)); + let typ = Self::convert_type(&self.interner.id_type(ident.id)); Some(ast::Ident { location: Some(ident.location), mutable, definition, name, typ }) } @@ -581,7 +581,7 @@ impl<'interner> Monomorphizer<'interner> { let typ = self.interner.id_type(expr_id); let definition = self.lookup_function(*func_id, expr_id, &typ); - let typ = self.convert_type(&typ); + let typ = Self::convert_type(&typ); let ident = ast::Ident { location, mutable, definition, name, typ }; ast::Expression::Ident(ident) } @@ -607,7 +607,7 @@ impl<'interner> Monomorphizer<'interner> { } /// Convert a non-tuple/struct type to a monomorphized type - fn convert_type(&self, typ: &HirType) -> ast::Type { + fn convert_type(typ: &HirType) -> ast::Type { match typ { HirType::FieldElement(_) => ast::Type::Field, HirType::Integer(_, sign, bits) => ast::Type::Integer(*sign, *bits), @@ -617,12 +617,12 @@ impl<'interner> Monomorphizer<'interner> { HirType::Array(length, element) => { let length = length.evaluate_to_u64().unwrap_or(0); - let element = self.convert_type(element.as_ref()); - return ast::Type::Array(length, Box::new(element)); + let element = Self::convert_type(element.as_ref()); + ast::Type::Array(length, Box::new(element)) } HirType::Slice(element) => { - let element = self.convert_type(element.as_ref()); + let element = Self::convert_type(element.as_ref()); ast::Type::Slice(Box::new(element)) } @@ -630,7 +630,7 @@ impl<'interner> Monomorphizer<'interner> { | HirType::TypeVariable(binding) | HirType::NamedGeneric(binding, _) => { if let TypeBinding::Bound(binding) = &*binding.borrow() { - return self.convert_type(binding); + return Self::convert_type(binding); } // Default any remaining unbound type variables to Field. @@ -647,23 +647,23 @@ impl<'interner> Monomorphizer<'interner> { HirType::Struct(def, args) => { let fields = def.borrow().get_fields(args); - let fields = vecmap(fields, |(_, field)| self.convert_type(&field)); + let fields = vecmap(fields, |(_, field)| Self::convert_type(&field)); ast::Type::Tuple(fields) } HirType::Tuple(fields) => { - let fields = vecmap(fields, |typ| self.convert_type(typ)); + let fields = vecmap(fields, Self::convert_type); ast::Type::Tuple(fields) } HirType::Function(args, ret) => { - let args = vecmap(args, |typ| self.convert_type(typ)); - let ret = Box::new(self.convert_type(ret)); + let args = vecmap(args, Self::convert_type); + let ret = Box::new(Self::convert_type(ret)); ast::Type::Function(args, ret) } HirType::MutableReference(element) => { - let element = self.convert_type(element); + let element = Self::convert_type(element); ast::Type::MutableReference(Box::new(element)) } @@ -682,7 +682,7 @@ impl<'interner> Monomorphizer<'interner> { let mut arguments = vecmap(&call.arguments, |id| self.expr(*id)); let hir_arguments = vecmap(&call.arguments, |id| self.interner.expression(id)); let return_type = self.interner.id_type(id); - let return_type = self.convert_type(&return_type); + let return_type = Self::convert_type(&return_type); let location = call.location; if let ast::Expression::Ident(ident) = func.as_ref() { @@ -870,13 +870,13 @@ impl<'interner> Monomorphizer<'interner> { ); let index = Box::new(self.expr(index)); - let element_type = self.convert_type(&typ); + let element_type = Self::convert_type(&typ); (array, Some((index, element_type, location))) } HirLValue::Dereference { lvalue, element_type } => { let (reference, index) = self.lvalue(*lvalue); let reference = Box::new(reference); - let element_type = self.convert_type(&element_type); + let element_type = Self::convert_type(&element_type); let lvalue = ast::LValue::Dereference { reference, element_type }; (lvalue, index) } @@ -892,13 +892,13 @@ impl<'interner> Monomorphizer<'interner> { location: Location, ) -> ast::Expression { let lvalue = ast::LValue::Index { array: lvalue, index, element_type: typ, location }; - return ast::Expression::Assign(ast::Assign { lvalue, expression }); + ast::Expression::Assign(ast::Assign { lvalue, expression }) } fn lambda(&mut self, lambda: HirLambda) -> ast::Expression { - let ret_type = self.convert_type(&lambda.return_type); + let ret_type = Self::convert_type(&lambda.return_type); let lambda_name = "lambda"; - let parameter_types = vecmap(&lambda.parameters, |(_, typ)| self.convert_type(typ)); + let parameter_types = vecmap(&lambda.parameters, |(_, typ)| Self::convert_type(typ)); // Manually convert to Parameters type so we can reuse the self.parameters method let parameters = Parameters(vecmap(lambda.parameters, |(pattern, typ)| {