deduplicate between validate_trait_object_ty and validate_impl_object_ty

Author: Shourya742

crates/syntax/src/validation.rs

@@ -3,14 +3,12 @@
 //! A failed validation emits a diagnostic.
 
 mod block;
-
-use rowan::Direction;
 use rustc_lexer::unescape::{self, Mode, unescape_mixed, unescape_unicode};
 
 use crate::{
-    AstNode, SyntaxError,
+    AstNode, Direction, SyntaxError,
     SyntaxKind::{CONST, FN, INT_NUMBER, TYPE_ALIAS},
-    SyntaxNode, SyntaxToken, T, TextSize, algo,
+    SyntaxNode, SyntaxToken, T, TextRange, TextSize, algo,
     ast::{self, HasAttrs, HasVisibility, IsString, RangeItem},
     match_ast,
 };
@@ -339,27 +337,49 @@ fn validate_trait_object_fn_ptr_ret_ty(ty: ast::FnPtrType, errors: &mut Vec<Synt
     }
 }
 
-fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
-    let tbl = ty.type_bound_list()?;
-    let bounds_count = tbl.bounds().count();
+fn validate_object_ty(
+    bounds: impl Iterator<Item = ast::TypeBound>,
+    preceding_token: Option<SyntaxToken>,
+    error_no_trait: &str,
+    ty_syntax_range: TextRange,
+    check_for_and_token: bool,
+) -> Option<SyntaxError> {
+    let bounds: Vec<_> = bounds.collect();
+    let bounds_count = bounds.len();
 
-    match bounds_count {
-        0 => Some(SyntaxError::new(
-            "At least one trait is required for an object type",
-            ty.syntax().text_range(),
-        )),
-        _ if bounds_count > 1 => {
-            let dyn_token = ty.dyn_token()?;
-            let preceding_token =
-                algo::skip_trivia_token(dyn_token.prev_token()?, Direction::Prev)?;
-
-            if !matches!(preceding_token.kind(), T!['('] | T![<] | T![=]) {
-                return Some(SyntaxError::new("ambiguous `+` in a type", ty.syntax().text_range()));
+    if bounds.is_empty()
+        || bounds.iter().all(|b| matches!(b.kind(), ast::TypeBoundKind::Lifetime(_)))
+    {
+        return Some(SyntaxError::new(error_no_trait, ty_syntax_range));
+    }
+
+    if bounds_count == 1 {
+        return None;
+    }
+
+    if let Some(preceding_token) = preceding_token {
+        if !matches!(preceding_token.kind(), T!['('] | T![<] | T![=]) {
+            if !check_for_and_token || matches!(preceding_token.kind(), T![&]) {
+                return Some(SyntaxError::new("ambiguous `+` in a type", ty_syntax_range));
             }
-            None
         }
-        _ => None,
     }
+
+    None
+}
+
+fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
+    let tbl = ty.type_bound_list()?;
+    let dyn_token = ty.dyn_token()?;
+    let preceding_token = algo::skip_trivia_token(dyn_token.prev_token()?, Direction::Prev);
+
+    validate_object_ty(
+        tbl.bounds(),
+        preceding_token,
+        "At least one trait is required for an object type",
+        ty.syntax().text_range(),
+        false,
+    )
 }
 
 fn validate_impl_object_ty(ty: ast::ImplTraitType, errors: &mut Vec<SyntaxError>) {
@@ -371,34 +391,19 @@ fn validate_impl_object_ty(ty: ast::ImplTraitType, errors: &mut Vec<SyntaxError>
         return;
     };
 
-    let bounds: Vec<_> = bound_list.bounds().collect();
-
-    if bounds.is_empty()
-        || bounds.iter().all(|b| matches!(b.kind(), ast::TypeBoundKind::Lifetime(_)))
-    {
-        errors.push(SyntaxError::new(
-            "At least one trait must be specified",
-            ty.syntax().text_range(),
-        ));
-        return;
-    }
-
-    if bounds.len() == 1 {
-        return;
-    }
-
-    let Some(preceding_token) = ty
-        .impl_token()
+    let impl_token = ty.impl_token();
+    let preceding_token = impl_token
         .and_then(|token| token.prev_token())
-        .and_then(|prev| algo::skip_trivia_token(prev, Direction::Prev))
-    else {
-        return;
-    };
-
-    if !matches!(preceding_token.kind(), T!['('] | T![<] | T![=])
-        && matches!(preceding_token.kind(), T![&])
-    {
-        errors.push(SyntaxError::new("ambiguous `+` in a type", ty.syntax().text_range()));
+        .and_then(|prev| algo::skip_trivia_token(prev, Direction::Prev));
+
+    if let Some(error) = validate_object_ty(
+        bound_list.bounds(),
+        preceding_token,
+        "At least one trait must be specified",
+        ty.syntax().text_range(),
+        true,
+    ) {
+        errors.push(error);
     }
 }