x.py fmt

filtsin · filtsin · commit 7374ae7a87b9 · 2020-10-14T18:09:27.000+03:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -1900,7 +1900,7 @@ pub struct BareFnTy {
     pub ext: Extern,
     pub generic_params: Vec<GenericParam>,
     pub decl: P<FnDecl>,
-    pub constness: Const
+    pub constness: Const,
 }
 
 /// The various kinds of type recognized by the compiler.
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -462,7 +462,8 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
             vis.visit_mt(mt);
         }
         TyKind::BareFn(bft) => {
-            let BareFnTy { unsafety: _, ext: _, constness: _, generic_params, decl } = bft.deref_mut();
+            let BareFnTy { unsafety: _, ext: _, constness: _, generic_params, decl } =
+                bft.deref_mut();
             generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
             vis.visit_fn_decl(decl);
         }
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -17,12 +17,12 @@ use rustc_errors::{error_code, pluralize, struct_span_err, Applicability};
 use rustc_parse::validate_attr;
 use rustc_session::lint::builtin::PATTERNS_IN_FNS_WITHOUT_BODY;
 use rustc_session::lint::LintBuffer;
+use rustc_session::parse::feature_err;
 use rustc_session::Session;
 use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::Span;
 use std::mem;
 use std::ops::DerefMut;
-use rustc_session::parse::feature_err;
 
 const MORE_EXTERN: &str =
     "for more information, visit https://doc.rust-lang.org/std/keyword.extern.html";
@@ -831,8 +831,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                             &self.session.parse_sess,
                             sym::const_fn_pointer,
                             span,
-                            "`const fn` pointer type is unstable"
-                        ).emit()
+                            "`const fn` pointer type is unstable",
+                        )
+                        .emit()
                     }
                 }
                 self.check_late_bound_lifetime_defs(&bfty.generic_params);
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -2035,7 +2035,7 @@ pub struct BareFnTy<'hir> {
     pub generic_params: &'hir [GenericParam<'hir>],
     pub decl: &'hir FnDecl<'hir>,
     pub param_names: &'hir [Ident],
-    pub constness: Constness
+    pub constness: Constness,
 }
 
 #[derive(Debug, HashStable_Generic)]
@@ -2522,7 +2522,7 @@ impl fmt::Display for Constness {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match *self {
             Self::Const => "const",
-            Self::NotConst => ""
+            Self::NotConst => "",
         })
     }
 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -2329,12 +2329,7 @@ impl<'a> State<'a> {
         };
         self.print_fn(
             decl,
-            hir::FnHeader {
-                unsafety,
-                abi,
-                constness,
-                asyncness: hir::IsAsync::NotAsync,
-            },
+            hir::FnHeader { unsafety, abi, constness, asyncness: hir::IsAsync::NotAsync },
             name,
             &generics,
             &Spanned { span: rustc_span::DUMMY_SP, node: hir::VisibilityKind::Inherited },
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -2082,7 +2082,14 @@ impl<'tcx> TyCtxt<'tcx> {
                 ty::Tuple(params) => params.into_iter().map(|k| k.expect_ty()),
                 _ => bug!(),
             };
-            self.mk_fn_sig(params_iter, s.output(), s.c_variadic, unsafety, abi::Abi::Rust, hir::Constness::NotConst,)
+            self.mk_fn_sig(
+                params_iter,
+                s.output(),
+                s.c_variadic,
+                unsafety,
+                abi::Abi::Rust,
+                hir::Constness::NotConst,
+            )
         })
     }
 
@@ -2469,7 +2476,7 @@ impl<'tcx> TyCtxt<'tcx> {
             c_variadic,
             unsafety,
             abi,
-            constness
+            constness,
         })
     }
 
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
@@ -201,9 +201,9 @@ impl<'tcx> TypeError<'tcx> {
     pub fn must_include_note(&self) -> bool {
         use self::TypeError::*;
         match self {
-            CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | Mismatch | AbiMismatch(_) | ConstnessMismatch(_) | FixedArraySize(_)
-            | Sorts(_) | IntMismatch(_) | FloatMismatch(_) | VariadicMismatch(_)
-            | TargetFeatureCast(_) => false,
+            CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | Mismatch | AbiMismatch(_)
+            | ConstnessMismatch(_) | FixedArraySize(_) | Sorts(_) | IntMismatch(_)
+            | FloatMismatch(_) | VariadicMismatch(_) | TargetFeatureCast(_) => false,
 
             Mutability
             | TupleSize(_)
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
@@ -190,7 +190,7 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> {
             c_variadic: a.c_variadic,
             unsafety,
             abi,
-            constness
+            constness,
         })
     }
 }
