attempt to make a minimal example work

fee1-dead · fee1-dead · commit 6e63f7be54d0 · 2023-01-12T02:28:37.000Z
diff --git a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
@@ -41,6 +41,7 @@ fn constness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::Constness {
             };
             if is_const { hir::Constness::Const } else { hir::Constness::NotConst }
         }
+        hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,
         _ => {
             if let Some(fn_kind) = node.fn_kind() {
                 if fn_kind.constness() == hir::Constness::Const {
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
@@ -20,6 +20,7 @@ Rust MIR: a lowered representation of Rust.
 #![feature(trusted_step)]
 #![feature(try_blocks)]
 #![feature(yeet_expr)]
+#![feature(if_let_guard)]
 #![feature(is_some_and)]
 #![recursion_limit = "256"]
 
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -783,6 +783,20 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             );
                             return;
                         }
+                        Ok(Some(ImplSource::Closure(data))) => {
+                            if !tcx.is_const_fn_raw(data.closure_def_id) {
+                                self.check_op(ops::FnCallNonConst {
+                                    caller,
+                                    callee,
+                                    substs,
+                                    span: *fn_span,
+                                    from_hir_call: *from_hir_call,
+                                    feature: None,
+                                });
+
+                                return;
+                            }
+                        }
                         Ok(Some(ImplSource::UserDefined(data))) => {
                             let callee_name = tcx.item_name(callee);
                             if let Some(&did) = tcx
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1686,6 +1686,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             }
 
             ty::Closure(_, substs) => {
+                let constness = self.tcx.constness(def_id.to_def_id());
+                self.tables.constness.set(def_id.to_def_id().index, constness);
                 record!(self.tables.fn_sig[def_id.to_def_id()] <- substs.as_closure().sig());
             }
 
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -485,7 +485,7 @@ impl<'hir> Map<'hir> {
             BodyOwnerKind::Static(mt) => ConstContext::Static(mt),
 
             BodyOwnerKind::Fn if self.tcx.is_constructor(def_id.to_def_id()) => return None,
-            BodyOwnerKind::Fn if self.tcx.is_const_fn_raw(def_id.to_def_id()) => {
+            BodyOwnerKind::Fn | BodyOwnerKind::Closure if self.tcx.is_const_fn_raw(def_id.to_def_id()) => {
                 ConstContext::ConstFn
             }
             BodyOwnerKind::Fn if self.tcx.is_const_default_method(def_id.to_def_id()) => {
diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs
@@ -131,7 +131,9 @@ pub enum SelectionCandidate<'tcx> {
 
     /// Implementation of a `Fn`-family trait by one of the anonymous types
     /// generated for an `||` expression.
-    ClosureCandidate,
+    ClosureCandidate {
+        is_const: bool,
+    },
 
     /// Implementation of a `Generator` trait by one of the anonymous types
     /// generated for a generator.
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -2465,8 +2465,10 @@ impl<'tcx> TyCtxt<'tcx> {
 
     #[inline]
     pub fn is_const_fn_raw(self, def_id: DefId) -> bool {
-        matches!(self.def_kind(def_id), DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..))
-            && self.constness(def_id) == hir::Constness::Const
+        matches!(
+            self.def_kind(def_id),
+            DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) | DefKind::Closure
+        ) && self.constness(def_id) == hir::Constness::Const
     }
 
     #[inline]
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -254,18 +254,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // touch bound regions, they just capture the in-scope
         // type/region parameters
         match *obligation.self_ty().skip_binder().kind() {
-            ty::Closure(_, closure_substs) => {
+            ty::Closure(def_id, closure_substs) => {
+                let is_const = self.tcx().is_const_fn_raw(def_id);
                 debug!(?kind, ?obligation, "assemble_unboxed_candidates");
                 match self.infcx.closure_kind(closure_substs) {
                     Some(closure_kind) => {
                         debug!(?closure_kind, "assemble_unboxed_candidates");
                         if closure_kind.extends(kind) {
-                            candidates.vec.push(ClosureCandidate);
+                            candidates.vec.push(ClosureCandidate {
+                                is_const,
+                            });
                         }
                     }
                     None => {
                         debug!("assemble_unboxed_candidates: closure_kind not yet known");
-                        candidates.vec.push(ClosureCandidate);
+                        candidates.vec.push(ClosureCandidate {
+                            is_const,
+                        });
                     }
                 }
             }
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -84,7 +84,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ImplSource::Object(data)
             }
 
-            ClosureCandidate => {
+            ClosureCandidate { .. } => {
                 let vtable_closure = self.confirm_closure_candidate(obligation)?;
                 ImplSource::Closure(vtable_closure)
             }
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -1365,15 +1365,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     // const param
                     ParamCandidate(trait_pred) if trait_pred.is_const_if_const() => {}
                     // const projection
-                    ProjectionCandidate(_, ty::BoundConstness::ConstIfConst) => {}
+                    ProjectionCandidate(_, ty::BoundConstness::ConstIfConst)
                     // auto trait impl
-                    AutoImplCandidate => {}
+                    | AutoImplCandidate
                     // generator / future, this will raise error in other places
                     // or ignore error with const_async_blocks feature
-                    GeneratorCandidate => {}
-                    FutureCandidate => {}
+                    | GeneratorCandidate
+                    | FutureCandidate
                     // FnDef where the function is const
-                    FnPointerCandidate { is_const: true } => {}
+                    | FnPointerCandidate { is_const: true }
+                    | ConstDestructCandidate(_)
+                    | ClosureCandidate { is_const: true } => {}
+
                     FnPointerCandidate { is_const: false } => {
                         if let ty::FnDef(def_id, _) = obligation.self_ty().skip_binder().kind() && tcx.trait_of_item(*def_id).is_some() {
                             // Trait methods are not seen as const unless the trait is implemented as const.
@@ -1382,7 +1385,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                             continue
                         }
                     }
-                    ConstDestructCandidate(_) => {}
+
                     _ => {
                         // reject all other types of candidates
                         continue;
@@ -1844,7 +1847,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             (
                 ParamCandidate(ref cand),
                 ImplCandidate(..)
-                | ClosureCandidate
+                | ClosureCandidate { .. }
                 | GeneratorCandidate
                 | FutureCandidate
                 | FnPointerCandidate { .. }
@@ -1863,7 +1866,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
             (
                 ImplCandidate(_)
-                | ClosureCandidate
+                | ClosureCandidate { .. }
                 | GeneratorCandidate
                 | FutureCandidate
                 | FnPointerCandidate { .. }
@@ -1894,7 +1897,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             (
                 ObjectCandidate(_) | ProjectionCandidate(..),
                 ImplCandidate(..)
-                | ClosureCandidate
+                | ClosureCandidate { .. }
                 | GeneratorCandidate
                 | FutureCandidate
                 | FnPointerCandidate { .. }
@@ -1907,7 +1910,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
             (
                 ImplCandidate(..)
-                | ClosureCandidate
+                | ClosureCandidate { .. }
                 | GeneratorCandidate
                 | FutureCandidate
                 | FnPointerCandidate { .. }
@@ -1989,7 +1992,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // Everything else is ambiguous
             (
                 ImplCandidate(_)
-                | ClosureCandidate
+                | ClosureCandidate { .. }
                 | GeneratorCandidate
                 | FutureCandidate
                 | FnPointerCandidate { .. }
@@ -1999,7 +2002,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | BuiltinCandidate { has_nested: true }
                 | TraitAliasCandidate,
                 ImplCandidate(_)
-                | ClosureCandidate
+                | ClosureCandidate { .. }
                 | GeneratorCandidate
                 | FutureCandidate
                 | FnPointerCandidate { .. }
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const_closures/call.rs b/src/test/ui/rfc-2632-const-trait-impl/const_closures/call.rs
@@ -0,0 +1,10 @@
+// check-pass
+
+#![feature(const_closures, const_trait_impl)]
+#![allow(incomplete_features)]
+
+pub const _: () = {
+    assert!((const || true)());
+};
+
+fn main() {}
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const_closures/gate.rs b/src/test/ui/rfc-2632-const-trait-impl/const_closures/gate.rs
@@ -1,3 +1,4 @@
+// gate-test-const_closures
 fn main() {
     (const || {})();
     //~^ ERROR: const closures are experimental
diff --git a/src/test/ui/rfc-2632-const-trait-impl/const_closures/gate.stderr b/src/test/ui/rfc-2632-const-trait-impl/const_closures/gate.stderr
@@ -1,5 +1,5 @@
 error[E0658]: const closures are experimental
-  --> $DIR/gate.rs:2:6
+  --> $DIR/gate.rs:3:6
    |
 LL |     (const || {})();
    |      ^^^^^^^^^^^

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ fn constness(tcx: TyCtxt<'_>, def_id: DefId) -> hir::Constness {`
`41`	`41`	`};`
`42`	`42`	`if is_const { hir::Constness::Const } else { hir::Constness::NotConst }`
`43`	`43`	`}`
	`44`	`+ hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,`
`44`	`45`	`_ => {`
`45`	`46`	`if let Some(fn_kind) = node.fn_kind() {`
`46`	`47`	`if fn_kind.constness() == hir::Constness::Const {`
Original file line number	Diff line number	Diff line change
`@@ -1686,6 +1686,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {`
`1686`	`1686`	`}`
`1687`	`1687`
`1688`	`1688`	`ty::Closure(_, substs) => {`
	`1689`	`+ let constness = self.tcx.constness(def_id.to_def_id());`
	`1690`	`+ self.tables.constness.set(def_id.to_def_id().index, constness);`
`1689`	`1691`	`record!(self.tables.fn_sig[def_id.to_def_id()] <- substs.as_closure().sig());`
`1690`	`1692`	`}`
`1691`	`1693`
Original file line number	Diff line number	Diff line change
`@@ -485,7 +485,7 @@ impl<'hir> Map<'hir> {`
`485`	`485`	`BodyOwnerKind::Static(mt) => ConstContext::Static(mt),`
`486`	`486`
`487`	`487`	`BodyOwnerKind::Fn if self.tcx.is_constructor(def_id.to_def_id()) => return None,`
`488`		`- BodyOwnerKind::Fn if self.tcx.is_const_fn_raw(def_id.to_def_id()) => {`
	`488`	`+ BodyOwnerKind::Fn \| BodyOwnerKind::Closure if self.tcx.is_const_fn_raw(def_id.to_def_id()) => {`
`489`	`489`	`ConstContext::ConstFn`
`490`	`490`	`}`
`491`	`491`	`BodyOwnerKind::Fn if self.tcx.is_const_default_method(def_id.to_def_id()) => {`
Original file line number	Diff line number	Diff line change
`@@ -254,18 +254,23 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`254`	`254`	`// touch bound regions, they just capture the in-scope`
`255`	`255`	`// type/region parameters`
`256`	`256`	`match *obligation.self_ty().skip_binder().kind() {`
`257`		`- ty::Closure(_, closure_substs) => {`
	`257`	`+ ty::Closure(def_id, closure_substs) => {`
	`258`	`+ let is_const = self.tcx().is_const_fn_raw(def_id);`
`258`	`259`	`debug!(?kind, ?obligation, "assemble_unboxed_candidates");`
`259`	`260`	`match self.infcx.closure_kind(closure_substs) {`
`260`	`261`	`Some(closure_kind) => {`
`261`	`262`	`debug!(?closure_kind, "assemble_unboxed_candidates");`
`262`	`263`	`if closure_kind.extends(kind) {`
`263`		`- candidates.vec.push(ClosureCandidate);`
	`264`	`+ candidates.vec.push(ClosureCandidate {`
	`265`	`+ is_const,`
	`266`	`+ });`
`264`	`267`	`}`
`265`	`268`	`}`
`266`	`269`	`None => {`
`267`	`270`	`debug!("assemble_unboxed_candidates: closure_kind not yet known");`
`268`		`- candidates.vec.push(ClosureCandidate);`
	`271`	`+ candidates.vec.push(ClosureCandidate {`
	`272`	`+ is_const,`
	`273`	`+ });`
`269`	`274`	`}`
`270`	`275`	`}`
`271`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {`
`84`	`84`	`ImplSource::Object(data)`
`85`	`85`	`}`
`86`	`86`
`87`		`- ClosureCandidate => {`
	`87`	`+ ClosureCandidate { .. } => {`
`88`	`88`	`let vtable_closure = self.confirm_closure_candidate(obligation)?;`
`89`	`89`	`ImplSource::Closure(vtable_closure)`
`90`	`90`	`}`