Bubble opaque types into aggregates to produce more precise diagnostics on aggregate constructors

oli-obk · oli-obk · commit cd61e54f8204 · 2022-04-07T16:56:51.000Z
diff --git a/compiler/rustc_mir_build/src/build/expr/as_temp.rs b/compiler/rustc_mir_build/src/build/expr/as_temp.rs
@@ -6,6 +6,7 @@ use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
+use rustc_middle::ty::Ty;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Compile `expr` into a fresh temporary. This is used when building
@@ -21,7 +22,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         // this is the only place in mir building that we need to truly need to worry about
         // infinite recursion. Everything else does recurse, too, but it always gets broken up
         // at some point by inserting an intermediate temporary
-        ensure_sufficient_stack(|| self.as_temp_inner(block, temp_lifetime, expr, mutability))
+        ensure_sufficient_stack(|| {
+            self.as_temp_inner(block, temp_lifetime, expr, mutability, expr.ty)
+        })
     }
 
     fn as_temp_inner(
@@ -30,18 +33,18 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         temp_lifetime: Option<region::Scope>,
         expr: &Expr<'tcx>,
         mutability: Mutability,
+        expr_ty: Ty<'tcx>,
     ) -> BlockAnd<Local> {
         let this = self;
 
         let expr_span = expr.span;
         let source_info = this.source_info(expr_span);
         if let ExprKind::Scope { region_scope, lint_level, value } = expr.kind {
             return this.in_scope((region_scope, source_info), lint_level, |this| {
-                this.as_temp(block, temp_lifetime, &this.thir[value], mutability)
+                this.as_temp_inner(block, temp_lifetime, &this.thir[value], mutability, expr.ty)
             });
         }
 
-        let expr_ty = expr.ty;
         let temp = {
             let mut local_decl = LocalDecl::new(expr_ty, expr_span);
             if mutability == Mutability::Not {
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -1,3 +1,4 @@
+use crate::build::ExprCategory as Category;
 use crate::thir::cx::Cx;
 use crate::thir::util::UserAnnotatedTyHelpers;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -24,20 +25,26 @@ use rustc_target::abi::VariantIdx;
 impl<'tcx> Cx<'tcx> {
     crate fn mirror_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) -> ExprId {
         // `mirror_expr` is recursing very deep. Make sure the stack doesn't overflow.
-        ensure_sufficient_stack(|| self.mirror_expr_inner(expr))
+        ensure_sufficient_stack(|| self.mirror_expr_inner(expr, None))
     }
 
-    crate fn mirror_exprs(&mut self, exprs: &'tcx [hir::Expr<'tcx>]) -> Box<[ExprId]> {
-        exprs.iter().map(|expr| self.mirror_expr_inner(expr)).collect()
+    crate fn mirror_exprs(
+        &mut self,
+        exprs: impl Iterator<Item = (&'tcx hir::Expr<'tcx>, Option<Ty<'tcx>>)>,
+    ) -> Box<[ExprId]> {
+        exprs.map(|(expr, ty)| self.mirror_expr_inner(expr, ty)).collect()
     }
 
-    pub(super) fn mirror_expr_inner(&mut self, hir_expr: &'tcx hir::Expr<'tcx>) -> ExprId {
+    #[instrument(level = "debug", skip(self))]
+    pub(super) fn mirror_expr_inner(
+        &mut self,
+        hir_expr: &'tcx hir::Expr<'tcx>,
+        ty: Option<Ty<'tcx>>,
+    ) -> ExprId {
         let temp_lifetime = self.region_scope_tree.temporary_scope(hir_expr.hir_id.local_id);
         let expr_scope =
             region::Scope { id: hir_expr.hir_id.local_id, data: region::ScopeData::Node };
 
-        debug!("Expr::make_mirror(): id={}, span={:?}", hir_expr.hir_id, hir_expr.span);
-
         let mut expr = self.make_mirror_unadjusted(hir_expr);
 
         let adjustment_span = match self.adjustment_span {
@@ -47,12 +54,16 @@ impl<'tcx> Cx<'tcx> {
 
         // Now apply adjustments, if any.
         for adjustment in self.typeck_results.expr_adjustments(hir_expr) {
-            debug!("make_mirror: expr={:?} applying adjustment={:?}", expr, adjustment);
+            debug!(?expr, ?adjustment);
             let span = expr.span;
             expr =
                 self.apply_adjustment(hir_expr, expr, adjustment, adjustment_span.unwrap_or(span));
         }
 
+        if !matches!(Category::of(&expr.kind), Some(Category::Constant)) {
+            expr.ty = ty.unwrap_or(expr.ty);
+        }
+
         // Next, wrap this up in the expr's scope.
         expr = Expr {
             temp_lifetime,
@@ -172,7 +183,7 @@ impl<'tcx> Cx<'tcx> {
                 // is guaranteed to exist, since a method call always has a receiver.
                 let old_adjustment_span = self.adjustment_span.replace((args[0].hir_id, expr_span));
                 tracing::info!("Using method span: {:?}", expr.span);
-                let args = self.mirror_exprs(args);
+                let args = self.mirror_exprs(args.iter().zip(std::iter::repeat(None)));
                 self.adjustment_span = old_adjustment_span;
                 ExprKind::Call {
                     ty: expr.ty,
@@ -194,12 +205,16 @@ impl<'tcx> Cx<'tcx> {
 
                     let method = self.method_callee(expr, fun.span, None);
 
-                    let arg_tys = args.iter().map(|e| self.typeck_results().expr_ty_adjusted(e));
+                    let arg_tys: Vec<_> =
+                        args.iter().map(|e| self.typeck_results().expr_ty_adjusted(e)).collect();
                     let tupled_args = Expr {
-                        ty: self.tcx.mk_tup(arg_tys),
+                        ty: self.tcx.mk_tup(arg_tys.iter()),
                         temp_lifetime,
                         span: expr.span,
-                        kind: ExprKind::Tuple { fields: self.mirror_exprs(args) },
+                        kind: ExprKind::Tuple {
+                            fields: self
+                                .mirror_exprs(args.iter().zip(arg_tys.into_iter().map(Some))),
+                        },
                     };
                     let tupled_args = self.thir.exprs.push(tupled_args);
 
@@ -256,7 +271,7 @@ impl<'tcx> Cx<'tcx> {
                         ExprKind::Call {
                             ty: self.typeck_results().node_type(fun.hir_id),
                             fun: self.mirror_expr(fun),
-                            args: self.mirror_exprs(args),
+                            args: self.mirror_exprs(args.iter().zip(std::iter::repeat(None))),
                             from_hir_call: true,
                             fn_span: expr.span,
                         }
@@ -763,10 +778,17 @@ impl<'tcx> Cx<'tcx> {
                 ExprKind::Use { source: self.mirror_expr(source) }
             }
             hir::ExprKind::Box(ref value) => ExprKind::Box { value: self.mirror_expr(value) },
-            hir::ExprKind::Array(ref fields) => {
-                ExprKind::Array { fields: self.mirror_exprs(fields) }
-            }
-            hir::ExprKind::Tup(ref fields) => ExprKind::Tuple { fields: self.mirror_exprs(fields) },
+            hir::ExprKind::Array(ref fields) => ExprKind::Array {
+                fields: self.mirror_exprs(
+                    fields
+                        .iter()
+                        .zip(std::iter::repeat(Some(expr_ty.sequence_element_type(self.tcx)))),
+                ),
+            },
+            hir::ExprKind::Tup(ref fields) => ExprKind::Tuple {
+                fields: self
+                    .mirror_exprs(fields.iter().zip(expr_ty.tuple_fields().iter().map(Some))),
+            },
 
             hir::ExprKind::Yield(ref v, _) => ExprKind::Yield { value: self.mirror_expr(v) },
             hir::ExprKind::Err => unreachable!(),
diff --git a/src/test/ui/impl-trait/issue-86465.stderr b/src/test/ui/impl-trait/issue-86465.stderr
@@ -1,11 +1,14 @@
 error: concrete type differs from previous defining opaque type use
-  --> $DIR/issue-86465.rs:6:5
+  --> $DIR/issue-86465.rs:6:9
    |
 LL |     (a, a)
-   |     ^^^^^^
-   |     |
-   |     expected `&'a u32`, got `&'b u32`
-   |     this expression supplies two conflicting concrete types for the same opaque type
+   |         ^ expected `&'a u32`, got `&'b u32`
+   |
+note: previous use here
+  --> $DIR/issue-86465.rs:6:6
+   |
+LL |     (a, a)
+   |      ^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr
@@ -1,11 +1,14 @@
 error: concrete type differs from previous defining opaque type use
-  --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:6:5
+  --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:6:9
    |
 LL |     (i, i)
-   |     ^^^^^^
-   |     |
-   |     expected `&'a i32`, got `&'b i32`
-   |     this expression supplies two conflicting concrete types for the same opaque type
+   |         ^ expected `&'a i32`, got `&'b i32`
+   |
+note: previous use here
+  --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:6:6
+   |
+LL |     (i, i)
+   |      ^
 
 error: aborting due to previous error
 
diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr
@@ -1,11 +1,14 @@
 error: concrete type differs from previous defining opaque type use
-  --> $DIR/multiple-def-uses-in-one-fn2.rs:10:5
+  --> $DIR/multiple-def-uses-in-one-fn2.rs:10:17
    |
 LL |     (a.clone(), a)
-   |     ^^^^^^^^^^^^^^
-   |     |
-   |     expected `A`, got `B`
-   |     this expression supplies two conflicting concrete types for the same opaque type
+   |                 ^ expected `A`, got `B`
+   |
+note: previous use here
+  --> $DIR/multiple-def-uses-in-one-fn2.rs:10:6
+   |
+LL |     (a.clone(), a)
+   |      ^^^^^^^^^
 
 error: aborting due to previous error
 
