backport new syntax to rustfmt 1.x (rust-lang#4105)

* feat: support raw reference operator

* feat: support const opt-out syntax

* feat: support half open range syntax

Author: calebcartwright

src/expr.rs

@@ -1988,14 +1988,16 @@ pub(crate) fn prefer_next_line(
 
 fn rewrite_expr_addrof(
     context: &RewriteContext<'_>,
-    _borrow_kind: ast::BorrowKind,
+    borrow_kind: ast::BorrowKind,
     mutability: ast::Mutability,
     expr: &ast::Expr,
     shape: Shape,
 ) -> Option<String> {
-    let operator_str = match mutability {
-        ast::Mutability::Not => "&",
-        ast::Mutability::Mut => "&mut ",
+    let operator_str = match (mutability, borrow_kind) {
+        (ast::Mutability::Not, ast::BorrowKind::Ref) => "&",
+        (ast::Mutability::Not, ast::BorrowKind::Raw) => "&raw const ",
+        (ast::Mutability::Mut, ast::BorrowKind::Ref) => "&mut ",
+        (ast::Mutability::Mut, ast::BorrowKind::Raw) => "&raw mut ",
     };
     rewrite_unary_prefix(context, operator_str, expr, shape)
 }

src/patterns.rs

@@ -55,6 +55,17 @@ fn is_short_pattern_inner(pat: &ast::Pat) -> bool {
     }
 }
 
+struct RangeOperand<'a>(&'a Option<ptr::P<ast::Expr>>);
+
+impl<'a> Rewrite for RangeOperand<'a> {
+    fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+        match &self.0 {
+            None => Some("".to_owned()),
+            Some(ref exp) => exp.rewrite(context, shape),
+        }
+    }
+}
+
 impl Rewrite for Pat {
     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
         match self.kind {
@@ -179,29 +190,34 @@ impl Rewrite for Pat {
                     None
                 }
             }
-            PatKind::Range(ref lhs, ref rhs, ref end_kind) => match (lhs, rhs) {
-                (Some(lhs), Some(rhs)) => {
-                    let infix = match end_kind.node {
-                        RangeEnd::Included(RangeSyntax::DotDotDot) => "...",
-                        RangeEnd::Included(RangeSyntax::DotDotEq) => "..=",
-                        RangeEnd::Excluded => "..",
+            PatKind::Range(ref lhs, ref rhs, ref end_kind) => {
+                let infix = match end_kind.node {
+                    RangeEnd::Included(RangeSyntax::DotDotDot) => "...",
+                    RangeEnd::Included(RangeSyntax::DotDotEq) => "..=",
+                    RangeEnd::Excluded => "..",
+                };
+                let infix = if context.config.spaces_around_ranges() {
+                    let lhs_spacing = match lhs {
+                        None => "",
+                        Some(_) => " ",
                     };
-                    let infix = if context.config.spaces_around_ranges() {
-                        format!(" {} ", infix)
-                    } else {
-                        infix.to_owned()
+                    let rhs_spacing = match rhs {
+                        None => "",
+                        Some(_) => " ",
                     };
-                    rewrite_pair(
-                        &**lhs,
-                        &**rhs,
-                        PairParts::infix(&infix),
-                        context,
-                        shape,
-                        SeparatorPlace::Front,
-                    )
-                }
-                (_, _) => unimplemented!(),
-            },
+                    format!("{}{}{}", lhs_spacing, infix, rhs_spacing)
+                } else {
+                    infix.to_owned()
+                };
+                rewrite_pair(
+                    &RangeOperand(lhs),
+                    &RangeOperand(rhs),
+                    PairParts::infix(&infix),
+                    context,
+                    shape,
+                    SeparatorPlace::Front,
+                )
+            }
             PatKind::Ref(ref pat, mutability) => {
                 let prefix = format!("&{}", format_mutability(mutability));
                 rewrite_unary_prefix(context, &prefix, &**pat, shape)

src/types.rs

@@ -527,7 +527,12 @@ impl Rewrite for ast::GenericBound {
                     ast::TraitBoundModifier::Maybe => poly_trait_ref
                         .rewrite(context, shape.offset_left(1)?)
                         .map(|s| format!("?{}", s)),
-                    _ => unimplemented!(),
+                    ast::TraitBoundModifier::MaybeConst => poly_trait_ref
+                        .rewrite(context, shape.offset_left(7)?)
+                        .map(|s| format!("?const {}", s)),
+                    ast::TraitBoundModifier::MaybeConstMaybe => poly_trait_ref
+                        .rewrite(context, shape.offset_left(8)?)
+                        .map(|s| format!("?const ?{}", s)),
                 };
                 rewrite.map(|s| if has_paren { format!("({})", s) } else { s })
             }

tests/source/configs/spaces_around_ranges/false.rs

@@ -20,3 +20,15 @@ fn main() {
         _ => bar,
     }
 }
+
+fn half_open() {
+    match [5 .. 4, 99 .. 105, 43 .. 44] {
+        [_, 99 .., _] => {}
+        [_, .. 105, _] => {}
+        _ => {}
+    };
+
+    if let ..=   5 = 0 {}
+    if let .. 5 = 0 {}
+    if let 5 .. = 0 {}
+}

tests/source/configs/spaces_around_ranges/true.rs

@@ -20,3 +20,15 @@ fn main() {
         _ => bar,
     }
 }
+
+fn half_open() {
+    match [5..4, 99..105, 43..44] {
+        [_, 99.., _] => {}
+        [_, ..105, _] => {}
+        _ => {}
+    };
+
+    if let ..=5 = 0 {}
+    if let ..5 = 0 {}
+    if let 5.. = 0 {}
+}

tests/source/expr.rs

@@ -218,6 +218,10 @@ fn returns() {
 fn addrof() {
     &    mut(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
     &    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
+
+    // raw reference operator
+    & raw   const  a;
+    & raw   mut    b;
 }
 
 fn casts() {

tests/source/type.rs

@@ -139,3 +139,30 @@ fn foo(a: SomeLongComplexType, b: SomeOtherLongComplexType) -> Box<Future<Item =
 }
 
 type MyFn = fn(a: SomeLongComplexType, b: SomeOtherLongComplexType,) -> Box<Future<Item = AnotherLongType, Error = ALongErrorType>>;
+
+// Const opt-out
+
+trait T: ?   const  Super {}
+
+const fn maybe_const<S: ?   const    T>() -> i32 { <S as T>::CONST }
+
+struct S<T:?  const   ?  Sized>(std::marker::PhantomData<T>);
+
+impl ?    const T {}
+
+fn trait_object() -> &'static dyn ?  const T { &S }
+
+fn i(_: impl IntoIterator<Item = Box<dyn ?    const    T>>) {}
+
+fn apit(_: impl ?const T) {}
+
+fn rpit() -> impl ?  const T { S }
+
+pub struct Foo<T: Trait>(T);
+impl<T:   ?  const Trait> Foo<T> {
+    fn new(t: T) -> Self {
+        // not calling methods on `t`, so we opt out of requiring
+        // `<T as Trait>` to have const methods via `?const`
+        Self(t)
+    }
+}

tests/target/configs/spaces_around_ranges/false.rs

@@ -20,3 +20,15 @@ fn main() {
         _ => bar,
     }
 }
+
+fn half_open() {
+    match [5..4, 99..105, 43..44] {
+        [_, 99.., _] => {}
+        [_, ..105, _] => {}
+        _ => {}
+    };
+
+    if let ..=5 = 0 {}
+    if let ..5 = 0 {}
+    if let 5.. = 0 {}
+}

tests/target/configs/spaces_around_ranges/true.rs

@@ -20,3 +20,15 @@ fn main() {
         _ => bar,
     }
 }
+
+fn half_open() {
+    match [5 .. 4, 99 .. 105, 43 .. 44] {
+        [_, 99 .., _] => {}
+        [_, .. 105, _] => {}
+        _ => {}
+    };
+
+    if let ..= 5 = 0 {}
+    if let .. 5 = 0 {}
+    if let 5 .. = 0 {}
+}

tests/target/expr.rs

@@ -253,6 +253,10 @@ fn addrof() {
         + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
     &(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
         + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
+
+    // raw reference operator
+    &raw const a;
+    &raw mut b;
 }
 
 fn casts() {

tests/target/type.rs

@@ -144,3 +144,36 @@ type MyFn = fn(
     a: SomeLongComplexType,
     b: SomeOtherLongComplexType,
 ) -> Box<Future<Item = AnotherLongType, Error = ALongErrorType>>;
+
+// Const opt-out
+
+trait T: ?const Super {}
+
+const fn maybe_const<S: ?const T>() -> i32 {
+    <S as T>::CONST
+}
+
+struct S<T: ?const ?Sized>(std::marker::PhantomData<T>);
+
+impl ?const T {}
+
+fn trait_object() -> &'static dyn ?const T {
+    &S
+}
+
+fn i(_: impl IntoIterator<Item = Box<dyn ?const T>>) {}
+
+fn apit(_: impl ?const T) {}
+
+fn rpit() -> impl ?const T {
+    S
+}
+
+pub struct Foo<T: Trait>(T);
+impl<T: ?const Trait> Foo<T> {
+    fn new(t: T) -> Self {
+        // not calling methods on `t`, so we opt out of requiring
+        // `<T as Trait>` to have const methods via `?const`
+        Self(t)
+    }
+}