diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs
index 308abb5e1332586a33260dff04dcf9bc4c10b001..b508f91e01ebb22905053676a4c7ba5a33419547 100644
--- a/src/librustc/infer/canonical/mod.rs
+++ b/src/librustc/infer/canonical/mod.rs
@@ -23,7 +23,7 @@
 
 use crate::infer::{InferCtxt, RegionVariableOrigin, TypeVariableOrigin, TypeVariableOriginKind};
 use crate::infer::{ConstVariableOrigin, ConstVariableOriginKind};
-use crate::infer::region_constraints::PickConstraint;
+use crate::infer::region_constraints::MemberConstraint;
 use crate::mir::interpret::ConstValue;
 use rustc_data_structures::indexed_vec::IndexVec;
 use rustc_macros::HashStable;
@@ -198,14 +198,14 @@ pub struct QueryResponse<'tcx, R> {
 #[derive(Clone, Debug, Default, HashStable)]
 pub struct QueryRegionConstraints<'tcx> {
     pub outlives: Vec<QueryOutlivesConstraint<'tcx>>,
-    pub pick_constraints: Vec<PickConstraint<'tcx>>,
+    pub member_constraints: Vec<MemberConstraint<'tcx>>,
 }
 
 impl QueryRegionConstraints<'_> {
     /// Represents an empty (trivially true) set of region
     /// constraints.
     pub fn is_empty(&self) -> bool {
-        self.outlives.is_empty() && self.pick_constraints.is_empty()
+        self.outlives.is_empty() && self.member_constraints.is_empty()
     }
 }
 
@@ -558,14 +558,14 @@ impl<'a, 'tcx, R> Lift<'tcx> for QueryResponse<'a, R> {
 
 BraceStructTypeFoldableImpl! {
     impl<'tcx> TypeFoldable<'tcx> for QueryRegionConstraints<'tcx> {
-        outlives, pick_constraints
+        outlives, member_constraints
     }
 }
 
 BraceStructLiftImpl! {
     impl<'a, 'tcx> Lift<'tcx> for QueryRegionConstraints<'a> {
         type Lifted = QueryRegionConstraints<'tcx>;
-        outlives, pick_constraints
+        outlives, member_constraints
     }
 }
 
diff --git a/src/librustc/infer/canonical/query_response.rs b/src/librustc/infer/canonical/query_response.rs
index 02a5005be7604f6d7fe118342dc3366cb4d01c23..79c5538626be191f80eba1c5671db8b8f56892fd 100644
--- a/src/librustc/infer/canonical/query_response.rs
+++ b/src/librustc/infer/canonical/query_response.rs
@@ -351,9 +351,9 @@ pub fn instantiate_nll_query_response_and_region_obligations<R>(
             })
         );
 
-        // ...also include the query pick constraints.
-        output_query_region_constraints.pick_constraints.extend(
-            query_response.value.region_constraints.pick_constraints.iter().map(|p_c| {
+        // ...also include the query member constraints.
+        output_query_region_constraints.member_constraints.extend(
+            query_response.value.region_constraints.member_constraints.iter().map(|p_c| {
                 substitute_value(self.tcx, &result_subst, p_c)
             })
         );
@@ -663,7 +663,7 @@ pub fn make_query_region_constraints<'tcx>(
         constraints,
         verifys,
         givens,
-        pick_constraints,
+        member_constraints,
     } = region_constraints;
 
     assert!(verifys.is_empty());
@@ -694,5 +694,5 @@ pub fn make_query_region_constraints<'tcx>(
         )
         .collect();
 
-    QueryRegionConstraints { outlives, pick_constraints: pick_constraints.clone() }
+    QueryRegionConstraints { outlives, member_constraints: member_constraints.clone() }
 }
diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
index 5a89fd89941d4fd6a6799fcaf6407c6125f0039c..cbfb048c064a2c2e4d3b91d72c632bf1cfb9f402 100644
--- a/src/librustc/infer/error_reporting/mod.rs
+++ b/src/librustc/infer/error_reporting/mod.rs
@@ -377,12 +377,12 @@ pub fn report_region_errors(
                         }
                     }
 
-                    RegionResolutionError::PickConstraintFailure {
+                    RegionResolutionError::MemberConstraintFailure {
                         opaque_type_def_id,
                         hidden_ty,
-                        pick_region,
+                        member_region,
                         span: _,
-                        option_regions: _,
+                        choice_regions: _,
                     } => {
                         let hidden_ty = self.resolve_vars_if_possible(&hidden_ty);
                         opaque_types::unexpected_hidden_region_diagnostic(
@@ -390,7 +390,7 @@ pub fn report_region_errors(
                             Some(region_scope_tree),
                             opaque_type_def_id,
                             hidden_ty,
-                            pick_region,
+                            member_region,
                         ).emit();
                     }
                 }
@@ -430,7 +430,7 @@ fn process_errors(
             RegionResolutionError::GenericBoundFailure(..) => true,
             RegionResolutionError::ConcreteFailure(..)
                 | RegionResolutionError::SubSupConflict(..)
-                | RegionResolutionError::PickConstraintFailure { .. } => false,
+                | RegionResolutionError::MemberConstraintFailure { .. } => false,
         };
 
         let mut errors = if errors.iter().all(|e| is_bound_failure(e)) {
@@ -448,7 +448,7 @@ fn process_errors(
             RegionResolutionError::ConcreteFailure(ref sro, _, _) => sro.span(),
             RegionResolutionError::GenericBoundFailure(ref sro, _, _) => sro.span(),
             RegionResolutionError::SubSupConflict(_, ref rvo, _, _, _, _) => rvo.span(),
-            RegionResolutionError::PickConstraintFailure { span, .. } => span,
+            RegionResolutionError::MemberConstraintFailure { span, .. } => span,
         });
         errors
     }
diff --git a/src/librustc/infer/lexical_region_resolve/mod.rs b/src/librustc/infer/lexical_region_resolve/mod.rs
index 44925608164018764b10ecd701f6b6935887702a..c718badf6e0630094522a573426410c37cc7e414 100644
--- a/src/librustc/infer/lexical_region_resolve/mod.rs
+++ b/src/librustc/infer/lexical_region_resolve/mod.rs
@@ -3,7 +3,7 @@
 use crate::hir::def_id::DefId;
 use crate::infer::region_constraints::Constraint;
 use crate::infer::region_constraints::GenericKind;
-use crate::infer::region_constraints::PickConstraint;
+use crate::infer::region_constraints::MemberConstraint;
 use crate::infer::region_constraints::RegionConstraintData;
 use crate::infer::region_constraints::VarInfos;
 use crate::infer::region_constraints::VerifyBound;
@@ -84,15 +84,15 @@ pub enum RegionResolutionError<'tcx> {
         Region<'tcx>,
     ),
 
-    /// Indicates a failure of a `PickConstraint`. These arise during
+    /// Indicates a failure of a `MemberConstraint`. These arise during
     /// impl trait processing explicitly -- basically, the impl trait's hidden type
     /// included some region that it was not supposed to.
-    PickConstraintFailure {
+    MemberConstraintFailure {
         span: Span,
         opaque_type_def_id: DefId,
         hidden_ty: Ty<'tcx>,
-        pick_region: Region<'tcx>,
-        option_regions: Vec<Region<'tcx>>,
+        member_region: Region<'tcx>,
+        choice_regions: Vec<Region<'tcx>>,
     },
 }
 
