Add constness qualifier to function signature

Author: filtsin

compiler/rustc_ast_lowering/src/item.rs

@@ -1296,7 +1296,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_constness(&mut self, c: Const) -> hir::Constness {
+    pub(super) fn lower_constness(&mut self, c: Const) -> hir::Constness {
         match c {
             Const::Yes(_) => hir::Constness::Const,
             Const::No => hir::Constness::NotConst,

compiler/rustc_ast_lowering/src/lib.rs

@@ -1247,6 +1247,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         abi: this.lower_extern(f.ext),
                         decl: this.lower_fn_decl(&f.decl, None, false, None),
                         param_names: this.lower_fn_params_to_names(&f.decl),
+                        constness: this.lower_constness(f.constness),
                     }))
                 })
             }),

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -683,6 +683,7 @@ fn gen_fn<'ll, 'tcx>(
         false,
         hir::Unsafety::Unsafe,
         Abi::Rust,
+        hir::Constness::NotConst,
     ));
     let fn_abi = FnAbi::of_fn_ptr(cx, rust_fn_sig, &[]);
     let llfn = cx.declare_fn(name, &fn_abi);
@@ -716,13 +717,15 @@ fn get_rust_try_fn<'ll, 'tcx>(
         false,
         hir::Unsafety::Unsafe,
         Abi::Rust,
+        hir::Constness::NotConst,
     )));
     let catch_fn_ty = tcx.mk_fn_ptr(ty::Binder::bind(tcx.mk_fn_sig(
         [i8p, i8p].iter().cloned(),
         tcx.mk_unit(),
         false,
         hir::Unsafety::Unsafe,
         Abi::Rust,
+        hir::Constness::NotConst,
     )));
     let output = tcx.types.i32;
     let rust_try = gen_fn(cx, "__rust_try", vec![try_fn_ty, i8p, catch_fn_ty], output, codegen);

compiler/rustc_hir/src/hir.rs

@@ -2035,6 +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
 }
 
 #[derive(Debug, HashStable_Generic)]
@@ -2517,6 +2518,15 @@ pub enum Constness {
     NotConst,
 }
 
+impl fmt::Display for Constness {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match *self {
+            Self::Const => "const",
+            Self::NotConst => ""
+        })
+    }
+}
+
 #[derive(Copy, Clone, Encodable, Debug, HashStable_Generic)]
 pub struct FnHeader {
     pub unsafety: Unsafety,

compiler/rustc_hir_pretty/src/lib.rs

@@ -404,6 +404,7 @@ impl<'a> State<'a> {
                 self.print_ty_fn(
                     f.abi,
                     f.unsafety,
+                    f.constness,
                     &f.decl,
                     None,
                     &f.generic_params,
@@ -2310,6 +2311,7 @@ impl<'a> State<'a> {
         &mut self,
         abi: Abi,
         unsafety: hir::Unsafety,
+        constness: hir::Constness,
         decl: &hir::FnDecl<'_>,
         name: Option<Symbol>,
         generic_params: &[hir::GenericParam<'_>],
@@ -2330,7 +2332,7 @@ impl<'a> State<'a> {
             hir::FnHeader {
                 unsafety,
                 abi,
-                constness: hir::Constness::NotConst,
+                constness,
                 asyncness: hir::IsAsync::NotAsync,
             },
             name,

compiler/rustc_middle/src/ty/context.rs

@@ -2082,7 +2082,7 @@ 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)
+            self.mk_fn_sig(params_iter, s.output(), s.c_variadic, unsafety, abi::Abi::Rust, hir::Constness::NotConst,)
         })
     }
 
@@ -2459,6 +2459,7 @@ impl<'tcx> TyCtxt<'tcx> {
         c_variadic: bool,
         unsafety: hir::Unsafety,
         abi: abi::Abi,
+        constness: hir::Constness,
     ) -> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
     where
         I: Iterator<Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>,
@@ -2468,6 +2469,7 @@ impl<'tcx> TyCtxt<'tcx> {
             c_variadic,
             unsafety,
             abi,
+            constness
         })
     }
 

compiler/rustc_middle/src/ty/error.rs

@@ -36,6 +36,7 @@ pub enum TypeError<'tcx> {
     Mismatch,
     UnsafetyMismatch(ExpectedFound<hir::Unsafety>),
     AbiMismatch(ExpectedFound<abi::Abi>),
