minor: Simplify impl-ty parse validation

Author: Veykril

Diff for: crates/syntax/src/validation.rs

@@ -37,7 +37,6 @@ pub(crate) fn validate(root: &SyntaxNode, errors: &mut Vec<SyntaxError>) {
                 ast::FnPtrType(it) => validate_trait_object_fn_ptr_ret_ty(it, errors),
                 ast::MacroRules(it) => validate_macro_rules(it, errors),
                 ast::LetExpr(it) => validate_let_expr(it, errors),
-                ast::ImplTraitType(it) => validate_impl_object_ty(it, errors),
                 _ => (),
             }
         }
@@ -316,26 +315,50 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
 }
 
 fn validate_trait_object_ref_ty(ty: ast::RefType, errors: &mut Vec<SyntaxError>) {
-    if let Some(ast::Type::DynTraitType(ty)) = ty.ty() {
-        if let Some(err) = validate_trait_object_ty(ty) {
-            errors.push(err);
+    match ty.ty() {
+        Some(ast::Type::DynTraitType(ty)) => {
+            if let Some(err) = validate_trait_object_ty(ty) {
+                errors.push(err);
+            }
+        }
+        Some(ast::Type::ImplTraitType(ty)) => {
+            if let Some(err) = validate_impl_object_ty(ty) {
+                errors.push(err);
+            }
         }
+        _ => (),
     }
 }
 
 fn validate_trait_object_ptr_ty(ty: ast::PtrType, errors: &mut Vec<SyntaxError>) {
-    if let Some(ast::Type::DynTraitType(ty)) = ty.ty() {
-        if let Some(err) = validate_trait_object_ty(ty) {
-            errors.push(err);
+    match ty.ty() {
+        Some(ast::Type::DynTraitType(ty)) => {
+            if let Some(err) = validate_trait_object_ty(ty) {
+                errors.push(err);
+            }
         }
+        Some(ast::Type::ImplTraitType(ty)) => {
+            if let Some(err) = validate_impl_object_ty(ty) {
+                errors.push(err);
+            }
+        }
+        _ => (),
     }
 }
 
 fn validate_trait_object_fn_ptr_ret_ty(ty: ast::FnPtrType, errors: &mut Vec<SyntaxError>) {
-    if let Some(ast::Type::DynTraitType(ty)) = ty.ret_type().and_then(|ty| ty.ty()) {
-        if let Some(err) = validate_trait_object_ty(ty) {
-            errors.push(err);
+    match ty.ret_type().and_then(|ty| ty.ty()) {
+        Some(ast::Type::DynTraitType(ty)) => {
+            if let Some(err) = validate_trait_object_ty(ty) {
+                errors.push(err);
+            }
+        }
+        Some(ast::Type::ImplTraitType(ty)) => {
+            if let Some(err) = validate_impl_object_ty(ty) {
+                errors.push(err);
+            }
         }
+        _ => (),
     }
 }
 
@@ -353,6 +376,7 @@ fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
             let preceding_token =
                 algo::skip_trivia_token(dyn_token.prev_token()?, Direction::Prev)?;
 
+            // FIXME: This is not a validation error, this is a context dependent parse error
             if !matches!(preceding_token.kind(), T!['('] | T![<] | T![=]) {
                 return Some(SyntaxError::new("ambiguous `+` in a type", ty.syntax().text_range()));
             }
@@ -362,41 +386,27 @@ fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
     }
 }
 
-fn validate_impl_object_ty(ty: ast::ImplTraitType, errors: &mut Vec<SyntaxError>) {
-    let Some(bound_list) = ty.type_bound_list() else {
-        errors.push(SyntaxError::new(
-            "At least one trait must be specified",
-            ty.syntax().text_range(),
-        ));
-        return;
-    };
-
-    let bounds: Vec<_> = bound_list.bounds().collect();
+fn validate_impl_object_ty(ty: ast::ImplTraitType) -> Option<SyntaxError> {
+    let tbl = ty.type_bound_list()?;
+    let bounds_count = tbl.bounds().count();
 
-    if !bounds.iter().any(|b| !matches!(b.kind(), ast::TypeBoundKind::Lifetime(_))) {
-        errors.push(SyntaxError::new(
-            "At least one trait must be specified",
+    match bounds_count {
+        0 => Some(SyntaxError::new(
+            "At least one trait is required for an object type",
             ty.syntax().text_range(),
-        ));
-        return;
-    }
-
-    if bounds.len() == 1 {
-        return;
-    }
-
-    let Some(preceding_token) = ty
-        .impl_token()
-        .and_then(|token| token.prev_token())
-        .and_then(|prev| algo::skip_trivia_token(prev, Direction::Prev))
-    else {
-        return;
-    };
+        )),
+        _ if bounds_count > 1 => {
+            let impl_token = ty.impl_token()?;
+            let preceding_token =
+                algo::skip_trivia_token(impl_token.prev_token()?, Direction::Prev)?;
 
-    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()));
+            // FIXME: This is not a validation error, this is a context dependent parse error
+            if !matches!(preceding_token.kind(), T!['('] | T![<] | T![=]) {
+                return Some(SyntaxError::new("ambiguous `+` in a type", ty.syntax().text_range()));
+            }
+            None
+        }
+        _ => None,
     }
 }