feat: Implement turbofish operator

compiler/noirc_frontend/Cargo.toml

@@ -14,7 +14,6 @@ noirc_arena.workspace = true
 noirc_errors.workspace = true
 noirc_printable_type.workspace = true
 fm.workspace = true
-fxhash.workspace = true
 iter-extended.workspace = true
 chumsky.workspace = true
 thiserror.workspace = true

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -328,8 +328,12 @@ impl<'context> Elaborator<'context> {
                 // Desugar the method call into a normal, resolved function call
                 // so that the backend doesn't need to worry about methods
                 // TODO: update object_type here?
-                let ((function_id, function_name), function_call, _) = method_call
-                    .into_function_call(&method_ref, object_type, location, self.interner);
+                let ((function_id, function_name), function_call) = method_call.into_function_call(
+                    &method_ref,
+                    object_type,
+                    location,
+                    self.interner,
+                );
 
                 let func_type = self.type_check_variable(function_name, function_id);
 

compiler/noirc_frontend/src/hir/type_check/expr.rs

@@ -249,18 +249,13 @@ impl<'interner> TypeChecker<'interner> {
                             }
                         }
 
-                        // Need to borrow `generics` here as `method_call` is moved when calling `into_function_call`
-                        // We don't save the expected generic count just yet though as `into_function_call` also accounts
-                        // for any implicit generics such as from a generic impl.
-                        let has_turbofish_generics = method_call.generics.is_some();
                         // TODO: update object_type here?
-                        let (_, function_call, implicit_generics_count) = method_call
-                            .into_function_call(&method_ref, object_type, location, self.interner);
-
-                        if has_turbofish_generics {
-                            self.method_call_implicit_generic_counts
-                                .insert(function_call.func, implicit_generics_count);
-                        }
+                        let (_, function_call) = method_call.into_function_call(
+                            &method_ref,
+                            object_type,
+                            location,
+                            self.interner,
+                        );
 
                         self.interner.replace_expr(expr_id, HirExpression::Call(function_call));
 
@@ -394,20 +389,10 @@ impl<'interner> TypeChecker<'interner> {
             _ => 0,
         });
 
-        let implicit_generic_count =
-            self.method_call_implicit_generic_counts.get(expr_id).copied().unwrap_or_default();
-
         // This instantiates a trait's generics as well which need to be set
         // when the constraint below is later solved for when the function is
         // finished. How to link the two?
-        let (typ, bindings) = self.instantiate(
-            t,
-            bindings,
-            generics,
-            function_generic_count,
-            implicit_generic_count,
-            span,
-        );
+        let (typ, bindings) = self.instantiate(t, bindings, generics, function_generic_count, span);
 
         // Push any trait constraints required by this definition to the context
         // to be checked later when the type of this variable is further constrained.