@@ -133,7 +133,7 @@ fn infer_variable_values(
         self.expand_givens(&graph);
         loop {
             self.expansion(&mut var_data);
-            if !self.enforce_pick_constraints(&graph, &mut var_data) {
+            if !self.enforce_member_constraints(&graph, &mut var_data) {
                 break;
             }
         }
@@ -197,16 +197,16 @@ fn expand_givens(&mut self, graph: &RegionGraph<'_>) {
         }
     }
 
-    /// Enforce all pick constraints and return true if anything
-    /// changed. See `enforce_pick_constraint` for more details.
-    fn enforce_pick_constraints(
+    /// Enforce all member constraints and return true if anything
+    /// changed. See `enforce_member_constraint` for more details.
+    fn enforce_member_constraints(
         &self,
         graph: &RegionGraph<'tcx>,
         var_values: &mut LexicalRegionResolutions<'tcx>,
     ) -> bool {
         let mut any_changed = false;
-        for pick_constraint in &self.data.pick_constraints {
-            if self.enforce_pick_constraint(graph, pick_constraint, var_values) {
+        for member_constraint in &self.data.member_constraints {
+            if self.enforce_member_constraint(graph, member_constraint, var_values) {
                 any_changed = true;
             }
         }
@@ -230,39 +230,44 @@ fn enforce_pick_constraints(
     ///
     /// From that list, we look for a *minimal* option `'o_min`. If we
     /// find one, then we can enforce that `'r: 'o_min`.
-    fn enforce_pick_constraint(
+    fn enforce_member_constraint(
         &self,
         graph: &RegionGraph<'tcx>,
-        pick_constraint: &PickConstraint<'tcx>,
+        member_constraint: &MemberConstraint<'tcx>,
         var_values: &mut LexicalRegionResolutions<'tcx>,
     ) -> bool {
-        debug!("enforce_pick_constraint(pick_constraint={:#?})", pick_constraint);
+        debug!("enforce_member_constraint(member_constraint={:#?})", member_constraint);
 
         // the constraint is some inference variable (`vid`) which
         // must be equal to one of the options
-        let pick_vid = match pick_constraint.pick_region {
+        let member_vid = match member_constraint.member_region {
             ty::ReVar(vid) => *vid,
             _ => return false,
         };
 
         // The current value of `vid` is a lower bound LB -- i.e., we
         // know that `LB <= vid` must be true.
-        let pick_lower_bound: ty::Region<'tcx> = match var_values.value(pick_vid) {
+        let member_lower_bound: ty::Region<'tcx> = match var_values.value(member_vid) {
             VarValue::ErrorValue => return false,
             VarValue::Value(r) => r,
         };
 
         // find all the "upper bounds" -- that is, each region `b` such that
         // `r0 <= b` must hold.
-        let (pick_upper_bounds, _) = self.collect_concrete_regions(graph, pick_vid, OUTGOING, None);
+        let (member_upper_bounds, _) = self.collect_concrete_regions(
+            graph,
+            member_vid,
+            OUTGOING,
+            None,
+        );
 
-        // get an iterator over the *available options* -- that is,
-        // each constraint regions `o` where `lb <= o` and `o <= ub` for all the
+        // get an iterator over the *available choice* -- that is,
+        // each choice region `c` where `lb <= c` and `c <= ub` for all the
         // upper bounds `ub`.
-        debug!("enforce_pick_constraint: upper_bounds={:#?}", pick_upper_bounds);
-        let mut options = pick_constraint.option_regions.iter().filter(|option| {
-            self.sub_concrete_regions(pick_lower_bound, option)
-                && pick_upper_bounds
+        debug!("enforce_member_constraint: upper_bounds={:#?}", member_upper_bounds);
+        let mut options = member_constraint.choice_regions.iter().filter(|option| {
+            self.sub_concrete_regions(member_lower_bound, option)
+                && member_upper_bounds
                     .iter()
                     .all(|upper_bound| self.sub_concrete_regions(option, upper_bound.region))
         });
@@ -274,23 +279,23 @@ fn enforce_pick_constraint(
             Some(&r) => r,
             None => return false,
         };
-        debug!("enforce_pick_constraint: least_choice={:?}", least_choice);
+        debug!("enforce_member_constraint: least_choice={:?}", least_choice);
         for &option in options {
-            debug!("enforce_pick_constraint: option={:?}", option);
+            debug!("enforce_member_constraint: option={:?}", option);
             if !self.sub_concrete_regions(least_choice, option) {
                 if self.sub_concrete_regions(option, least_choice) {
-                    debug!("enforce_pick_constraint: new least choice");
+                    debug!("enforce_member_constraint: new least choice");
                     least_choice = option;
                 } else {
-                    debug!("enforce_pick_constraint: no least choice");
+                    debug!("enforce_member_constraint: no least choice");
                     return false;
                 }
             }
         }
 
-        debug!("enforce_pick_constraint: final least choice = {:?}", least_choice);
-        if least_choice != pick_lower_bound {
-            *var_values.value_mut(pick_vid) = VarValue::Value(least_choice);
+        debug!("enforce_member_constraint: final least choice = {:?}", least_choice);
+        if least_choice != member_lower_bound {
+            *var_values.value_mut(member_vid) = VarValue::Value(least_choice);
             true
         } else {
             false
@@ -547,20 +552,20 @@ fn collect_errors(
             }
         }
 
-        for pick_constraint in &self.data.pick_constraints {
-            let pick_region = var_data.normalize(self.tcx(), pick_constraint.pick_region);
-            let option_regions = pick_constraint
-                .option_regions
+        for member_constraint in &self.data.member_constraints {
+            let member_region = var_data.normalize(self.tcx(), member_constraint.member_region);
+            let choice_regions = member_constraint
+                .choice_regions
                 .iter()
-                .map(|&option_region| var_data.normalize(self.tcx(), option_region));
-            if !option_regions.clone().any(|option_region| pick_region == option_region) {
-                let span = self.tcx().def_span(pick_constraint.opaque_type_def_id);
-                errors.push(RegionResolutionError::PickConstraintFailure {
+                .map(|&choice_region| var_data.normalize(self.tcx(), choice_region));
+            if !choice_regions.clone().any(|choice_region| member_region == choice_region) {
+                let span = self.tcx().def_span(member_constraint.opaque_type_def_id);
+                errors.push(RegionResolutionError::MemberConstraintFailure {
                     span,
-                    opaque_type_def_id: pick_constraint.opaque_type_def_id,
-                    hidden_ty: pick_constraint.hidden_ty,
-                    pick_region,
-                    option_regions: option_regions.collect(),
+                    opaque_type_def_id: member_constraint.opaque_type_def_id,
+                    hidden_ty: member_constraint.hidden_ty,
+                    member_region,
+                    choice_regions: choice_regions.collect(),
                 });
             }
         }
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
index d887dc13f59d2d14ec36fdbf6475d86c5e756a2e..663acd67dcd839b147f5e4b3a7fc263a70e0a0af 100644
--- a/src/librustc/infer/mod.rs
+++ b/src/librustc/infer/mod.rs
@@ -907,7 +907,7 @@ pub fn sub_regions(
 
     /// Require that the region `r` be equal to one of the regions in
     /// the set `regions`.
-    pub fn pick_constraint(
+    pub fn member_constraint(
         &self,
         opaque_type_def_id: DefId,
         definition_span: Span,
@@ -915,9 +915,9 @@ pub fn pick_constraint(
         region: ty::Region<'tcx>,
         in_regions: &Lrc<Vec<ty::Region<'tcx>>>,
     ) {
-        debug!("pick_constraint({:?} <: {:?})", region, in_regions);
+        debug!("member_constraint({:?} <: {:?})", region, in_regions);
         self.borrow_region_constraints()
-            .pick_constraint(opaque_type_def_id, definition_span, hidden_ty, region, in_regions);
+            .member_constraint(opaque_type_def_id, definition_span, hidden_ty, region, in_regions);
     }
 
     pub fn subtype_predicate(
diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs
index 0571de8680f8b313ca418e237670584b712a8b25..2e35aefa88ae6a0d45a5cb8b1a47230d67c9946d 100644
--- a/src/librustc/infer/opaque_types/mod.rs
+++ b/src/librustc/infer/opaque_types/mod.rs
@@ -393,7 +393,7 @@ pub fn constrain_opaque_type<FRR: FreeRegionRelations<'tcx>>(
                         // we will create a "in bound" like `'r in
                         // ['a, 'b, 'c]`, where `'a..'c` are the
                         // regions that appear in the impl trait.
-                        return self.generate_pick_constraint(
+                        return self.generate_member_constraint(
                             concrete_ty,
                             abstract_type_generics,
                             opaque_defn,
@@ -418,17 +418,17 @@ pub fn constrain_opaque_type<FRR: FreeRegionRelations<'tcx>>(
     /// related, we would generate a constraint `'r in ['a, 'b,
     /// 'static]` for each region `'r` that appears in the hidden type
     /// (i.e., it must be equal to `'a`, `'b`, or `'static`).
-    fn generate_pick_constraint(
+    fn generate_member_constraint(
         &self,
         concrete_ty: Ty<'tcx>,
         abstract_type_generics: &ty::Generics,
         opaque_defn: &OpaqueTypeDecl<'tcx>,
         opaque_type_def_id: DefId,
     ) {
-        // Create the set of option regions: each region in the hidden
+        // Create the set of choice regions: each region in the hidden
         // type can be equal to any of the region parameters of the
         // opaque type definition.
-        let option_regions: Lrc<Vec<ty::Region<'tcx>>> = Lrc::new(
+        let choice_regions: Lrc<Vec<ty::Region<'tcx>>> = Lrc::new(
             abstract_type_generics
                 .params
                 .iter()
@@ -443,12 +443,12 @@ fn generate_pick_constraint(
 
         concrete_ty.visit_with(&mut ConstrainOpaqueTypeRegionVisitor {
             tcx: self.tcx,
-            op: |r| self.pick_constraint(
+            op: |r| self.member_constraint(
                 opaque_type_def_id,
                 opaque_defn.definition_span,
                 concrete_ty,
                 r,
-                &option_regions,
+                &choice_regions,
             ),
         });
     }
diff --git a/src/librustc/infer/region_constraints/mod.rs b/src/librustc/infer/region_constraints/mod.rs
index a8a2ae343a5925aeb797d3a087fe726e7605e8fc..06365890607637bdd940bd7f79abe87bc725da2c 100644
--- a/src/librustc/infer/region_constraints/mod.rs
+++ b/src/librustc/infer/region_constraints/mod.rs
@@ -81,10 +81,10 @@ pub struct RegionConstraintData<'tcx> {
     /// be a region variable (or neither, as it happens).
     pub constraints: BTreeMap<Constraint<'tcx>, SubregionOrigin<'tcx>>,
 
-    /// Constraints of the form `pick R0 from [R1, ..., Rn]`, meaning that
+    /// Constraints of the form `R0 member of [R1, ..., Rn]`, meaning that
     /// `R0` must be equal to one of the regions `R1..Rn`. These occur
     /// with `impl Trait` quite frequently.
-    pub pick_constraints: Vec<PickConstraint<'tcx>>,
+    pub member_constraints: Vec<MemberConstraint<'tcx>>,
 
     /// A "verify" is something that we need to verify after inference
     /// is done, but which does not directly affect inference in any
@@ -145,40 +145,40 @@ pub fn involves_placeholders(&self) -> bool {
     }
 }
 
-/// Requires that `region` must be equal to one of the regions in `option_regions`.
+/// Requires that `region` must be equal to one of the regions in `choice_regions`.
 /// We often denote this using the syntax:
 ///
 /// ```
-/// pick R0 from [O1..On]
+/// R0 member of [O1..On]
 /// ```
 #[derive(Debug, Clone, HashStable)]
-pub struct PickConstraint<'tcx> {
+pub struct MemberConstraint<'tcx> {
     /// the def-id of the opaque type causing this constraint: used for error reporting
     pub opaque_type_def_id: DefId,
 
     /// the span where the hidden type was instantiated
     pub definition_span: Span,
 
-    /// the hidden type in which `pick_region` appears: used for error reporting
+    /// the hidden type in which `member_region` appears: used for error reporting
     pub hidden_ty: Ty<'tcx>,
 
     /// the region R0
-    pub pick_region: Region<'tcx>,
+    pub member_region: Region<'tcx>,
 
     /// the options O1..On
-    pub option_regions: Lrc<Vec<Region<'tcx>>>,
+    pub choice_regions: Lrc<Vec<Region<'tcx>>>,
 }
 
 BraceStructTypeFoldableImpl! {
-    impl<'tcx> TypeFoldable<'tcx> for PickConstraint<'tcx> {
-        opaque_type_def_id, definition_span, hidden_ty, pick_region, option_regions
+    impl<'tcx> TypeFoldable<'tcx> for MemberConstraint<'tcx> {
+        opaque_type_def_id, definition_span, hidden_ty, member_region, choice_regions
     }
 }
 
 BraceStructLiftImpl! {
-    impl<'a, 'tcx> Lift<'tcx> for PickConstraint<'a> {
-        type Lifted = PickConstraint<'tcx>;
-        opaque_type_def_id, definition_span, hidden_ty, pick_region, option_regions
+    impl<'a, 'tcx> Lift<'tcx> for MemberConstraint<'a> {
+        type Lifted = MemberConstraint<'tcx>;
+        opaque_type_def_id, definition_span, hidden_ty, member_region, choice_regions
     }
 }
 
@@ -688,26 +688,26 @@ pub fn make_eqregion(
         }
     }
 
-    pub fn pick_constraint(
+    pub fn member_constraint(
         &mut self,
         opaque_type_def_id: DefId,
         definition_span: Span,
         hidden_ty: Ty<'tcx>,
-        pick_region: ty::Region<'tcx>,
-        option_regions: &Lrc<Vec<ty::Region<'tcx>>>,
+        member_region: ty::Region<'tcx>,
+        choice_regions: &Lrc<Vec<ty::Region<'tcx>>>,
     ) {
-        debug!("pick_constraint({:?} in {:#?})", pick_region, option_regions);
+        debug!("member_constraint({:?} in {:#?})", member_region, choice_regions);
 
-        if option_regions.iter().any(|&r| r == pick_region) {
+        if choice_regions.iter().any(|&r| r == member_region) {
             return;
         }
 
-        self.data.pick_constraints.push(PickConstraint {
+        self.data.member_constraints.push(MemberConstraint {
             opaque_type_def_id,
             definition_span,
             hidden_ty,
-            pick_region,
-            option_regions: option_regions.clone()
+            member_region,
+            choice_regions: choice_regions.clone()
         });
 
     }
@@ -975,12 +975,12 @@ impl<'tcx> RegionConstraintData<'tcx> {
     pub fn is_empty(&self) -> bool {
         let RegionConstraintData {
             constraints,
-            pick_constraints,
+            member_constraints,
             verifys,
             givens,
         } = self;
         constraints.is_empty() &&
-            pick_constraints.is_empty() &&
+            member_constraints.is_empty() &&
             verifys.is_empty() &&
             givens.is_empty()
     }
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
index b37e676570d33caeaa202ba39db6b8f7d666be7e..f1749d39d6e4131c12706ae70943c4d40cdb8839 100644
--- a/src/librustc/ty/structural_impls.rs
+++ b/src/librustc/ty/structural_impls.rs
@@ -349,7 +349,7 @@ fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
         tcx.lift(&self.0).and_then(|a| {
             tcx.lift(&self.1).and_then(|b| tcx.lift(&self.2).map(|c| (a, b, c)))
         })
-    }
+   }
 }
 
 impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for Option<T> {
diff --git a/src/librustc_mir/borrow_check/nll/mod.rs b/src/librustc_mir/borrow_check/nll/mod.rs
index 380bfb52e3ba3aa3375454ac6ef5c89a49747f42..eb63e0de195e5d6692d56ad9e94d9edb4514ab3e 100644
--- a/src/librustc_mir/borrow_check/nll/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/mod.rs
@@ -37,7 +37,7 @@
 mod universal_regions;
 
 mod constraints;
-mod pick_constraints;
+mod member_constraints;
 
 use self::facts::AllFacts;
 use self::region_infer::RegionInferenceContext;
@@ -130,7 +130,7 @@ pub(in crate::borrow_check) fn compute_regions<'cx, 'tcx>(
         placeholder_index_to_region: _,
         mut liveness_constraints,
         outlives_constraints,
-        pick_constraints,
+        member_constraints,
         closure_bounds_mapping,
         type_tests,
     } = constraints;
@@ -152,7 +152,7 @@ pub(in crate::borrow_check) fn compute_regions<'cx, 'tcx>(
         universal_region_relations,
         body,
         outlives_constraints,
-        pick_constraints,
+        member_constraints,
         closure_bounds_mapping,
         type_tests,
         liveness_constraints,
diff --git a/src/librustc_mir/borrow_check/nll/pick_constraints.rs b/src/librustc_mir/borrow_check/nll/pick_constraints.rs
index aa0f7852273abff96310cbc32d62a8c093a8df67..43212ffddf3a5be2a4afd475d5a25d37d92bf0bd 100644
--- a/src/librustc_mir/borrow_check/nll/pick_constraints.rs
+++ b/src/librustc_mir/borrow_check/nll/pick_constraints.rs
@@ -1,36 +1,36 @@
 use crate::rustc::ty::{self, Ty};
 use rustc::hir::def_id::DefId;
-use rustc::infer::region_constraints::PickConstraint;
+use rustc::infer::region_constraints::MemberConstraint;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use std::hash::Hash;
 use std::ops::Index;
 use syntax_pos::Span;
 
-/// Compactly stores a set of `pick R0 in [R1...Rn]` constraints,
+/// Compactly stores a set of `R0 member of [R1...Rn]` constraints,
 /// indexed by the region R0.
-crate struct PickConstraintSet<'tcx, R>
+crate struct MemberConstraintSet<'tcx, R>
 where
     R: Copy + Hash + Eq,
 {
-    /// Stores the first "pick" constraint for a given R0. This is an
+    /// Stores the first "member" constraint for a given R0. This is an
     /// index into the `constraints` vector below.
-    first_constraints: FxHashMap<R, NllPickConstraintIndex>,
+    first_constraints: FxHashMap<R, NllMemberConstraintIndex>,
 
-    /// Stores the data about each `pick R0 from [R1..Rn]` constraint.
+    /// Stores the data about each `R0 member of [R1..Rn]` constraint.
     /// These are organized into a linked list, so each constraint
     /// contains the index of the next constraint with the same R0.
-    constraints: IndexVec<NllPickConstraintIndex, NllPickConstraint<'tcx>>,
+    constraints: IndexVec<NllMemberConstraintIndex, NllMemberConstraint<'tcx>>,
 
     /// Stores the `R1..Rn` regions for *all* sets. For any given
     /// constraint, we keep two indices so that we can pull out a
     /// slice.
-    option_regions: Vec<ty::RegionVid>,
+    choice_regions: Vec<ty::RegionVid>,
 }
 
-/// Represents a `pick R0 in [R1..Rn]` constraint
-crate struct NllPickConstraint<'tcx> {
-    next_constraint: Option<NllPickConstraintIndex>,
+/// Represents a `R0 member of [R1..Rn]` constraint
+crate struct NllMemberConstraint<'tcx> {
+    next_constraint: Option<NllMemberConstraintIndex>,
 
     /// The opaque type whose hidden type is being inferred. (Used in error reporting.)
     crate opaque_type_def_id: DefId,
@@ -42,67 +42,70 @@
     crate hidden_ty: Ty<'tcx>,
 
     /// The region R0.
-    crate pick_region_vid: ty::RegionVid,
+    crate member_region_vid: ty::RegionVid,
 
-    /// Index of `R1` in `option_regions` vector from `PickConstraintSet`.
+    /// Index of `R1` in `choice_regions` vector from `MemberConstraintSet`.
     start_index: usize,
 
-    /// Index of `Rn` in `option_regions` vector from `PickConstraintSet`.
+    /// Index of `Rn` in `choice_regions` vector from `MemberConstraintSet`.
     end_index: usize,
 }
 
 newtype_index! {
-    crate struct NllPickConstraintIndex {
-        DEBUG_FORMAT = "PickConstraintIndex({})"
+    crate struct NllMemberConstraintIndex {
+        DEBUG_FORMAT = "MemberConstraintIndex({})"
     }
 }
 
-impl Default for PickConstraintSet<'tcx, ty::RegionVid> {
+impl Default for MemberConstraintSet<'tcx, ty::RegionVid> {
     fn default() -> Self {
         Self {
             first_constraints: Default::default(),
             constraints: Default::default(),
-            option_regions: Default::default(),
+            choice_regions: Default::default(),
         }
     }
 }
 
-impl<'tcx> PickConstraintSet<'tcx, ty::RegionVid> {
+impl<'tcx> MemberConstraintSet<'tcx, ty::RegionVid> {
     crate fn push_constraint(
         &mut self,
-        p_c: &PickConstraint<'tcx>,
+        m_c: &MemberConstraint<'tcx>,
         mut to_region_vid: impl FnMut(ty::Region<'tcx>) -> ty::RegionVid,
     ) {
-        debug!("push_constraint(p_c={:?})", p_c);
-        let pick_region_vid: ty::RegionVid = to_region_vid(p_c.pick_region);
-        let next_constraint = self.first_constraints.get(&pick_region_vid).cloned();
-        let start_index = self.option_regions.len();
-        let end_index = start_index + p_c.option_regions.len();
-        debug!("push_constraint: pick_region_vid={:?}", pick_region_vid);
-        let constraint_index = self.constraints.push(NllPickConstraint {
+        debug!("push_constraint(m_c={:?})", m_c);
+        let member_region_vid: ty::RegionVid = to_region_vid(m_c.member_region);
+        let next_constraint = self.first_constraints.get(&member_region_vid).cloned();
+        let start_index = self.choice_regions.len();
+        let end_index = start_index + m_c.choice_regions.len();
+        debug!("push_constraint: member_region_vid={:?}", member_region_vid);
+        let constraint_index = self.constraints.push(NllMemberConstraint {
             next_constraint,
-            pick_region_vid,
-            opaque_type_def_id: p_c.opaque_type_def_id,
-            definition_span: p_c.definition_span,
-            hidden_ty: p_c.hidden_ty,
+            member_region_vid,
+            opaque_type_def_id: m_c.opaque_type_def_id,
+            definition_span: m_c.definition_span,
+            hidden_ty: m_c.hidden_ty,
             start_index,
             end_index,
         });
-        self.first_constraints.insert(pick_region_vid, constraint_index);
-        self.option_regions.extend(p_c.option_regions.iter().map(|&r| to_region_vid(r)));
+        self.first_constraints.insert(member_region_vid, constraint_index);
+        self.choice_regions.extend(m_c.choice_regions.iter().map(|&r| to_region_vid(r)));
     }
 }
 
-impl<'tcx, R1> PickConstraintSet<'tcx, R1>
+impl<'tcx, R1> MemberConstraintSet<'tcx, R1>
 where
     R1: Copy + Hash + Eq,
 {
-    /// Remap the "pick region" key using `map_fn`, producing a new
+    /// Remap the "member region" key using `map_fn`, producing a new
     /// pick-constraint set.  This is used in the NLL code to map from
     /// the original `RegionVid` to an scc index. In some cases, we
     /// may have multiple R1 values mapping to the same R2 key -- that
     /// is ok, the two sets will be merged.
-    crate fn into_mapped<R2>(self, mut map_fn: impl FnMut(R1) -> R2) -> PickConstraintSet<'tcx, R2>
+    crate fn into_mapped<R2>(
+        self,
+        mut map_fn: impl FnMut(R1) -> R2,
+    ) -> MemberConstraintSet<'tcx, R2>
     where
         R2: Copy + Hash + Eq,
     {
@@ -116,7 +119,7 @@ impl<'tcx, R1> PickConstraintSet<'tcx, R1>
         // link from one list to point at the othe other (see
         // `append_list`).
 
-        let PickConstraintSet { first_constraints, mut constraints, option_regions } = self;
+        let MemberConstraintSet { first_constraints, mut constraints, choice_regions } = self;
 
         let mut first_constraints2 = FxHashMap::default();
         first_constraints2.reserve(first_constraints.len());
@@ -129,33 +132,33 @@ impl<'tcx, R1> PickConstraintSet<'tcx, R1>
             first_constraints2.insert(r2, start1);
         }
 
-        PickConstraintSet {
+        MemberConstraintSet {
             first_constraints: first_constraints2,
             constraints,
-            option_regions,
+            choice_regions,
         }
     }
 }
 
-impl<'tcx, R> PickConstraintSet<'tcx, R>
+impl<'tcx, R> MemberConstraintSet<'tcx, R>
 where
     R: Copy + Hash + Eq,
 {
     crate fn all_indices(
         &self,
-    ) -> impl Iterator<Item = NllPickConstraintIndex> {
+    ) -> impl Iterator<Item = NllMemberConstraintIndex> {
         self.constraints.indices()
     }
 
     /// Iterate down the constraint indices associated with a given
-    /// peek-region.  You can then use `option_regions` and other
+    /// peek-region.  You can then use `choice_regions` and other
     /// methods to access data.
     crate fn indices(
         &self,
-        pick_region_vid: R,
-    ) -> impl Iterator<Item = NllPickConstraintIndex> + '_ {
-        let mut next = self.first_constraints.get(&pick_region_vid).cloned();
-        std::iter::from_fn(move || -> Option<NllPickConstraintIndex> {
+        member_region_vid: R,
+    ) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ {
+        let mut next = self.first_constraints.get(&member_region_vid).cloned();
+        std::iter::from_fn(move || -> Option<NllMemberConstraintIndex> {
             if let Some(current) = next {
                 next = self.constraints[current].next_constraint;
                 Some(current)
@@ -165,25 +168,25 @@ impl<'tcx, R> PickConstraintSet<'tcx, R>
         })
     }
 
-    /// Returns the "option regions" for a given pick constraint. This is the R1..Rn from
-    /// a constraint like:
+    /// Returns the "choice regions" for a given member
+    /// constraint. This is the R1..Rn from a constraint like:
     ///
     /// ```
-    /// pick R0 in [R1..Rn]
+    /// R0 member of [R1..Rn]
     /// ```
-    crate fn option_regions(&self, pci: NllPickConstraintIndex) -> &[ty::RegionVid] {
-        let NllPickConstraint { start_index, end_index, .. } = &self.constraints[pci];
-        &self.option_regions[*start_index..*end_index]
+    crate fn choice_regions(&self, pci: NllMemberConstraintIndex) -> &[ty::RegionVid] {
+        let NllMemberConstraint { start_index, end_index, .. } = &self.constraints[pci];
+        &self.choice_regions[*start_index..*end_index]
     }
 }
 
-impl<'tcx, R> Index<NllPickConstraintIndex> for PickConstraintSet<'tcx, R>
+impl<'tcx, R> Index<NllMemberConstraintIndex> for MemberConstraintSet<'tcx, R>
 where
     R: Copy + Hash + Eq,
 {
-    type Output = NllPickConstraint<'tcx>;
+    type Output = NllMemberConstraint<'tcx>;
 
-    fn index(&self, i: NllPickConstraintIndex) -> &NllPickConstraint<'tcx> {
+    fn index(&self, i: NllMemberConstraintIndex) -> &NllMemberConstraint<'tcx> {
         &self.constraints[i]
     }
 }
@@ -205,9 +208,9 @@ fn index(&self, i: NllPickConstraintIndex) -> &NllPickConstraint<'tcx> {
 /// target_list: A -> B -> C -> D -> E -> F -> (None)
 /// ```
 fn append_list(
-    constraints: &mut IndexVec<NllPickConstraintIndex, NllPickConstraint<'_>>,
-    target_list: NllPickConstraintIndex,
-    source_list: NllPickConstraintIndex,
+    constraints: &mut IndexVec<NllMemberConstraintIndex, NllMemberConstraint<'_>>,
+    target_list: NllMemberConstraintIndex,
+    source_list: NllMemberConstraintIndex,
 ) {
     let mut p = target_list;
     loop {
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
index 34fd3427d326c771020be1f436576febee8d8ba1..b3649b2179fff2fbbd69bb977c042ecdb905b5f4 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
@@ -1,5 +1,5 @@
 use crate::borrow_check::nll::constraints::OutlivesConstraint;
-use crate::borrow_check::nll::region_infer::AppliedPickConstraint;
+use crate::borrow_check::nll::region_infer::AppliedMemberConstraint;
 use crate::borrow_check::nll::region_infer::RegionInferenceContext;
 use crate::borrow_check::nll::type_check::Locations;
 use crate::borrow_check::nll::universal_regions::DefiningTy;
@@ -224,13 +224,13 @@ fn find_constraint_paths_between_regions(
             // But pick-constraints can also give rise to `'r: 'x`
             // edges that were not part of the graph initially, so
             // watch out for those.
-            let outgoing_edges_from_picks = self.applied_pick_constraints(r)
+            let outgoing_edges_from_picks = self.applied_member_constraints(r)
                 .iter()
-                .map(|&AppliedPickConstraint { best_option, pick_constraint_index, .. }| {
-                    let p_c = &self.pick_constraints[pick_constraint_index];
+                .map(|&AppliedMemberConstraint { min_choice, member_constraint_index, .. }| {
+                    let p_c = &self.member_constraints[member_constraint_index];
                     OutlivesConstraint {
                         sup: r,
-                        sub: best_option,
+                        sub: min_choice,
                         locations: Locations::All(p_c.definition_span),
                         category: ConstraintCategory::OpaqueType,
                     }
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
index db519fad0d9e1054574a0f5ef7daea68cfe15323..78f6e731ce2442e476b72db873d21fa8c5b71a28 100644
--- a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
@@ -3,7 +3,7 @@
 use crate::borrow_check::nll::constraints::{
     ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet,
 };
-use crate::borrow_check::nll::pick_constraints::{PickConstraintSet, NllPickConstraintIndex};
+use crate::borrow_check::nll::member_constraints::{MemberConstraintSet, NllMemberConstraintIndex};
 use crate::borrow_check::nll::region_infer::values::{
     PlaceholderIndices, RegionElement, ToElementIndex,
 };
@@ -72,14 +72,14 @@ pub struct RegionInferenceContext<'tcx> {
     /// exists if `B: A`. Computed lazilly.
     rev_constraint_graph: Option<Rc<VecGraph<ConstraintSccIndex>>>,
 
-    /// The "pick R0 from [R1..Rn]" constraints, indexed by SCC.
-    pick_constraints: Rc<PickConstraintSet<'tcx, ConstraintSccIndex>>,
+    /// The "R0 member of [R1..Rn]" constraints, indexed by SCC.
+    member_constraints: Rc<MemberConstraintSet<'tcx, ConstraintSccIndex>>,
 
     /// Records the pick-constraints that we applied to each scc.
     /// This is useful for error reporting. Once constraint
     /// propagation is done, this vector is sorted according to
-    /// `pick_region_scc`.
-    pick_constraints_applied: Vec<AppliedPickConstraint>,
+    /// `member_region_scc`.
+    member_constraints_applied: Vec<AppliedMemberConstraint>,
 
     /// Map closure bounds to a `Span` that should be used for error reporting.
     closure_bounds_mapping:
@@ -116,30 +116,30 @@ pub struct RegionInferenceContext<'tcx> {
     universal_region_relations: Rc<UniversalRegionRelations<'tcx>>,
 }
 
-/// Each time that `apply_pick_constraint` is successful, it appends
-/// one of these structs to the `pick_constraints_applied` field.
+/// Each time that `apply_member_constraint` is successful, it appends
+/// one of these structs to the `member_constraints_applied` field.
 /// This is used in error reporting to trace out what happened.
 ///
-/// The way that `apply_pick_constraint` works is that it effectively
+/// The way that `apply_member_constraint` works is that it effectively
 /// adds a new lower bound to the SCC it is analyzing: so you wind up
 /// with `'R: 'O` where `'R` is the pick-region and `'O` is the
 /// minimal viable option.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
-struct AppliedPickConstraint {
-    /// The SCC that was affected. (The "pick region".)
+struct AppliedMemberConstraint {
+    /// The SCC that was affected. (The "member region".)
     ///
-    /// The vector if `AppliedPickConstraint` elements is kept sorted
+    /// The vector if `AppliedMemberConstraint` elements is kept sorted
     /// by this field.
-    pick_region_scc: ConstraintSccIndex,
+    member_region_scc: ConstraintSccIndex,
 
-    /// The "best option" that `apply_pick_constraint` found -- this was
-    /// added as an "ad-hoc" lower-bound to `pick_region_scc`.
-    best_option: ty::RegionVid,
+    /// The "best option" that `apply_member_constraint` found -- this was
+    /// added as an "ad-hoc" lower-bound to `member_region_scc`.
+    min_choice: ty::RegionVid,
 
-    /// The "pick constraint index" -- we can find out details about
+    /// The "member constraint index" -- we can find out details about
     /// the constraint from
-    /// `set.pick_constraints[pick_constraint_index]`.
-    pick_constraint_index: NllPickConstraintIndex,
+    /// `set.member_constraints[member_constraint_index]`.
+    member_constraint_index: NllMemberConstraintIndex,
 }
 
 struct RegionDefinition<'tcx> {
@@ -234,7 +234,7 @@ pub(crate) fn new(
         universal_region_relations: Rc<UniversalRegionRelations<'tcx>>,
         _body: &Body<'tcx>,
         outlives_constraints: OutlivesConstraintSet,
-        pick_constraints_in: PickConstraintSet<'tcx, RegionVid>,
+        member_constraints_in: MemberConstraintSet<'tcx, RegionVid>,
         closure_bounds_mapping: FxHashMap<
             Location,
             FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>,
@@ -266,7 +266,8 @@ pub(crate) fn new(
 
         let scc_representatives = Self::compute_scc_representatives(&constraint_sccs, &definitions);
 
-        let pick_constraints = Rc::new(pick_constraints_in.into_mapped(|r| constraint_sccs.scc(r)));
+        let member_constraints =
+            Rc::new(member_constraints_in.into_mapped(|r| constraint_sccs.scc(r)));
 
         let mut result = Self {
             definitions,
@@ -275,8 +276,8 @@ pub(crate) fn new(
             constraint_graph,
             constraint_sccs,
             rev_constraint_graph: None,
-            pick_constraints,
-            pick_constraints_applied: Vec::new(),
+            member_constraints,
+            member_constraints_applied: Vec::new(),
             closure_bounds_mapping,
             scc_universes,
             scc_representatives,
@@ -447,12 +448,12 @@ pub fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
 
     /// Once region solving has completed, this function will return
     /// the pick-constraints that were applied to the value of a given
-    /// region `r`. See `AppliedPickConstraint`.
-    fn applied_pick_constraints(&self, r: impl ToRegionVid) -> &[AppliedPickConstraint] {
+    /// region `r`. See `AppliedMemberConstraint`.
+    fn applied_member_constraints(&self, r: impl ToRegionVid) -> &[AppliedMemberConstraint] {
         let scc = self.constraint_sccs.scc(r.to_region_vid());
         binary_search_util::binary_search_slice(
-            &self.pick_constraints_applied,
-            |applied| applied.pick_region_scc,
+            &self.member_constraints_applied,
+            |applied| applied.member_region_scc,
             &scc,
         )
     }
@@ -511,7 +512,7 @@ fn solve_inner(
             errors_buffer,
         );
 
-        self.check_pick_constraints(infcx, mir_def_id, errors_buffer);
+        self.check_member_constraints(infcx, mir_def_id, errors_buffer);
 
         let outlives_requirements = outlives_requirements.unwrap_or(vec![]);
 
@@ -548,9 +549,9 @@ fn propagate_constraints(&mut self, _body: &Body<'tcx>) {
             self.propagate_constraint_sccs_if_new(scc_index, visited);
         }
 
-        // Sort the applied pick constraints so we can binary search
+        // Sort the applied member constraints so we can binary search
         // through them later.
-        self.pick_constraints_applied.sort_by_key(|applied| applied.pick_region_scc);
+        self.member_constraints_applied.sort_by_key(|applied| applied.member_region_scc);
     }
 
     /// Computes the value of the SCC `scc_a` if it has not already
@@ -597,13 +598,13 @@ fn propagate_constraint_sccs_new(
             }
         }
 
-        // Now take pick constraints into account
-        let pick_constraints = self.pick_constraints.clone();
-        for p_c_i in pick_constraints.indices(scc_a) {
-            self.apply_pick_constraint(
+        // Now take member constraints into account
+        let member_constraints = self.member_constraints.clone();
+        for m_c_i in member_constraints.indices(scc_a) {
+            self.apply_member_constraint(
                 scc_a,
-                p_c_i,
-                pick_constraints.option_regions(p_c_i),
+                m_c_i,
+                member_constraints.choice_regions(m_c_i),
             );
         }
 
@@ -614,9 +615,9 @@ fn propagate_constraint_sccs_new(
         );
     }
 
-    /// Invoked for each `pick R0 from [R1..Rn]` constraint.
+    /// Invoked for each `member R0 of [R1..Rn]` constraint.
     ///
-    /// `scc` is the SCC containing R0, and `option_regions` are the
+    /// `scc` is the SCC containing R0, and `choice_regions` are the
     /// `R1..Rn` regions -- they are always known to be universal
     /// regions (and if that's not true, we just don't attempt to
     /// enforce the constraint).
@@ -625,34 +626,34 @@ fn propagate_constraint_sccs_new(
     /// is considered a *lower bound*.  If possible, we will modify
     /// the constraint to set it equal to one of the option regions.
     /// If we make any changes, returns true, else false.
-    fn apply_pick_constraint(
+    fn apply_member_constraint(
         &mut self,
         scc: ConstraintSccIndex,
-        pick_constraint_index: NllPickConstraintIndex,
-        option_regions: &[ty::RegionVid],
+        member_constraint_index: NllMemberConstraintIndex,
+        choice_regions: &[ty::RegionVid],
     ) -> bool {
-        debug!("apply_pick_constraint(scc={:?}, option_regions={:#?})", scc, option_regions,);
+        debug!("apply_member_constraint(scc={:?}, choice_regions={:#?})", scc, choice_regions,);
 
         if let Some(uh_oh) =
-            option_regions.iter().find(|&&r| !self.universal_regions.is_universal_region(r))
+            choice_regions.iter().find(|&&r| !self.universal_regions.is_universal_region(r))
         {
             // FIXME(#61773): This case can only occur with
             // `impl_trait_in_bindings`, I believe, and we are just
             // opting not to handle it for now. See #61773 for
             // details.
             bug!(
-                "pick constraint for `{:?}` has an option region `{:?}` \
+                "member constraint for `{:?}` has an option region `{:?}` \
                  that is not a universal region",
-                self.pick_constraints[pick_constraint_index].opaque_type_def_id,
+                self.member_constraints[member_constraint_index].opaque_type_def_id,
                 uh_oh,
             );
         }
 
         // Create a mutable vector of the options. We'll try to winnow
         // them down.
-        let mut option_regions: Vec<ty::RegionVid> = option_regions.to_vec();
+        let mut choice_regions: Vec<ty::RegionVid> = choice_regions.to_vec();
 
-        // The 'pick-region' in a pick-constraint is part of the
+        // The 'member region' in a member constraint is part of the
         // hidden type, which must be in the root universe. Therefore,
         // it cannot have any placeholders in its value.
         assert!(self.scc_universes[scc] == ty::UniverseIndex::ROOT);
@@ -665,35 +666,37 @@ fn apply_pick_constraint(
 
         // The existing value for `scc` is a lower-bound. This will
         // consist of some set {P} + {LB} of points {P} and
-        // lower-bound free regions {LB}. As each option region O is a
+        // lower-bound free regions {LB}. As each choice region O is a
         // free region, it will outlive the points. But we can only
         // consider the option O if O: LB.
-        option_regions.retain(|&o_r| {
+        choice_regions.retain(|&o_r| {
             self.scc_values
                 .universal_regions_outlived_by(scc)
                 .all(|lb| self.universal_region_relations.outlives(o_r, lb))
         });
-        debug!("apply_pick_constraint: after lb, option_regions={:?}", option_regions);
+        debug!("apply_member_constraint: after lb, choice_regions={:?}", choice_regions);
 
-        // Now find all the *upper bounds* -- that is, each UB is a free
-        // region that must outlive pick region R0 (`UB: R0`). Therefore,
-        // we need only keep an option O if `UB: O` for all UB.
-        if option_regions.len() > 1 {
+        // Now find all the *upper bounds* -- that is, each UB is a
+        // free region that must outlive the member region R0 (`UB:
+        // R0`). Therefore, we need only keep an option O if `UB: O`
+        // for all UB.
+        if choice_regions.len() > 1 {
             let universal_region_relations = self.universal_region_relations.clone();
             for ub in self.upper_bounds(scc) {
-                debug!("apply_pick_constraint: ub={:?}", ub);
-                option_regions.retain(|&o_r| universal_region_relations.outlives(ub, o_r));
+                debug!("apply_member_constraint: ub={:?}", ub);
+                choice_regions.retain(|&o_r| universal_region_relations.outlives(ub, o_r));
             }
-            debug!("apply_pick_constraint: after ub, option_regions={:?}", option_regions);
+            debug!("apply_member_constraint: after ub, choice_regions={:?}", choice_regions);
         }
 
         // If we ruled everything out, we're done.
-        if option_regions.is_empty() {
+        if choice_regions.is_empty() {
             return false;
         }
 
-        // Otherwise, we need to find the minimum option, if any, and take that.
-        debug!("apply_pick_constraint: option_regions remaining are {:#?}", option_regions);
+        // Otherwise, we need to find the minimum remaining choice, if
+        // any, and take that.
+        debug!("apply_member_constraint: choice_regions remaining are {:#?}", choice_regions);
         let min = |r1: ty::RegionVid, r2: ty::RegionVid| -> Option<ty::RegionVid> {
             let r1_outlives_r2 = self.universal_region_relations.outlives(r1, r2);
             let r2_outlives_r1 = self.universal_region_relations.outlives(r2, r1);
@@ -707,35 +710,35 @@ fn apply_pick_constraint(
                 None
             }
         };
-        let mut best_option = option_regions[0];
-        for &other_option in &option_regions[1..] {
+        let mut min_choice = choice_regions[0];
+        for &other_option in &choice_regions[1..] {
             debug!(
-                "apply_pick_constraint: best_option={:?} other_option={:?}",
-                best_option, other_option,
+                "apply_member_constraint: min_choice={:?} other_option={:?}",
+                min_choice, other_option,
             );
-            match min(best_option, other_option) {
-                Some(m) => best_option = m,
+            match min(min_choice, other_option) {
+                Some(m) => min_choice = m,
                 None => {
                     debug!(
-                        "apply_pick_constraint: {:?} and {:?} are incomparable --> no best choice",
-                        best_option, other_option,
+                        "apply_member_constraint: {:?} and {:?} are incomparable; no min choice",
+                        min_choice, other_option,
                     );
                     return false;
                 }
             }
         }
 
-        let best_option_scc = self.constraint_sccs.scc(best_option);
+        let min_choice_scc = self.constraint_sccs.scc(min_choice);
         debug!(
-            "apply_pick_constraint: best_choice={:?} best_option_scc={:?}",
-            best_option,
-            best_option_scc,
+            "apply_member_constraint: min_choice={:?} best_choice_scc={:?}",
+            min_choice,
+            min_choice_scc,
         );
-        if self.scc_values.add_region(scc, best_option_scc) {
-            self.pick_constraints_applied.push(AppliedPickConstraint {
-                pick_region_scc: scc,
-                best_option,
-                pick_constraint_index,
+        if self.scc_values.add_region(scc, min_choice_scc) {
+            self.member_constraints_applied.push(AppliedMemberConstraint {
+                member_region_scc: scc,
+                min_choice,
+                member_constraint_index,
             });
 
             true
@@ -1542,42 +1545,42 @@ fn check_bound_universal_region(
         diag.emit();
     }
 
-    fn check_pick_constraints(
+    fn check_member_constraints(
         &self,
         infcx: &InferCtxt<'_, 'tcx>,
         mir_def_id: DefId,
         errors_buffer: &mut Vec<Diagnostic>,
     ) {
-        let pick_constraints = self.pick_constraints.clone();
-        for p_c_i in pick_constraints.all_indices() {
-            debug!("check_pick_constraint(p_c_i={:?})", p_c_i);
-            let p_c = &pick_constraints[p_c_i];
-            let pick_region_vid = p_c.pick_region_vid;
+        let member_constraints = self.member_constraints.clone();
+        for m_c_i in member_constraints.all_indices() {
+            debug!("check_member_constraint(m_c_i={:?})", m_c_i);
+            let m_c = &member_constraints[m_c_i];
+            let member_region_vid = m_c.member_region_vid;
             debug!(
-                "check_pick_constraint: pick_region_vid={:?} with value {}",
-                pick_region_vid,
-                self.region_value_str(pick_region_vid),
+                "check_member_constraint: member_region_vid={:?} with value {}",
+                member_region_vid,
+                self.region_value_str(member_region_vid),
             );
-            let option_regions = pick_constraints.option_regions(p_c_i);
-            debug!("check_pick_constraint: option_regions={:?}", option_regions);
+            let choice_regions = member_constraints.choice_regions(m_c_i);
+            debug!("check_member_constraint: choice_regions={:?}", choice_regions);
 
             // did the pick-region wind up equal to any of the option regions?
-            if let Some(o) = option_regions.iter().find(|&&o_r| {
-                self.eval_equal(o_r, p_c.pick_region_vid)
+            if let Some(o) = choice_regions.iter().find(|&&o_r| {
+                self.eval_equal(o_r, m_c.member_region_vid)
             }) {
-                debug!("check_pick_constraint: evaluated as equal to {:?}", o);
+                debug!("check_member_constraint: evaluated as equal to {:?}", o);
                 continue;
             }
 
             // if not, report an error
             let region_scope_tree = &infcx.tcx.region_scope_tree(mir_def_id);
-            let pick_region = infcx.tcx.mk_region(ty::ReVar(pick_region_vid));
+            let member_region = infcx.tcx.mk_region(ty::ReVar(member_region_vid));
             opaque_types::unexpected_hidden_region_diagnostic(
                 infcx.tcx,
                 Some(region_scope_tree),
-                p_c.opaque_type_def_id,
-                p_c.hidden_ty,
-                pick_region,
+                m_c.opaque_type_def_id,
+                m_c.hidden_ty,
+                member_region,
             )
             .buffer(errors_buffer);
         }
diff --git a/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs b/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs
index e7ae9de3c2e6c40e2f7037f2556937136ee25c4c..8de014522dea76ed302922d7f77baf84da1fc47e 100644
--- a/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs
+++ b/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs
@@ -53,20 +53,23 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
     pub(super) fn convert_all(&mut self, query_constraints: &QueryRegionConstraints<'tcx>) {
         debug!("convert_all(query_constraints={:#?})", query_constraints);
 
-        let QueryRegionConstraints { outlives, pick_constraints } = query_constraints;
+        let QueryRegionConstraints { outlives, member_constraints } = query_constraints;
 
         // Annoying: to invoke `self.to_region_vid`, we need access to
         // `self.constraints`, but we also want to be mutating
-        // `self.pick_constraints`. For now, just swap out the value
+        // `self.member_constraints`. For now, just swap out the value
         // we want and replace at the end.
-        let mut tmp = std::mem::replace(&mut self.constraints.pick_constraints, Default::default());
-        for pick_constraint in pick_constraints {
+        let mut tmp = std::mem::replace(
+            &mut self.constraints.member_constraints,
+            Default::default(),
+        );
+        for member_constraint in member_constraints {
             tmp.push_constraint(
-                pick_constraint,
+                member_constraint,
                 |r| self.to_region_vid(r),
             );
         }
-        self.constraints.pick_constraints = tmp;
+        self.constraints.member_constraints = tmp;
 
         for query_constraint in outlives {
             self.convert(query_constraint);
diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
index 09f9b5510d0db7ec223a493592be55ced4c513a6..2cdd1363cdf963f392d188f6c4fc0d8241c5b160 100644
--- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
@@ -5,7 +5,7 @@
 use crate::borrow_check::borrow_set::BorrowSet;
 use crate::borrow_check::location::LocationTable;
 use crate::borrow_check::nll::constraints::{OutlivesConstraintSet, OutlivesConstraint};
-use crate::borrow_check::nll::pick_constraints::PickConstraintSet;
+use crate::borrow_check::nll::member_constraints::MemberConstraintSet;
 use crate::borrow_check::nll::facts::AllFacts;
 use crate::borrow_check::nll::region_infer::values::LivenessValues;
 use crate::borrow_check::nll::region_infer::values::PlaceholderIndex;
@@ -129,7 +129,7 @@ pub(crate) fn type_check<'tcx>(
         placeholder_index_to_region: IndexVec::default(),
         liveness_constraints: LivenessValues::new(elements.clone()),
         outlives_constraints: OutlivesConstraintSet::default(),
-        pick_constraints: PickConstraintSet::default(),
+        member_constraints: MemberConstraintSet::default(),
         closure_bounds_mapping: Default::default(),
         type_tests: Vec::default(),
     };
@@ -889,7 +889,7 @@ struct BorrowCheckContext<'a, 'tcx> {
 
     crate outlives_constraints: OutlivesConstraintSet,
 
-    crate pick_constraints: PickConstraintSet<'tcx, RegionVid>,
+    crate member_constraints: MemberConstraintSet<'tcx, RegionVid>,
 
     crate closure_bounds_mapping:
         FxHashMap<Location, FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>>,
@@ -2525,7 +2525,7 @@ fn prove_closure_bounds(
                 // constraints only come from `-> impl Trait` and
                 // friends which don't appear (thus far...) in
                 // closures.
-                pick_constraints: vec![],
+                member_constraints: vec![],
             };
 
             let bounds_mapping = closure_constraints