@@ -223,10 +223,13 @@ impl<'tcx> Relate<'tcx> for ast::Constness {
     fn relate<R: TypeRelation<'tcx>>(
         relation: &mut R,
         a: ast::Constness,
-        b: ast::Constness
+        b: ast::Constness,
     ) -> RelateResult<'tcx, ast::Constness> {
-        if a == b || (a == ast::Constness::Const && b == ast::Constness::NotConst) { Ok(b) }
-        else { Err(TypeError::ConstnessMismatch(expected_found(relation, a, b))) }
+        if a == b || (a == ast::Constness::Const && b == ast::Constness::NotConst) {
+            Ok(b)
+        } else {
+            Err(TypeError::ConstnessMismatch(expected_found(relation, a, b)))
+        }
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -648,7 +648,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::FnSig<'a> {
             c_variadic: self.c_variadic,
             unsafety: self.unsafety,
             abi: self.abi,
-            constness: self.constness
+            constness: self.constness,
         })
     }
 }
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1127,7 +1127,7 @@ pub struct FnSig<'tcx> {
     pub c_variadic: bool,
     pub unsafety: hir::Unsafety,
     pub abi: abi::Abi,
-    pub constness: hir::Constness
+    pub constness: hir::Constness,
 }
 
 impl<'tcx> FnSig<'tcx> {
@@ -1179,7 +1179,9 @@ impl<'tcx> PolyFnSig<'tcx> {
     pub fn abi(&self) -> abi::Abi {
         self.skip_binder().abi
     }
-    pub fn constness(&self) -> hir::Constness { self.skip_binder().constness }
+    pub fn constness(&self) -> hir::Constness {
+        self.skip_binder().constness
+    }
 }
 
 pub type CanonicalPolyFnSig<'tcx> = Canonical<'tcx, Binder<FnSig<'tcx>>>;
diff --git a/compiler/rustc_mir/src/transform/check_consts/validation.rs b/compiler/rustc_mir/src/transform/check_consts/validation.rs
@@ -748,7 +748,9 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
                     ty::FnPtr(fn_sig) => {
                         // At this point, we are calling a function by raw pointer because
                         // we know that it is const
-                        if fn_sig.constness() == hir::Constness::Const { return; }
+                        if fn_sig.constness() == hir::Constness::Const {
+                            return;
+                        }
                         self.check_op(ops::FnCallIndirect);
                         return;
                     }
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -1159,7 +1159,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
                     false,
                     hir::Unsafety::Normal,
                     abi::Abi::Rust,
-                    hir::Constness::NotConst
+                    hir::Constness::NotConst,
                 )
             } else {
                 tcx.mk_fn_sig(
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -2185,8 +2185,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         debug!("ty_of_fn: output_ty={:?}", output_ty);
 
-        let bare_fn_ty =
-            ty::Binder::bind(tcx.mk_fn_sig(input_tys, output_ty, decl.c_variadic, unsafety, abi, constness,));
+        let bare_fn_ty = ty::Binder::bind(tcx.mk_fn_sig(
+            input_tys,
+            output_ty,
+            decl.c_variadic,
+            unsafety,
+            abi,
+            constness,
+        ));
 
         if !self.allow_ty_infer() {
             // We always collect the spans for placeholder types when evaluating `fn`s, but we
diff --git a/compiler/rustc_typeck/src/check/callee.rs b/compiler/rustc_typeck/src/check/callee.rs
@@ -397,7 +397,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         false,
                         hir::Unsafety::Normal,
                         abi::Abi::Rust,
-                        hir::Constness::NotConst
+                        hir::Constness::NotConst,
                     )),
                     None,
                 )
diff --git a/compiler/rustc_typeck/src/check/intrinsic.rs b/compiler/rustc_typeck/src/check/intrinsic.rs
@@ -380,7 +380,17 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
         };
         (n_tps, inputs, output, unsafety)
     };
-    equate_intrinsic_type(tcx, it, def_id, n_tps, Abi::RustIntrinsic, unsafety, hir::Constness::NotConst, inputs, output)
+    equate_intrinsic_type(
+        tcx,
+        it,
+        def_id,
+        n_tps,
+        Abi::RustIntrinsic,
+        unsafety,
+        hir::Constness::NotConst,
+        inputs,
+        output,
+    )
 }
 
 /// Type-check `extern "platform-intrinsic" { ... }` functions.
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
@@ -1569,9 +1569,15 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: DefId) -> ty::PolyFnSig<'_> {
             ident,
             generics,
             ..