@@ -448,24 +433,25 @@ impl<'interner> TypeChecker<'interner> {
         bindings: TypeBindings,
         generics: Option<Vec<Type>>,
         function_generic_count: usize,
-        implicit_generic_count: usize,
         span: Span,
     ) -> (Type, TypeBindings) {
         match generics {
             Some(generics) => {
-                if generics.len() != (function_generic_count + implicit_generic_count) {
-                    // The list of `generics` represents the total number of generics on a function, including implicit generics.
-                    // We calculate any implicit generics earlier when type checking a method call,
-                    // In a user facing error we want to display only the number of function generics
-                    // as this is what the user will actually be specifying.
+                if generics.len() != function_generic_count {
                     self.errors.push(TypeCheckError::IncorrectTurbofishGenericCount {
                         expected_count: function_generic_count,
-                        actual_count: generics.len() - implicit_generic_count,
+                        actual_count: generics.len(),
                         span,
                     });
                     typ.instantiate_with_bindings(bindings, self.interner)
                 } else {
-                    typ.instantiate_with(generics)
+                    // Fetch the count of any implicit generics on the function, such as
+                    // for a method within a generic impl.
+                    let implicit_generic_count = match &typ {
+                        Type::Forall(generics, _) => generics.len() - function_generic_count,
+                        _ => 0,
+                    };
+                    typ.instantiate_with(generics, self.interner, implicit_generic_count)
                 }
             }
             None => typ.instantiate_with_bindings(bindings, self.interner),

compiler/noirc_frontend/src/hir/type_check/mod.rs

@@ -24,7 +24,6 @@ use crate::{
     node_interner::{ExprId, FuncId, GlobalId, NodeInterner},
     Type, TypeBindings,
 };
-use fxhash::FxHashMap as HashMap;
 
 pub use self::errors::Source;
 
@@ -43,10 +42,6 @@ pub struct TypeChecker<'interner> {
     /// This map is used to default any integer type variables at the end of
     /// a function (before checking trait constraints) if a type wasn't already chosen.
     type_variables: Vec<Type>,
-
-    /// Method calls can have implicit generics from generic impls.
-    /// These need to be tracked separately for accurate type checking.
-    method_call_implicit_generic_counts: HashMap<ExprId, usize>,
 }
 
 /// Type checks a function and assigns the
@@ -359,7 +354,6 @@ impl<'interner> TypeChecker<'interner> {
             trait_constraints: Vec::new(),
             type_variables: Vec::new(),
             current_function: None,
-            method_call_implicit_generic_counts: HashMap::default(),
         }
     }
 
@@ -377,7 +371,6 @@ impl<'interner> TypeChecker<'interner> {
             trait_constraints: Vec::new(),
             type_variables: Vec::new(),
             current_function: None,
-            method_call_implicit_generic_counts: HashMap::default(),
         };
         let statement = this.interner.get_global(id).let_statement;
         this.check_statement(&statement);

compiler/noirc_frontend/src/hir_def/expr.rs

@@ -212,28 +212,7 @@ impl HirMethodCallExpression {
         object_type: Type,
         location: Location,
         interner: &mut NodeInterner,
-    ) -> ((ExprId, HirIdent), HirCallExpression, usize) {
-        // Attach any generics which may not be a part of the function call's explicit generics
-        // This includes types such as implicit generics if the function is part of an impl
-        let (generics, generics_count) = if let Some(mut function_generics) = self.generics
-        {
-            let mut generics = Vec::new();
-            match object_type.clone() {
-                Type::Struct(_, mut struct_generics) => {
-                    generics.append(&mut struct_generics);
-                }
-                _ => {
-                    // TODO: Support other types that may contain generics such as `TraitAsType`
-                    unreachable!("Only struct method calls are supported");
-                }
-            };
-            let implicit_generics_count = generics.len();
-            generics.append(&mut function_generics);
-            (Some(generics), implicit_generics_count)
-        } else {
-            (None, 0)
-        };
-
+    ) -> ((ExprId, HirIdent), HirCallExpression) {
         let mut arguments = vec![self.object];
         arguments.append(&mut self.arguments);
 
@@ -252,10 +231,10 @@ impl HirMethodCallExpression {
             }
         };
         let func_var = HirIdent { location, id, impl_kind };
-        let func = interner.push_expr(HirExpression::Ident(func_var.clone(), generics));
+        let func = interner.push_expr(HirExpression::Ident(func_var.clone(), self.generics));
         interner.push_expr_location(func, location.span, location.file);
         let expr = HirCallExpression { func, arguments, location };
-        ((func, func_var), expr, generics_count)
+        ((func, func_var), expr)
     }
 }
 

compiler/noirc_frontend/src/hir_def/types.rs

@@ -1485,16 +1485,28 @@ impl Type {
     /// is used and generic substitutions are provided manually by users.
     ///
     /// Expects the given type vector to be the same length as the Forall type variables.
-    pub fn instantiate_with(&self, types: Vec<Type>) -> (Type, TypeBindings) {
+    pub fn instantiate_with(
+        &self,
+        types: Vec<Type>,
+        interner: &NodeInterner,
+        implicit_generic_count: usize,
+    ) -> (Type, TypeBindings) {
         match self {
             Type::Forall(typevars, typ) => {
-                assert_eq!(types.len(), typevars.len(), "Turbofish operator used with incorrect generic count which was not caught by name resolution");
+                assert_eq!(types.len() + implicit_generic_count, typevars.len(), "Turbofish operator used with incorrect generic count which was not caught by name resolution");
 
-                let replacements = typevars
+                let mut replacements = typevars[..implicit_generic_count]
                     .iter()
-                    .zip(types)
-                    .map(|(var, binding)| (var.id(), (var.clone(), binding)))
-                    .collect();
+                    .map(|var| {
+                        let new = interner.next_type_variable();
+                        (var.id(), (var.clone(), new))
+                    })
+                    .collect::<HashMap<_, _>>();
+
+                // `zip` ends at the shorter iterator so we skip any implicit generics included in the `Forall` type
+                for (var, binding) in typevars.iter().skip(implicit_generic_count).zip(types) {
+                    replacements.insert(var.id(), (var.clone(), binding));
+                }
 
                 let instantiated = typ.substitute(&replacements);
                 (instantiated, replacements)

compiler/noirc_frontend/src/parser/parser.rs

@@ -1044,6 +1044,7 @@ where
             expr_no_constructors,
             statement,
             allow_constructors,
+            parse_type(),
         ))
     })
 }
@@ -1064,6 +1065,7 @@ fn atom_or_right_unary<'a, P, P2, S>(
     expr_no_constructors: P2,
     statement: S,
     allow_constructors: bool,
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
 ) -> impl NoirParser<Expression> + 'a
 where
     P: ExprParser + 'a,
@@ -1088,12 +1090,12 @@ where
 
     // `as Type` in `atom as Type`
     let cast_rhs = keyword(Keyword::As)
