Rollup merge of rust-lang#85934 - tmiasko:is-union, r=jackh726

JohnTitor · web-flow · commit 2fddcfda7a46 · 2021-06-03T14:35:41.000+09:00
Add `Ty::is_union` predicate
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1837,10 +1837,12 @@ impl<'tcx> TyS<'tcx> {
 
     #[inline]
     pub fn is_enum(&self) -> bool {
-        match self.kind() {
-            Adt(adt_def, _) => adt_def.is_enum(),
-            _ => false,
-        }
+        matches!(self.kind(), Adt(adt_def, _) if adt_def.is_enum())
+    }
+
+    #[inline]
+    pub fn is_union(&self) -> bool {
+        matches!(self.kind(), Adt(adt_def, _) if adt_def.is_union())
     }
 
     #[inline]
diff --git a/compiler/rustc_mir/src/borrow_check/mod.rs b/compiler/rustc_mir/src/borrow_check/mod.rs
@@ -1965,13 +1965,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 // no move out from an earlier location) then this is an attempt at initialization
                 // of the union - we should error in that case.
                 let tcx = this.infcx.tcx;
-                if let ty::Adt(def, _) = base.ty(this.body(), tcx).ty.kind() {
-                    if def.is_union() {
-                        if this.move_data.path_map[mpi].iter().any(|moi| {
-                            this.move_data.moves[*moi].source.is_predecessor_of(location, this.body)
-                        }) {
-                            return;
-                        }
+                if base.ty(this.body(), tcx).ty.is_union() {
+                    if this.move_data.path_map[mpi].iter().any(|moi| {
+                        this.move_data.moves[*moi].source.is_predecessor_of(location, this.body)
+                    }) {
+                        return;
                     }
                 }
 
diff --git a/compiler/rustc_mir/src/borrow_check/places_conflict.rs b/compiler/rustc_mir/src/borrow_check/places_conflict.rs
@@ -331,17 +331,14 @@ fn place_projection_conflict<'tcx>(
                 Overlap::EqualOrDisjoint
             } else {
                 let ty = Place::ty_from(pi1_local, pi1_proj_base, body, tcx).ty;
-                match ty.kind() {
-                    ty::Adt(def, _) if def.is_union() => {
-                        // Different fields of a union, we are basically stuck.
-                        debug!("place_element_conflict: STUCK-UNION");
-                        Overlap::Arbitrary
-                    }
-                    _ => {
-                        // Different fields of a struct (`a.x` vs. `a.y`). Disjoint!
-                        debug!("place_element_conflict: DISJOINT-FIELD");
-                        Overlap::Disjoint
-                    }
+                if ty.is_union() {
+                    // Different fields of a union, we are basically stuck.
+                    debug!("place_element_conflict: STUCK-UNION");
+                    Overlap::Arbitrary
+                } else {
+                    // Different fields of a struct (`a.x` vs. `a.y`). Disjoint!
+                    debug!("place_element_conflict: DISJOINT-FIELD");
+                    Overlap::Disjoint
                 }
             }
         }
diff --git a/compiler/rustc_mir/src/dataflow/move_paths/builder.rs b/compiler/rustc_mir/src/dataflow/move_paths/builder.rs
@@ -519,10 +519,8 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
         // Check if we are assigning into a field of a union, if so, lookup the place
         // of the union so it is marked as initialized again.
         if let Some((place_base, ProjectionElem::Field(_, _))) = place.last_projection() {
-            if let ty::Adt(def, _) = place_base.ty(self.builder.body, self.builder.tcx).ty.kind() {
-                if def.is_union() {
-                    place = place_base;
-                }
+            if place_base.ty(self.builder.body, self.builder.tcx).ty.is_union() {
+                place = place_base;
             }
         }
 
diff --git a/compiler/rustc_mir/src/transform/check_consts/validation.rs b/compiler/rustc_mir/src/transform/check_consts/validation.rs
@@ -752,12 +752,8 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
             | ProjectionElem::Field(..)
             | ProjectionElem::Index(_) => {
                 let base_ty = Place::ty_from(place_local, proj_base, self.body, self.tcx).ty;
-                match base_ty.ty_adt_def() {
-                    Some(def) if def.is_union() => {
-                        self.check_op(ops::UnionAccess);
-                    }
-
-                    _ => {}
+                if base_ty.is_union() {
+                    self.check_op(ops::UnionAccess);
                 }
             }
         }
diff --git a/compiler/rustc_mir/src/transform/check_unsafety.rs b/compiler/rustc_mir/src/transform/check_unsafety.rs
@@ -221,7 +221,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
             }
 
             let base_ty = base.ty(self.body, self.tcx).ty;
-            if base_ty.ty_adt_def().map_or(false, |adt| adt.is_union()) {
+            if base_ty.is_union() {
                 // If we did not hit a `Deref` yet and the overall place use is an assignment, the
                 // rules are different.
                 let assign_to_field = !saw_deref
diff --git a/compiler/rustc_mir/src/transform/dest_prop.rs b/compiler/rustc_mir/src/transform/dest_prop.rs
@@ -114,7 +114,7 @@ use rustc_middle::mir::{
     traversal, Body, InlineAsmOperand, Local, LocalKind, Location, Operand, Place, PlaceElem,
     Rvalue, Statement, StatementKind, Terminator, TerminatorKind,
 };
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::TyCtxt;
 
 // Empirical measurements have resulted in some observations:
 // - Running on a body with a single block and 500 locals takes barely any time
@@ -910,17 +910,8 @@ impl<'a, 'tcx> Visitor<'tcx> for FindAssignments<'a, 'tcx> {
 
             // Handle the "subtle case" described above by rejecting any `dest` that is or
             // projects through a union.
-            let is_union = |ty: Ty<'_>| {
-                if let ty::Adt(def, _) = ty.kind() {
-                    if def.is_union() {
-                        return true;
-                    }
-                }
-
-                false
-            };
             let mut place_ty = PlaceTy::from_ty(self.body.local_decls[dest.local].ty);
-            if is_union(place_ty.ty) {
+            if place_ty.ty.is_union() {
                 return;
             }
             for elem in dest.projection {
@@ -930,7 +921,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindAssignments<'a, 'tcx> {
                 }
 
                 place_ty = place_ty.projection_ty(self.tcx, elem);
-                if is_union(place_ty.ty) {
+                if place_ty.ty.is_union() {
                     return;
                 }
             }
diff --git a/compiler/rustc_mir/src/transform/promote_consts.rs b/compiler/rustc_mir/src/transform/promote_consts.rs
@@ -415,11 +415,9 @@ impl<'tcx> Validator<'_, 'tcx> {
 
                     ProjectionElem::Field(..) => {
                         let base_ty = place_base.ty(self.body, self.tcx).ty;
-                        if let Some(def) = base_ty.ty_adt_def() {
+                        if base_ty.is_union() {
                             // No promotion of union field accesses.
-                            if def.is_union() {
-                                return Err(Unpromotable);
-                            }
+                            return Err(Unpromotable);
                         }
                     }
                 }
diff --git a/compiler/rustc_mir/src/transform/remove_zsts.rs b/compiler/rustc_mir/src/transform/remove_zsts.rs
@@ -69,21 +69,14 @@ fn involves_a_union<'tcx>(
     tcx: TyCtxt<'tcx>,
 ) -> bool {
     let mut place_ty = PlaceTy::from_ty(local_decls[place.local].ty);
-    if is_union(place_ty.ty) {
+    if place_ty.ty.is_union() {
         return true;
     }
     for elem in place.projection {
         place_ty = place_ty.projection_ty(tcx, elem);
-        if is_union(place_ty.ty) {
+        if place_ty.ty.is_union() {
             return true;
         }
     }
     return false;
 }
-
-fn is_union(ty: Ty<'_>) -> bool {
-    match ty.kind() {
-        ty::Adt(def, _) if def.is_union() => true,
-        _ => false,
-    }
-}
diff --git a/compiler/rustc_typeck/src/check/place_op.rs b/compiler/rustc_typeck/src/check/place_op.rs
@@ -248,7 +248,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Clear previous flag; after a pointer indirection it does not apply any more.
                 inside_union = false;
             }
-            if source.ty_adt_def().map_or(false, |adt| adt.is_union()) {
+            if source.is_union() {
                 inside_union = true;
             }
             // Fix up the autoderefs. Autorefs can only occur immediately preceding

Original file line number	Diff line number	Diff line change
`@@ -519,10 +519,8 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {`
`519`	`519`	`// Check if we are assigning into a field of a union, if so, lookup the place`
`520`	`520`	`// of the union so it is marked as initialized again.`
`521`	`521`	`if let Some((place_base, ProjectionElem::Field(_, _))) = place.last_projection() {`
`522`		`- if let ty::Adt(def, _) = place_base.ty(self.builder.body, self.builder.tcx).ty.kind() {`
`523`		`- if def.is_union() {`
`524`		`- place = place_base;`
`525`		`- }`
	`522`	`+ if place_base.ty(self.builder.body, self.builder.tcx).ty.is_union() {`
	`523`	`+ place = place_base;`
`526`	`524`	`}`
`527`	`525`	`}`
`528`	`526`
Original file line number	Diff line number	Diff line change
`@@ -752,12 +752,8 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {`
`752`	`752`	`\| ProjectionElem::Field(..)`
`753`	`753`	`\| ProjectionElem::Index(_) => {`
`754`	`754`	`let base_ty = Place::ty_from(place_local, proj_base, self.body, self.tcx).ty;`
`755`		`- match base_ty.ty_adt_def() {`
`756`		`- Some(def) if def.is_union() => {`
`757`		`- self.check_op(ops::UnionAccess);`
`758`		`- }`
`759`		`-`
`760`		`- _ => {}`
	`755`	`+ if base_ty.is_union() {`
	`756`	`+ self.check_op(ops::UnionAccess);`
`761`	`757`	`}`
`762`	`758`	`}`
`763`	`759`	`}`
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`let base_ty = base.ty(self.body, self.tcx).ty;`
`224`		`- if base_ty.ty_adt_def().map_or(false, \|adt\| adt.is_union()) {`
	`224`	`+ if base_ty.is_union() {`
`225`	`225`	// If we did not hit a `Deref` yet and the overall place use is an assignment, the
`226`	`226`	`// rules are different.`
`227`	`227`	`let assign_to_field = !saw_deref`
Original file line number	Diff line number	Diff line change
`@@ -415,11 +415,9 @@ impl<'tcx> Validator<'_, 'tcx> {`
`415`	`415`
`416`	`416`	`ProjectionElem::Field(..) => {`
`417`	`417`	`let base_ty = place_base.ty(self.body, self.tcx).ty;`
`418`		`- if let Some(def) = base_ty.ty_adt_def() {`
	`418`	`+ if base_ty.is_union() {`
`419`	`419`	`// No promotion of union field accesses.`
`420`		`- if def.is_union() {`
`421`		`- return Err(Unpromotable);`
`422`		`- }`
	`420`	`+ return Err(Unpromotable);`
`423`	`421`	`}`
`424`	`422`	`}`
`425`	`423`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,21 +69,14 @@ fn involves_a_union<'tcx>(`
`69`	`69`	`tcx: TyCtxt<'tcx>,`
`70`	`70`	`) -> bool {`
`71`	`71`	`let mut place_ty = PlaceTy::from_ty(local_decls[place.local].ty);`
`72`		`- if is_union(place_ty.ty) {`
	`72`	`+ if place_ty.ty.is_union() {`
`73`	`73`	`return true;`
`74`	`74`	`}`
`75`	`75`	`for elem in place.projection {`
`76`	`76`	`place_ty = place_ty.projection_ty(tcx, elem);`
`77`		`- if is_union(place_ty.ty) {`
	`77`	`+ if place_ty.ty.is_union() {`
`78`	`78`	`return true;`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`	`return false;`
`82`	`82`	`}`
`83`		`-`
`84`		`-fn is_union(ty: Ty<'_>) -> bool {`
`85`		`- match ty.kind() {`
`86`		`- ty::Adt(def, _) if def.is_union() => true,`
`87`		`- _ => false,`
`88`		`- }`
`89`		`-}`
Original file line number	Diff line number	Diff line change
`@@ -248,7 +248,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`248`	`248`	`// Clear previous flag; after a pointer indirection it does not apply any more.`
`249`	`249`	`inside_union = false;`
`250`	`250`	`}`
`251`		`- if source.ty_adt_def().map_or(false, \|adt\| adt.is_union()) {`
	`251`	`+ if source.is_union() {`
`252`	`252`	`inside_union = true;`
`253`	`253`	`}`
`254`	`254`	`// Fix up the autoderefs. Autorefs can only occur immediately preceding`