Make closures and anon consts report that their parent item is the one that is supposed to be restricted

Author: oli-obk

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -640,7 +640,9 @@ fn find_opaque_ty_constraints_for_tait(tcx: TyCtxt<'_>, def_id: LocalDefId) -> T
             let concrete_opaque_types = &self.tcx.mir_borrowck(item_def_id).concrete_opaque_types;
             debug!(?concrete_opaque_types);
             if let Some(&concrete_type) = concrete_opaque_types.get(&self.def_id) {
-                if !may_define_opaque_type(self.tcx, item_def_id, self.def_id, concrete_type.span) {
+                if let Err(item_def_id) =
+                    may_define_opaque_type(self.tcx, item_def_id, self.def_id, concrete_type.span)
+                {
                     self.tcx.sess.emit_err(OpaqueTypeConstrainedButNotInSig {
                         span: concrete_type.span,
                         item_span: self.tcx.def_span(item_def_id),
@@ -666,8 +668,12 @@ fn find_opaque_ty_constraints_for_tait(tcx: TyCtxt<'_>, def_id: LocalDefId) -> T
             self.tcx.hir()
         }
         fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
-            if let hir::ExprKind::Closure(closure) = ex.kind {
-                self.check(closure.def_id);
+            match ex.kind {
+                hir::ExprKind::Closure(closure) => {
+                    self.check(closure.def_id);
+                }
+                hir::ExprKind::ConstBlock(anon) => self.check(anon.def_id),
+                _ => (),
             }
             intravisit::walk_expr(self, ex);
         }
@@ -760,14 +766,14 @@ fn may_define_opaque_type<'tcx>(
     def_id: LocalDefId,
     opaque_def_id: LocalDefId,
     span: Span,
-) -> bool {
+) -> Result<(), LocalDefId> {
     if tcx.is_descendant_of(opaque_def_id.to_def_id(), def_id.to_def_id()) {
         // If the opaque type is defined in the body of a function, that function
         // may constrain the opaque type since it can't mention it in bounds.
-        return true;
+        return Ok(());
     }
 
-    if tcx.is_closure(def_id.to_def_id()) {
+    if tcx.is_typeck_child(def_id.to_def_id()) {
         return may_define_opaque_type(tcx, tcx.local_parent(def_id), opaque_def_id, span);
     }
 
@@ -863,12 +869,12 @@ fn may_define_opaque_type<'tcx>(
     };
     trace!(?tait_in_fn_sig);
     if tait_in_fn_sig {
-        return true;
+        return Ok(());
     }
     let tait_in_where_bounds =
         has_tait(tcx.predicates_of(def_id.to_def_id()).predicates, opaque_def_id, tcx, param_env);
     if tcx.features().type_alias_impl_trait_in_where_bounds {
-        tait_in_where_bounds
+        if tait_in_where_bounds { Ok(()) } else { Err(def_id) }
     } else {
         if tait_in_where_bounds {
             feature_err(
@@ -879,7 +885,7 @@ fn may_define_opaque_type<'tcx>(
             )
             .emit();
         }
-        false
+        Err(def_id)
     }
 }
 

tests/ui/type-alias-impl-trait/issue-63263-anon-const-fail.rs

@@ -0,0 +1,14 @@
+// Regression test for issue #63263.
+// Tests that we properly handle closures with an explicit return type
+// that return an opaque type.
+
+#![feature(type_alias_impl_trait, inline_const)]
+
+pub type Closure = impl FnOnce();
+
+fn main() {
+    const {
+        let x: Closure = || {};
+        //~^ ERROR: opaque type constrained without being represented in the signature
+    }
+}

tests/ui/type-alias-impl-trait/issue-63263-anon-const-fail.stderr

@@ -0,0 +1,11 @@
+error: opaque type constrained without being represented in the signature
+  --> $DIR/issue-63263-anon-const-fail.rs:11:26
+   |
+LL | fn main() {
+   | --------- this item must mention the opaque type in its signature or where bounds
+LL |     const {
+LL |         let x: Closure = || {};
+   |                          ^^^^^
+
+error: aborting due to previous error
+

tests/ui/type-alias-impl-trait/issue-63263-anon-const.rs

@@ -0,0 +1,14 @@
+// Regression test for issue #63263.
+// Tests that we properly handle closures with an explicit return type
+// that return an opaque type.
+
+// check-pass
+
+#![feature(type_alias_impl_trait, inline_const)]
+
+fn main() {
+    pub type Closure = impl FnOnce();
+    const {
+        let x: Closure = || {};
+    }
+}

tests/ui/type-alias-impl-trait/issue-63263-closure-return-fail.rs

@@ -0,0 +1,11 @@
+// Tests that we don't allow closures to constrain opaque types
+// unless their surrounding item has the opaque type in its signature.
+
+#![feature(type_alias_impl_trait)]
+
+pub type Closure = impl FnOnce();
+
+fn main() {
+    || -> Closure { || () };
+    //~^ ERROR: opaque type constrained without being represented in the signature
+}

tests/ui/type-alias-impl-trait/issue-63263-closure-return-fail.stderr

@@ -0,0 +1,10 @@
+error: opaque type constrained without being represented in the signature
+  --> $DIR/issue-63263-closure-return-fail.rs:9:21
+   |
+LL | fn main() {
+   | --------- this item must mention the opaque type in its signature or where bounds
+LL |     || -> Closure { || () };
+   |                     ^^^^^
+
+error: aborting due to previous error
+