-        .ignore_then(parse_type())
+        .ignore_then(type_parser.clone())
         .map(UnaryRhs::Cast)
         .labelled(ParsingRuleLabel::Cast);
 
     // A turbofish operator is optional in a method call to specify generic types
-    let turbofish = primitives::turbofish(parse_type());
+    let turbofish = primitives::turbofish(type_parser);
 
     // `.foo` or `.foo(args)` in `atom.foo` or `atom.foo(args)`
     let member_rhs = just(Token::Dot)
@@ -1384,11 +1386,12 @@ mod test {
                 expression_no_constructors(expression()),
                 fresh_statement(),
                 true,
+                parse_type(),
             ),
             vec!["x as u8", "x as u16", "0 as Field", "(x + 3) as [Field; 8]"],
         );
         parse_all_failing(
-            atom_or_right_unary(expression(), expression_nc, fresh_statement(), true),
+            atom_or_right_unary(expression(), expression_nc, fresh_statement(), true, parse_type()),
             vec!["x as pub u8"],
         );
     }
@@ -1408,6 +1411,7 @@ mod test {
                 expression_no_constructors(expression()),
                 fresh_statement(),
                 true,
+                parse_type(),
             ),
             valid,
         );

tooling/nargo_fmt/src/rewrite/expr.rs

@@ -1,5 +1,5 @@
 use noirc_frontend::ast::{
-    ArrayLiteral, BlockExpression, Expression, ExpressionKind, Literal, UnaryOp,
+    ArrayLiteral, BlockExpression, Expression, ExpressionKind, Literal, UnaryOp, UnresolvedType,
 };
 use noirc_frontend::{macros_api::Span, token::Token};
 
@@ -73,6 +73,7 @@ pub(crate) fn rewrite(
 
             let object = rewrite_sub_expr(visitor, shape, method_call_expr.object);
             let method = method_call_expr.method_name.to_string();
+            let turbofish = rewrite_turbofish(visitor, shape, method_call_expr.generics);
             let args = format_parens(
                 visitor.config.fn_call_width.into(),
                 visitor.fork(),
@@ -84,21 +85,7 @@ pub(crate) fn rewrite(
                 NewlineMode::IfContainsNewLineAndWidth,
             );
 
-            if let Some(generics) = method_call_expr.generics {
-                let mut turbofish = "".to_owned();
-                for (i, generic) in generics.into_iter().enumerate() {
-                    let generic = rewrite::typ(visitor, shape, generic);
-                    turbofish = if i == 0 {
-                        format!("<{}", generic)
-                    } else {
-                        format!("{turbofish}, {}", generic)
-                    };
-                }
-                turbofish = format!("{turbofish}>");
-                format!("{object}.{method}::{turbofish}{args}")
-            } else {
-                format!("{object}.{method}{args}")
-            }
+            format!("{object}.{method}{turbofish}{args}")
         }
         ExpressionKind::MemberAccess(member_access_expr) => {
             let lhs_str = rewrite_sub_expr(visitor, shape, member_access_expr.lhs);
@@ -172,9 +159,13 @@ pub(crate) fn rewrite(
 
             visitor.format_if(*if_expr)
         }
-        ExpressionKind::Lambda(_) | ExpressionKind::Variable(_, _) => {
-            visitor.slice(span).to_string()
+        ExpressionKind::Variable(path, generics) => {
+            let path_string = visitor.slice(path.span);
+
+            let turbofish = rewrite_turbofish(visitor, shape, generics);
+            format!("{path_string}{turbofish}")
         }
+        ExpressionKind::Lambda(_) => visitor.slice(span).to_string(),
         ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
         ExpressionKind::Comptime(block) => {
             format!("comptime {}", rewrite_block(visitor, block, span))
@@ -188,3 +179,24 @@ fn rewrite_block(visitor: &FmtVisitor, block: BlockExpression, span: Span) -> St
     visitor.visit_block(block, span);
     visitor.finish()
 }
+
+fn rewrite_turbofish(
+    visitor: &FmtVisitor,
+    shape: Shape,
+    generics: Option<Vec<UnresolvedType>>,
+) -> String {
+    if let Some(generics) = generics {
+        let mut turbofish = "".to_owned();
+        for (i, generic) in generics.into_iter().enumerate() {
+            let generic = rewrite::typ(visitor, shape, generic);
+            turbofish = if i == 0 {
+                format!("::<{}", generic)
+            } else {
+                format!("{turbofish}, {}", generic)
+            };
+        }
+        format!("{turbofish}>")
+    } else {
+        "".to_owned()
+    }
+}

tooling/nargo_fmt/tests/expected/turbofish_call.nr

@@ -5,4 +5,4 @@ fn foo() {
         some_function(), // Original inner function call
         another_function() // Original inner function call
     );
-}
+}

tooling/nargo_fmt/tests/expected/turbofish_method_call.nr

@@ -9,4 +9,4 @@ fn foo() {
             )
         )
     );
-}
+}