Error on unsupported turbofish usage

compiler/noirc_frontend/src/ast/statement.rs

@@ -458,11 +458,13 @@ impl Path {
 pub struct PathSegment {
     pub ident: Ident,
     pub generics: Option<Vec<UnresolvedType>>,
+    pub span: Span,
 }
 
 impl From<Ident> for PathSegment {
     fn from(ident: Ident) -> PathSegment {
-        PathSegment { ident, generics: None }
+        let span = ident.span();
+        PathSegment { ident, generics: None, span }
     }
 }
 

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -408,6 +408,9 @@ impl<'context> Elaborator<'context> {
         &mut self,
         constructor: ConstructorExpression,
     ) -> (HirExpression, Type) {
+        let exclude_last_segment = false;
+        self.check_unsupported_turbofish_usage(&constructor.type_name, exclude_last_segment);
+
         let span = constructor.type_name.span();
         let last_segment = constructor.type_name.last_ident();
         let is_self_type = last_segment.is_self_type_name();

compiler/noirc_frontend/src/elaborator/patterns.rs

@@ -430,6 +430,9 @@ impl<'context> Elaborator<'context> {
     }
 
     pub(super) fn elaborate_variable(&mut self, variable: Path) -> (ExprId, Type) {
+        let exclude_last_segment = true;
+        self.check_unsupported_turbofish_usage(&variable, exclude_last_segment);
+
         let unresolved_turbofish = variable.segments.last().unwrap().generics.clone();
 
         let span = variable.span;

compiler/noirc_frontend/src/elaborator/types.rs

@@ -1614,6 +1614,20 @@ impl<'context> Elaborator<'context> {
         let context = context.expect("The function_context stack should always be non-empty");
         context.trait_constraints.push((constraint, expr_id));
     }
+
+    pub fn check_unsupported_turbofish_usage(&mut self, path: &Path, exclude_last_segment: bool) {
+        for (index, segment) in path.segments.iter().enumerate() {
+            if exclude_last_segment && index == path.segments.len() - 1 {
+                continue;
+            }
+
+            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());
+                self.push_err(TypeCheckError::UnsupportedTurbofishUsage { span })
+            }
+        }
+    }
 }
 
 /// Gives an error if a user tries to create a mutable reference

compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs

@@ -89,12 +89,12 @@ impl HirExpression {
         let kind = match self {
             HirExpression::Ident(ident, generics) => {
                 let ident = ident.to_display_ast(interner);
-                let span = ident.span();
                 let segment = PathSegment {
                     ident,
                     generics: generics.as_ref().map(|option| {
                         option.iter().map(|generic| generic.to_display_ast()).collect()
                     }),
+                    span,
                 };
 
                 let path =

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

@@ -152,6 +152,8 @@ pub enum TypeCheckError {
     StringIndexAssign { span: Span },
     #[error("Macro calls may only return `Quoted` values")]
     MacroReturningNonExpr { typ: Type, span: Span },
+    #[error("turbofish (`::<_>`) usage at this position isn't supported yet")]
+    UnsupportedTurbofishUsage { span: Span },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -350,6 +352,10 @@ impl<'a> From<&'a TypeCheckError> for Diagnostic {
                 "Macro calls must return quoted values, otherwise there is no code to insert".into(),
                 *span,
             ),
+            TypeCheckError::UnsupportedTurbofishUsage { span } => {
+                let msg = "turbofish (`::<_>`)  usage at this position isn't supported yet";
+                Diagnostic::simple_error(msg.to_string(), "".to_string(), *span)
+            },
         }
     }
 }

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

@@ -36,7 +36,7 @@ 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(|(ident, generics)| PathSegment { ident, generics })
+        .map_with_span(|(ident, generics), span| PathSegment { ident, generics, span })
 }
 
 pub(super) fn path_segment_no_turbofish() -> impl NoirParser<PathSegment> {

compiler/noirc_frontend/src/tests.rs

@@ -2537,3 +2537,49 @@ fn trait_constraint_on_tuple_type() {
         fn main() {}"#;
     assert_no_errors(src);
 }
+
+#[test]
+fn turbofish_in_constructor_unsupported_yet() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    fn main() {
+        let _ = Foo::<i32> { x: 1 };
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::UnsupportedTurbofishUsage { .. }),
+    ));
+}
+
+#[test]
+fn turbofish_in_middle_of_variable_unsupported_yet() {
+    let src = r#"
+    struct Foo<T> {
+        x: T
+    }
+
+    impl <T> Foo<T> {
+        fn new(x: T) -> Self {
+            Foo { x }
+        }
+    }
+
+    fn main() {
+        let _ = Foo::<i32>::new(1);
+    }
+    "#;
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    assert!(matches!(
+        errors[0].0,
+        CompilationError::TypeError(TypeCheckError::UnsupportedTurbofishUsage { .. }),
+    ));
+}