Merge branch 'master' into ab/incorrect-generic-count-on-impl

compiler/noirc_frontend/src/ast/statement.rs

@@ -461,6 +461,18 @@ pub struct PathSegment {
     pub span: Span,
 }
 
+impl PathSegment {
+    /// Returns the span where turbofish happen. For example:
+    ///
+    ///    foo::<T>
+    ///       ~^^^^
+    ///
+    /// Returns an empty span at the end of `foo` if there's no turbofish.
+    pub fn turbofish_span(&self) -> Span {
+        Span::from(self.ident.span().end()..self.span.end())
+    }
+}
+
 impl From<Ident> for PathSegment {
     fn from(ident: Ident) -> PathSegment {
         let span = ident.span();

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -39,7 +39,7 @@ impl<'context> Elaborator<'context> {
         let (hir_expr, typ) = match expr.kind {
             ExpressionKind::Literal(literal) => self.elaborate_literal(literal, expr.span),
             ExpressionKind::Block(block) => self.elaborate_block(block),
-            ExpressionKind::Prefix(prefix) => return self.elaborate_prefix(*prefix),
+            ExpressionKind::Prefix(prefix) => return self.elaborate_prefix(*prefix, expr.span),
             ExpressionKind::Index(index) => self.elaborate_index(*index),
             ExpressionKind::Call(call) => self.elaborate_call(*call, expr.span),
             ExpressionKind::MethodCall(call) => self.elaborate_method_call(*call, expr.span),
@@ -225,8 +225,7 @@ impl<'context> Elaborator<'context> {
         (HirExpression::Literal(HirLiteral::FmtStr(str, fmt_str_idents)), typ)
     }
 
-    fn elaborate_prefix(&mut self, prefix: PrefixExpression) -> (ExprId, Type) {
-        let span = prefix.rhs.span;
+    fn elaborate_prefix(&mut self, prefix: PrefixExpression, span: Span) -> (ExprId, Type) {
         let (rhs, rhs_type) = self.elaborate_expression(prefix.rhs);
         let trait_id = self.interner.get_prefix_operator_trait_method(&prefix.operator);
 
@@ -430,23 +429,14 @@ impl<'context> Elaborator<'context> {
             }
         };
 
-        let struct_generics = if let Some(turbofish_generics) = &last_segment.generics {
-            if turbofish_generics.len() == struct_generics.len() {
-                let struct_type = r#type.borrow();
-                self.resolve_turbofish_generics(&struct_type.generics, turbofish_generics.clone())
-            } else {
-                self.push_err(TypeCheckError::GenericCountMismatch {
-                    item: format!("struct {}", last_segment.ident),
-                    expected: struct_generics.len(),
-                    found: turbofish_generics.len(),
-                    span: Span::from(last_segment.ident.span().end()..last_segment.span.end()),
-                });
+        let turbofish_span = last_segment.turbofish_span();
 
-                struct_generics
-            }
-        } else {
-            struct_generics
-        };
+        let struct_generics = self.resolve_struct_turbofish_generics(
+            &r#type.borrow(),
+            struct_generics,
+            last_segment.generics,
+            turbofish_span,
+        );
 
         let struct_type = r#type.clone();
         let generics = struct_generics.clone();

compiler/noirc_frontend/src/elaborator/patterns.rs

@@ -157,8 +157,12 @@ impl<'context> Elaborator<'context> {
         mutable: Option<Span>,
         new_definitions: &mut Vec<HirIdent>,
     ) -> HirPattern {
-        let name_span = name.last_ident().span();
-        let is_self_type = name.last_ident().is_self_type_name();
+        let exclude_last_segment = true;
+        self.check_unsupported_turbofish_usage(&name, exclude_last_segment);
+
+        let last_segment = name.last_segment();
+        let name_span = last_segment.ident.span();
+        let is_self_type = last_segment.ident.is_self_type_name();
 
         let error_identifier = |this: &mut Self| {
             // Must create a name here to return a HirPattern::Identifier. Allowing
@@ -178,6 +182,15 @@ impl<'context> Elaborator<'context> {
             }
         };
 
+        let turbofish_span = last_segment.turbofish_span();
+
+        let generics = self.resolve_struct_turbofish_generics(
+            &struct_type.borrow(),
+            generics,
+            last_segment.generics,
+            turbofish_span,
+        );
+
         let actual_type = Type::Struct(struct_type.clone(), generics);
         let location = Location::new(span, self.file);
 
@@ -426,6 +439,30 @@ impl<'context> Elaborator<'context> {
         })
     }
 
+    pub(super) fn resolve_struct_turbofish_generics(
+        &mut self,
+        struct_type: &StructType,
+        generics: Vec<Type>,
+        unresolved_turbofish: Option<Vec<UnresolvedType>>,
+        span: Span,
+    ) -> Vec<Type> {
+        let Some(turbofish_generics) = unresolved_turbofish else {
+            return generics;
+        };
+
+        if turbofish_generics.len() != generics.len() {
+            self.push_err(TypeCheckError::GenericCountMismatch {
+                item: format!("struct {}", struct_type.name),
+                expected: generics.len(),
+                found: turbofish_generics.len(),
+                span,
+            });
+            return generics;
+        }
+
+        self.resolve_turbofish_generics(&struct_type.generics, turbofish_generics)
+    }
+
     pub(super) fn resolve_turbofish_generics(
         &mut self,
         generics: &[ResolvedGeneric],

compiler/noirc_frontend/src/elaborator/types.rs

@@ -1635,8 +1635,7 @@ impl<'context> Elaborator<'context> {
             }
 
             if segment.generics.is_some() {
-                // From "foo::<T>", create a span for just "::<T>"
-                let span = Span::from(segment.ident.span().end()..segment.span.end());
+                let span = segment.turbofish_span();
                 self.push_err(TypeCheckError::UnsupportedTurbofishUsage { span });
             }
         }

compiler/noirc_frontend/src/parser/parser.rs

@@ -557,7 +557,7 @@ fn pattern() -> impl NoirParser<Pattern> {
             .separated_by(just(Token::Comma))
             .delimited_by(just(Token::LeftBrace), just(Token::RightBrace));
 
-        let struct_pattern = path()
+        let struct_pattern = path(super::parse_type())
             .then(struct_pattern_fields)
             .map_with_span(|(typename, fields), span| Pattern::Struct(typename, fields, span));
 
@@ -1128,7 +1128,7 @@ fn constructor(expr_parser: impl ExprParser) -> impl NoirParser<ExpressionKind>
         .allow_trailing()
         .delimited_by(just(Token::LeftBrace), just(Token::RightBrace));
 
-    path().then(args).map(ExpressionKind::constructor)
+    path(super::parse_type()).then(args).map(ExpressionKind::constructor)
 }
 
 fn constructor_field<P>(expr_parser: P) -> impl NoirParser<(Ident, Expression)>

compiler/noirc_frontend/src/parser/parser/path.rs

@@ -1,4 +1,4 @@
-use crate::ast::{Path, PathKind, PathSegment};
+use crate::ast::{Path, PathKind, PathSegment, UnresolvedType};
 use crate::parser::NoirParser;
 
 use crate::token::{Keyword, Token};
@@ -8,8 +8,10 @@ use chumsky::prelude::*;
 use super::keyword;
 use super::primitives::{path_segment, path_segment_no_turbofish};
 
-pub(super) fn path() -> impl NoirParser<Path> {
-    path_inner(path_segment())
+pub(super) fn path<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<Path> + 'a {
+    path_inner(path_segment(type_parser))
 }
 
 pub(super) fn path_no_turbofish() -> impl NoirParser<Path> {
@@ -40,13 +42,16 @@ fn empty_path() -> impl NoirParser<Path> {
 }
 
 pub(super) fn maybe_empty_path() -> impl NoirParser<Path> {
-    path().or(empty_path())
+    path_no_turbofish().or(empty_path())
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::parser::parser::test_helpers::{parse_all_failing, parse_with};
+    use crate::parser::{
+        parse_type,
+        parser::test_helpers::{parse_all_failing, parse_with},
+    };
 
     #[test]
     fn parse_path() {
@@ -59,13 +64,13 @@ mod test {
         ];
 
         for (src, expected_segments) in cases {
-            let path: Path = parse_with(path(), src).unwrap();
+            let path: Path = parse_with(path(parse_type()), src).unwrap();
             for (segment, expected) in path.segments.into_iter().zip(expected_segments) {
                 assert_eq!(segment.ident.0.contents, expected);
             }
         }
 
-        parse_all_failing(path(), vec!["std::", "::std", "std::hash::", "foo::1"]);
+        parse_all_failing(path(parse_type()), vec!["std::", "::std", "std::hash::", "foo::1"]);
     }
 
     #[test]
@@ -78,12 +83,12 @@ mod test {
         ];
 
         for (src, expected_path_kind) in cases {
-            let path = parse_with(path(), src).unwrap();
+            let path = parse_with(path(parse_type()), src).unwrap();
             assert_eq!(path.kind, expected_path_kind);
         }
 
         parse_all_failing(
-            path(),
+            path(parse_type()),
             vec!["crate", "crate::std::crate", "foo::bar::crate", "foo::dep"],
         );
     }

compiler/noirc_frontend/src/parser/parser/primitives.rs

@@ -33,10 +33,14 @@ pub(super) fn token_kind(token_kind: TokenKind) -> impl NoirParser<Token> {
     })
 }
 
-pub(super) fn path_segment() -> impl NoirParser<PathSegment> {
-    ident()
-        .then(turbofish(super::parse_type()))
-        .map_with_span(|(ident, generics), span| PathSegment { ident, generics, span })
+pub(super) fn path_segment<'a>(
+    type_parser: impl NoirParser<UnresolvedType> + 'a,
+) -> impl NoirParser<PathSegment> + 'a {
+    ident().then(turbofish(type_parser)).map_with_span(|(ident, generics), span| PathSegment {
+        ident,
+        generics,
+        span,
+    })
 }
 
 pub(super) fn path_segment_no_turbofish() -> impl NoirParser<PathSegment> {
@@ -96,7 +100,7 @@ pub(super) fn turbofish<'a>(
 }
 
 pub(super) fn variable() -> impl NoirParser<ExpressionKind> {
-    path().map(ExpressionKind::Variable)
+    path(super::parse_type()).map(ExpressionKind::Variable)
 }
 
 pub(super) fn variable_no_turbofish() -> impl NoirParser<ExpressionKind> {

compiler/noirc_frontend/src/tests.rs

@@ -2611,13 +2611,82 @@ fn turbofish_in_middle_of_variable_unsupported_yet() {
     ));
 }
 
+#[test]
+fn turbofish_in_struct_pattern() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    fn main() {
+        let value: Field = 0;
+        let Foo::<Field> { x } = Foo { x: value };
+        let _ = x;
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn turbofish_in_struct_pattern_errors_if_type_mismatch() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    fn main() {
+        let value: Field = 0;
+        let Foo::<i32> { x } = Foo { x: value };
+        let _ = x;
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::TypeMismatchWithSource { .. }) = &errors[0].0
+    else {
+        panic!("Expected a type mismatch error, got {:?}", errors[0].0);
+    };
+}
+
+#[test]
+fn turbofish_in_struct_pattern_generic_count_mismatch() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    fn main() {
+        let value = 0;
+        let Foo::<i32, i64> { x } = Foo { x: value };
+        let _ = x;
+    }
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::TypeError(TypeCheckError::GenericCountMismatch {
+        item,
+        expected,
+        found,
+        ..
+    }) = &errors[0].0
+    else {
+        panic!("Expected a generic count mismatch error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(item, "struct Foo");
+    assert_eq!(*expected, 1);
+    assert_eq!(*found, 2);
+}
+
 #[test]
 fn incorrect_generic_count_on_struct_impl() {
     let src = r#"
     struct Foo {}
-
     impl <T> Foo<T> {}
-
     fn main() {}
     "#;
 
@@ -2641,9 +2710,7 @@ fn incorrect_generic_count_on_struct_impl() {
 fn incorrect_generic_count_on_type_alias() {
     let src = r#"
     struct Foo {}
-
     type Bar = Foo<i32>;
-
     fn main() {}
     "#;