Rollup merge of #68681 - bobrippling:fix-matched-angle-brackets, r=Centril

Suggest path separator for single-colon typos

This commit adds guidance for when a user means to type a path, but ends
up typing a single colon, such as `<<Impl as T>:Ty>`.

This change seemed pertinent as the current error message is
particularly misleading, emitting `error: unmatched angle bracket`,
despite the angle bracket being matched later on, leaving the user to
track down the typo'd colon.

Author: JohnTitor

src/librustc_parse/parser/path.rs

@@ -71,14 +71,49 @@ impl<'a> Parser<'a> {
             debug!("parse_qpath: (decrement) count={:?}", self.unmatched_angle_bracket_count);
         }
 
-        self.expect(&token::ModSep)?;
+        if !self.recover_colon_before_qpath_proj() {
+            self.expect(&token::ModSep)?;
+        }
 
         let qself = QSelf { ty, path_span, position: path.segments.len() };
         self.parse_path_segments(&mut path.segments, style)?;
 
         Ok((qself, Path { segments: path.segments, span: lo.to(self.prev_span) }))
     }
 
+    /// Recover from an invalid single colon, when the user likely meant a qualified path.
+    /// We avoid emitting this if not followed by an identifier, as our assumption that the user
+    /// intended this to be a qualified path may not be correct.
+    ///
+    /// ```ignore (diagnostics)
+    /// <Bar as Baz<T>>:Qux
+    ///                ^ help: use double colon
+    /// ```
+    fn recover_colon_before_qpath_proj(&mut self) -> bool {
+        if self.token.kind != token::Colon
+            || self.look_ahead(1, |t| !t.is_ident() || t.is_reserved_ident())
+        {
+            return false;
+        }
+
+        self.bump(); // colon
+
+        self.diagnostic()
+            .struct_span_err(
+                self.prev_span,
+                "found single colon before projection in qualified path",
+            )
+            .span_suggestion(
+                self.prev_span,
+                "use double colon",
+                "::".to_string(),
+                Applicability::MachineApplicable,
+            )
+            .emit();
+
+        true
+    }
+
     /// Parses simple paths.
     ///
     /// `path = [::] segment+`

src/test/ui/parser/qualified-path-in-turbofish.fixed

@@ -0,0 +1,19 @@
+// run-rustfix
+trait T {
+    type Ty;
+}
+
+struct Impl;
+
+impl T for Impl {
+    type Ty = u32;
+}
+
+fn template<T>() -> i64 {
+    3
+}
+
+fn main() {
+    template::<<Impl as T>::Ty>();
+    //~^ ERROR found single colon before projection in qualified path
+}

src/test/ui/parser/qualified-path-in-turbofish.rs

@@ -0,0 +1,19 @@
+// run-rustfix
+trait T {
+    type Ty;
+}
+
+struct Impl;
+
+impl T for Impl {
+    type Ty = u32;
+}
+
+fn template<T>() -> i64 {
+    3
+}
+
+fn main() {
+    template::<<Impl as T>:Ty>();
+    //~^ ERROR found single colon before projection in qualified path
+}

src/test/ui/parser/qualified-path-in-turbofish.stderr

@@ -0,0 +1,8 @@
+error: found single colon before projection in qualified path
+  --> $DIR/qualified-path-in-turbofish.rs:17:27
+   |
+LL |     template::<<Impl as T>:Ty>();
+   |                           ^ help: use double colon: `::`
+
+error: aborting due to previous error
+