-        }) => {
-            AstConv::ty_of_fn(&icx, header.unsafety, header.abi, header.constness, decl, &generics, Some(ident.span))
-        }
+        }) => AstConv::ty_of_fn(
+            &icx,
+            header.unsafety,
+            header.abi,
+            header.constness,
+            decl,
+            &generics,
+            Some(ident.span),
+        ),
 
         ForeignItem(&hir::ForeignItem {
             kind: ForeignItemKind::Fn(ref fn_decl, _, _),
diff --git a/src/test/ui/feature-gates/feature-gate-const_fn_pointer.rs b/src/test/ui/feature-gates/feature-gate-const_fn_pointer.rs
@@ -0,0 +1,19 @@
+const fn foo() { }
+const x: const fn() = foo;
+//~^ ERROR `const fn` pointer type is unstable
+
+static y: const fn() = foo;
+//~^ ERROR `const fn` pointer type is unstable
+
+const fn bar(f: const fn()) { f() }
+//~^ ERROR `const fn` pointer type is unstable
+
+struct Foo { field: const fn() }
+//~^ ERROR `const fn` pointer type is unstable
+
+fn main() {
+  let local: fn() = foo;
+  let local2: const fn() = foo;
+  //~^ ERROR `const fn` pointer type is unstable
+  let local3 = foo;
+}
diff --git a/src/test/ui/feature-gates/feature-gate-const_fn_pointer.stderr b/src/test/ui/feature-gates/feature-gate-const_fn_pointer.stderr
@@ -0,0 +1,48 @@
+error[E0658]: `const fn` pointer type is unstable
+  --> $DIR/feature-gate-const_fn_pointer.rs:2:10
+   |
+LL | const x: const fn() = foo;
+   |          ^^^^^
+   |
+   = note: see issue #63997 <https://github.com/rust-lang/rust/issues/63997> for more information
+   = help: add `#![feature(const_fn_pointer)]` to the crate attributes to enable
+
+error[E0658]: `const fn` pointer type is unstable
+  --> $DIR/feature-gate-const_fn_pointer.rs:5:11
+   |
+LL | static y: const fn() = foo;
+   |           ^^^^^
+   |
+   = note: see issue #63997 <https://github.com/rust-lang/rust/issues/63997> for more information
+   = help: add `#![feature(const_fn_pointer)]` to the crate attributes to enable
+
+error[E0658]: `const fn` pointer type is unstable
+  --> $DIR/feature-gate-const_fn_pointer.rs:8:17
+   |
+LL | const fn bar(f: const fn()) { f() }
+   |                 ^^^^^
+   |
+   = note: see issue #63997 <https://github.com/rust-lang/rust/issues/63997> for more information
+   = help: add `#![feature(const_fn_pointer)]` to the crate attributes to enable
+
+error[E0658]: `const fn` pointer type is unstable
+  --> $DIR/feature-gate-const_fn_pointer.rs:11:21
+   |
+LL | struct Foo { field: const fn() }
+   |                     ^^^^^
+   |
+   = note: see issue #63997 <https://github.com/rust-lang/rust/issues/63997> for more information
+   = help: add `#![feature(const_fn_pointer)]` to the crate attributes to enable
+
+error[E0658]: `const fn` pointer type is unstable
+  --> $DIR/feature-gate-const_fn_pointer.rs:16:15
+   |
+LL |   let local2: const fn() = foo;
+   |               ^^^^^
+   |
+   = note: see issue #63997 <https://github.com/rust-lang/rust/issues/63997> for more information
+   = help: add `#![feature(const_fn_pointer)]` to the crate attributes to enable
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0658`.

Original file line number	Diff line number	Diff line change
`@@ -1900,7 +1900,7 @@ pub struct BareFnTy {`
`1900`	`1900`	`pub ext: Extern,`
`1901`	`1901`	`pub generic_params: Vec<GenericParam>,`
`1902`	`1902`	`pub decl: P<FnDecl>,`
`1903`		`- pub constness: Const`
	`1903`	`+ pub constness: Const,`
`1904`	`1904`	`}`
`1905`	`1905`
`1906`	`1906`	`/// The various kinds of type recognized by the compiler.`
Original file line number	Diff line number	Diff line change
`@@ -462,7 +462,8 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {`
`462`	`462`	`vis.visit_mt(mt);`
`463`	`463`	`}`
`464`	`464`	`TyKind::BareFn(bft) => {`
`465`		`- let BareFnTy { unsafety: _, ext: _, constness: _, generic_params, decl } = bft.deref_mut();`
	`465`	`+ let BareFnTy { unsafety: _, ext: _, constness: _, generic_params, decl } =`
	`466`	`+ bft.deref_mut();`
`466`	`467`	`generic_params.flat_map_in_place(\|param\| vis.flat_map_generic_param(param));`
`467`	`468`	`vis.visit_fn_decl(decl);`
`468`	`469`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2035,7 +2035,7 @@ pub struct BareFnTy<'hir> {`
`2035`	`2035`	`pub generic_params: &'hir [GenericParam<'hir>],`
`2036`	`2036`	`pub decl: &'hir FnDecl<'hir>,`
`2037`	`2037`	`pub param_names: &'hir [Ident],`
`2038`		`- pub constness: Constness`
	`2038`	`+ pub constness: Constness,`
`2039`	`2039`	`}`
`2040`	`2040`
`2041`	`2041`	`#[derive(Debug, HashStable_Generic)]`
`@@ -2522,7 +2522,7 @@ impl fmt::Display for Constness {`
`2522`	`2522`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`2523`	`2523`	`f.write_str(match *self {`
`2524`	`2524`	`Self::Const => "const",`
`2525`		`- Self::NotConst => ""`
	`2525`	`+ Self::NotConst => "",`
`2526`	`2526`	`})`
`2527`	`2527`	`}`
`2528`	`2528`	`}`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> {`
`190`	`190`	`c_variadic: a.c_variadic,`
`191`	`191`	`unsafety,`
`192`	`192`	`abi,`
`193`		`- constness`
	`193`	`+ constness,`
`194`	`194`	`})`
`195`	`195`	`}`
`196`	`196`	`}`
`@@ -223,10 +223,13 @@ impl<'tcx> Relate<'tcx> for ast::Constness {`
`223`	`223`	`fn relate<R: TypeRelation<'tcx>>(`
`224`	`224`	`relation: &mut R,`
`225`	`225`	`a: ast::Constness,`
`226`		`- b: ast::Constness`
	`226`	`+ b: ast::Constness,`
`227`	`227`	`) -> RelateResult<'tcx, ast::Constness> {`
`228`		`- if a == b \|\| (a == ast::Constness::Const && b == ast::Constness::NotConst) { Ok(b) }`
`229`		`- else { Err(TypeError::ConstnessMismatch(expected_found(relation, a, b))) }`
	`228`	`+ if a == b \|\| (a == ast::Constness::Const && b == ast::Constness::NotConst) {`
	`229`	`+ Ok(b)`
	`230`	`+ } else {`
	`231`	`+ Err(TypeError::ConstnessMismatch(expected_found(relation, a, b)))`
	`232`	`+ }`
`230`	`233`	`}`
`231`	`234`	`}`
`232`	`235`
Original file line number	Diff line number	Diff line change
`@@ -648,7 +648,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::FnSig<'a> {`
`648`	`648`	`c_variadic: self.c_variadic,`
`649`	`649`	`unsafety: self.unsafety,`
`650`	`650`	`abi: self.abi,`
`651`		`- constness: self.constness`
	`651`	`+ constness: self.constness,`
`652`	`652`	`})`
`653`	`653`	`}`
`654`	`654`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1127,7 +1127,7 @@ pub struct FnSig<'tcx> {`
`1127`	`1127`	`pub c_variadic: bool,`
`1128`	`1128`	`pub unsafety: hir::Unsafety,`
`1129`	`1129`	`pub abi: abi::Abi,`
`1130`		`- pub constness: hir::Constness`
	`1130`	`+ pub constness: hir::Constness,`
`1131`	`1131`	`}`
`1132`	`1132`
`1133`	`1133`	`impl<'tcx> FnSig<'tcx> {`
`@@ -1179,7 +1179,9 @@ impl<'tcx> PolyFnSig<'tcx> {`
`1179`	`1179`	`pub fn abi(&self) -> abi::Abi {`
`1180`	`1180`	`self.skip_binder().abi`
`1181`	`1181`	`}`
`1182`		`- pub fn constness(&self) -> hir::Constness { self.skip_binder().constness }`
	`1182`	`+ pub fn constness(&self) -> hir::Constness {`
	`1183`	`+ self.skip_binder().constness`
	`1184`	`+ }`
`1183`	`1185`	`}`
`1184`	`1186`
`1185`	`1187`	`pub type CanonicalPolyFnSig<'tcx> = Canonical<'tcx, Binder<FnSig<'tcx>>>;`