+    ConstnessMismatch(ExpectedFound<hir::Constness>),
     Mutability,
     TupleSize(ExpectedFound<usize>),
     FixedArraySize(ExpectedFound<u64>),
@@ -109,6 +110,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
             AbiMismatch(values) => {
                 write!(f, "expected {} fn, found {} fn", values.expected, values.found)
             }
+            ConstnessMismatch(values) => {
+                write!(f, "expected {} fn, found {} fn", values.expected, values.found)
+            }
             Mutability => write!(f, "types differ in mutability"),
             TupleSize(values) => write!(
                 f,
@@ -197,9 +201,9 @@ impl<'tcx> TypeError<'tcx> {
     pub fn must_include_note(&self) -> bool {
         use self::TypeError::*;
         match self {
-            CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | Mismatch | AbiMismatch(_)
-            | FixedArraySize(_) | Sorts(_) | IntMismatch(_) | FloatMismatch(_)
-            | VariadicMismatch(_) | TargetFeatureCast(_) => false,
+            CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | Mismatch | AbiMismatch(_) | ConstnessMismatch(_) | FixedArraySize(_)
+            | Sorts(_) | IntMismatch(_) | FloatMismatch(_) | VariadicMismatch(_)
+            | TargetFeatureCast(_) => false,
 
             Mutability
             | TupleSize(_)

compiler/rustc_middle/src/ty/layout.rs

@@ -2339,15 +2339,16 @@ impl<'tcx> ty::Instance<'tcx> {
                 let sig = substs.as_closure().sig();
 
                 let env_ty = tcx.closure_env_ty(def_id, substs).unwrap();
-                sig.map_bound(|sig| {
-                    tcx.mk_fn_sig(
-                        iter::once(env_ty.skip_binder()).chain(sig.inputs().iter().cloned()),
-                        sig.output(),
-                        sig.c_variadic,
-                        sig.unsafety,
-                        sig.abi,
-                    )
-                })
+
+                sig.map_bound(|sig|
+                  tcx.mk_fn_sig(
+                    iter::once(env_ty.skip_binder()).chain(sig.inputs().iter().cloned()),
+                    sig.output(),
+                    sig.c_variadic,
+                    sig.unsafety,
+                    sig.abi,
+                    hir::Constness::NotConst,
+                ))
             }
             ty::Generator(_, substs, _) => {
                 let sig = substs.as_generator().poly_sig();
@@ -2373,6 +2374,7 @@ impl<'tcx> ty::Instance<'tcx> {
                         false,
                         hir::Unsafety::Normal,
                         rustc_target::spec::abi::Abi::Rust,
+                        hir::Constness::NotConst,
                     )
                 })
             }

compiler/rustc_middle/src/ty/relate.rs

@@ -165,6 +165,7 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> {
         }
         let unsafety = relation.relate(a.unsafety, b.unsafety)?;
         let abi = relation.relate(a.abi, b.abi)?;
+        let constness = relation.relate(a.constness, b.constness)?;
 
         if a.inputs().len() != b.inputs().len() {
             return Err(TypeError::ArgCount);
@@ -189,6 +190,7 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> {
             c_variadic: a.c_variadic,
             unsafety,
             abi,
+            constness
         })
     }
 }
@@ -217,6 +219,17 @@ impl<'tcx> Relate<'tcx> for abi::Abi {
     }
 }
 
+impl<'tcx> Relate<'tcx> for ast::Constness {
+    fn relate<R: TypeRelation<'tcx>>(
+        relation: &mut R,
+        a: ast::Constness,
+        b: ast::Constness
+    ) -> RelateResult<'tcx, ast::Constness> {
+        if a == b || (a == ast::Constness::Const && b == ast::Constness::NotConst) { Ok(a) }
+        else { Err(TypeError::ConstnessMismatch(expected_found(relation, a, b))) }
+    }
+}
+
 impl<'tcx> Relate<'tcx> for ty::ProjectionTy<'tcx> {
     fn relate<R: TypeRelation<'tcx>>(
         relation: &mut R,

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -648,6 +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
         })
     }
 }
@@ -670,6 +671,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::TypeError<'a> {
             Mismatch => Mismatch,
             UnsafetyMismatch(x) => UnsafetyMismatch(x),
             AbiMismatch(x) => AbiMismatch(x),
+            ConstnessMismatch(x) => ConstnessMismatch(x),
             Mutability => Mutability,
             TupleSize(x) => TupleSize(x),
             FixedArraySize(x) => FixedArraySize(x),