backport new syntax to rustfmt 1.x (#4105)
* feat: support raw reference operator * feat: support const opt-out syntax * feat: support half open range syntax
This commit is contained in:
parent
5ca3d023ff
commit
00e199c974
11 changed files with 165 additions and 26 deletions
10
src/expr.rs
10
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)
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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 })
|
||||
}
|
||||
|
|
|
@ -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 {}
|
||||
}
|
||||
|
|
|
@ -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 {}
|
||||
}
|
||||
|
|
|
@ -218,6 +218,10 @@ fn returns() {
|
|||
fn addrof() {
|
||||
& mut(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
|
||||
& (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
|
||||
|
||||
// raw reference operator
|
||||
& raw const a;
|
||||
& raw mut b;
|
||||
}
|
||||
|
||||
fn casts() {
|
||||
|
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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 {}
|
||||
}
|
||||
|
|
|
@ -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 {}
|
||||
}
|
||||
|
|
|
@ -253,6 +253,10 @@ fn addrof() {
|
|||
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
|
||||
&(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
||||
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
|
||||
|
||||
// raw reference operator
|
||||
&raw const a;
|
||||
&raw mut b;
|
||||
}
|
||||
|
||||
fn casts() {
|
||||
|
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue