Merging upstream version 1.75.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 77 insertions, 21 deletions

diff --git a/vendor/syn/tests/test_precedence.rs b/vendor/syn/tests/test_precedence.rs
index b49577f0f..bf0510bb3 100644
--- a/vendor/syn/tests/test_precedence.rs
+++ b/vendor/syn/tests/test_precedence.rs
@@ -30,6 +30,7 @@ extern crate rustc_ast_pretty;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_span;
+extern crate smallvec;
 extern crate thin_vec;
 
 use crate::common::eq::SpanlessEq;
@@ -168,15 +169,17 @@ fn librustc_parse_and_rewrite(input: &str) -> Option<P<ast::Expr>> {
 /// This method operates on librustc objects.
 fn librustc_brackets(mut librustc_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
     use rustc_ast::ast::{
-        Attribute, BinOpKind, Block, BorrowKind, Expr, ExprField, ExprKind, GenericArg,
-        GenericBound, Local, LocalKind, Pat, Stmt, StmtKind, StructExpr, StructRest,
-        TraitBoundModifier, Ty,
+        AssocItem, AssocItemKind, Attribute, BinOpKind, Block, BorrowKind, Expr, ExprField,
+        ExprKind, GenericArg, GenericBound, ItemKind, Local, LocalKind, Pat, Stmt, StmtKind,
+        StructExpr, StructRest, TraitBoundModifier, Ty,
     };
     use rustc_ast::mut_visit::{
-        noop_visit_generic_arg, noop_visit_local, noop_visit_param_bound, MutVisitor,
+        noop_flat_map_assoc_item, noop_visit_generic_arg, noop_visit_item_kind, noop_visit_local,
+        noop_visit_param_bound, MutVisitor,
     };
     use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
     use rustc_span::DUMMY_SP;
+    use smallvec::SmallVec;
     use std::mem;
     use std::ops::DerefMut;
     use thin_vec::ThinVec;
@@ -185,6 +188,17 @@ fn librustc_brackets(mut librustc_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
         failed: bool,
     }
 
+    fn contains_let_chain(expr: &Expr) -> bool {
+        match &expr.kind {
+            ExprKind::Let(..) => true,
+            ExprKind::Binary(binop, left, right) => {
+                binop.node == BinOpKind::And
+                    && (contains_let_chain(left) || contains_let_chain(right))
+            }
+            _ => false,
+        }
+    }
+
     fn flat_map_field<T: MutVisitor>(mut f: ExprField, vis: &mut T) -> Vec<ExprField> {
         if f.is_shorthand {
             noop_visit_expr(&mut f.expr, vis);
@@ -241,12 +255,7 @@ fn librustc_brackets(mut librustc_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
             noop_visit_expr(e, self);
             match e.kind {
                 ExprKind::Block(..) | ExprKind::If(..) | ExprKind::Let(..) => {}
-                ExprKind::Binary(binop, ref left, ref right)
-                    if match (&left.kind, binop.node, &right.kind) {
-                        (ExprKind::Let(..), BinOpKind::And, _)
-                        | (_, BinOpKind::And, ExprKind::Let(..)) => true,
-                        _ => false,
-                    } => {}
+                ExprKind::Binary(..) if contains_let_chain(e) => {}
                 _ => {
                     let inner = mem::replace(
                         e,
@@ -300,6 +309,39 @@ fn librustc_brackets(mut librustc_expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
             }
         }
 
+        fn visit_item_kind(&mut self, item: &mut ItemKind) {
+            match item {
+                ItemKind::Const(const_item)
+                    if !const_item.generics.params.is_empty()
+                        || !const_item.generics.where_clause.predicates.is_empty() => {}
+                _ => noop_visit_item_kind(item, self),
+            }
+        }
+
+        fn flat_map_trait_item(&mut self, item: P<AssocItem>) -> SmallVec<[P<AssocItem>; 1]> {
+            match &item.kind {
+                AssocItemKind::Const(const_item)
+                    if !const_item.generics.params.is_empty()
+                        || !const_item.generics.where_clause.predicates.is_empty() =>
+                {
+                    SmallVec::from([item])
+                }
+                _ => noop_flat_map_assoc_item(item, self),
+            }
+        }
+
+        fn flat_map_impl_item(&mut self, item: P<AssocItem>) -> SmallVec<[P<AssocItem>; 1]> {
+            match &item.kind {
+                AssocItemKind::Const(const_item)
+                    if !const_item.generics.params.is_empty()
+                        || !const_item.generics.where_clause.predicates.is_empty() =>
+                {
+                    SmallVec::from([item])
+                }
+                _ => noop_flat_map_assoc_item(item, self),
+            }
+        }
+
         // We don't want to look at expressions that might appear in patterns or
         // types yet. We'll look into comparing those in the future. For now
         // focus on expressions appearing in other places.
@@ -334,28 +376,42 @@ fn syn_brackets(syn_expr: syn::Expr) -> syn::Expr {
 
     struct ParenthesizeEveryExpr;
 
+    fn parenthesize(expr: Expr) -> Expr {
+        Expr::Paren(ExprParen {
+            attrs: Vec::new(),
+            expr: Box::new(expr),
+            paren_token: token::Paren::default(),
+        })
+    }
+
     fn needs_paren(expr: &Expr) -> bool {
         match expr {
             Expr::Group(_) => unreachable!(),
             Expr::If(_) | Expr::Unsafe(_) | Expr::Block(_) | Expr::Let(_) => false,
-            Expr::Binary(bin) => match (&*bin.left, bin.op, &*bin.right) {
-                (Expr::Let(_), BinOp::And(_), _) | (_, BinOp::And(_), Expr::Let(_)) => false,
-                _ => true,
-            },
+            Expr::Binary(_) => !contains_let_chain(expr),
             _ => true,
         }
     }
 
+    fn contains_let_chain(expr: &Expr) -> bool {
+        match expr {
+            Expr::Let(_) => true,
+            Expr::Binary(expr) => {
+                matches!(expr.op, BinOp::And(_))
+                    && (contains_let_chain(&expr.left) || contains_let_chain(&expr.right))
+            }
+            _ => false,
+        }
+    }
+
     impl Fold for ParenthesizeEveryExpr {
         fn fold_expr(&mut self, expr: Expr) -> Expr {
-            if needs_paren(&expr) {
-                Expr::Paren(ExprParen {
-                    attrs: Vec::new(),
-                    expr: Box::new(fold_expr(self, expr)),
-                    paren_token: token::Paren::default(),
-                })
+            let needs_paren = needs_paren(&expr);
+            let folded = fold_expr(self, expr);
+            if needs_paren {
+                parenthesize(folded)
             } else {
-                fold_expr(self, expr)
+                folded
             }
         }