introduce AstConv::probe_adt

Author: aliemjay

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -108,9 +108,12 @@ pub trait AstConv<'tcx> {
         poly_trait_ref: ty::PolyTraitRef<'tcx>,
     ) -> Ty<'tcx>;
 
-    fn normalize_ty_2(&self, _span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
-        ty
-    }
+    /// Returns `AdtDef` if `ty` is an ADT.
+    /// Note that `ty` might be a projection type that needs normalization.
+    /// This used to get the enum variants in scope of the type.
+    /// For example, `Self::A` could refer to an associated type
+    /// or to an enum variant depending on the result of this function.
+    fn probe_adt(&self, span: Span, ty: Ty<'tcx>) -> Option<ty::AdtDef<'tcx>>;
 
     /// Invoked when we encounter an error from some prior pass
     /// (e.g., resolve) that is translated into a ty-error. This is
@@ -1811,7 +1814,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         // Check if we have an enum variant.
         let mut variant_resolution = None;
-        if let ty::Adt(adt_def, _) = self.normalize_ty_2(span, qself_ty).kind() {
+        if let Some(adt_def) = self.probe_adt(span, qself_ty) {
             if adt_def.is_enum() {
                 let variant_def = adt_def
                     .variants()
@@ -2263,6 +2266,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         self_ty: Option<Ty<'tcx>>,
         kind: DefKind,
         def_id: DefId,
+        span: Span,
     ) -> Vec<PathSeg> {
         // We need to extract the type parameters supplied by the user in
         // the path `path`. Due to the current setup, this is a bit of a
@@ -2330,8 +2334,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
             // Case 2. Reference to a variant constructor.
             DefKind::Ctor(CtorOf::Variant, ..) | DefKind::Variant => {
-                let adt_def = self_ty.map(|t| t.ty_adt_def().unwrap());
-                let (generics_def_id, index) = if let Some(adt_def) = adt_def {
+                let (generics_def_id, index) = if let Some(self_ty) = self_ty {
+                    let adt_def = self.probe_adt(span, self_ty).unwrap();
                     debug_assert!(adt_def.is_enum());
                     (adt_def.did(), last)
                 } else if last >= 1 && segments[last - 1].args.is_some() {
@@ -2428,7 +2432,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 assert_eq!(opt_self_ty, None);
 
                 let path_segs =
-                    self.def_ids_for_value_path_segments(path.segments, None, kind, def_id);
+                    self.def_ids_for_value_path_segments(path.segments, None, kind, def_id, span);
                 let generic_segs: FxHashSet<_> =
                     path_segs.iter().map(|PathSeg(_, index)| index).collect();
                 self.prohibit_generics(

compiler/rustc_hir_analysis/src/collect.rs

@@ -513,6 +513,12 @@ impl<'tcx> AstConv<'tcx> for ItemCtxt<'tcx> {
         }
     }
 
+    fn probe_adt(&self, _span: Span, ty: Ty<'tcx>) -> Option<ty::AdtDef<'tcx>> {
+        // FIXME(aliemjay): We should handle the case where `ty` is a projection,
+        // but we currently don't. See #103640.
+        ty.ty_adt_def()
+    }
+
     fn set_tainted_by_errors(&self, _: ErrorGuaranteed) {
         // There's no obvious place to track this, so just let it go.
     }

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1059,9 +1059,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             Res::Def(kind, def_id) => <dyn AstConv<'_>>::def_ids_for_value_path_segments(
                 self,
                 segments,
-                self_ty.map(|ty| ty.normalized),
+                self_ty.map(|ty| ty.raw),
                 kind,
                 def_id,
+                span,
             ),
             _ => bug!("instantiate_value_path on {:?}", res),
         };
@@ -1174,7 +1175,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .unwrap_or(false);
 
         let (res, self_ctor_substs) = if let Res::SelfCtor(impl_def_id) = res {
-            let ty = self.normalize_ty_2(span, tcx.at(span).type_of(impl_def_id));
+            let ty = tcx.at(span).type_of(impl_def_id);
+            let ty = self.normalize_associated_types_in(span, ty);
             match *ty.kind() {
                 ty::Adt(adt_def, substs) if adt_def.has_ctor() => {
                     let variant = adt_def.non_enum_variant();
@@ -1297,10 +1299,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             // If we have a default, then we it doesn't matter that we're not
                             // inferring the type arguments: we provide the default where any
                             // is missing.
-                            let default = tcx.bound_type_of(param.def_id);
-                            self.fcx
-                                .normalize_ty_2(self.span, default.subst(tcx, substs.unwrap()))
-                                .into()
+                            let default =
+                                tcx.bound_type_of(param.def_id).subst(tcx, substs.unwrap());
+                            self.fcx.normalize_associated_types_in(self.span, default).into()
                         } else {
                             // If no type arguments were provided, we have to infer them.
                             // This case also occurs as a result of some malformed input, e.g.

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -17,7 +17,7 @@ use rustc_infer::infer::error_reporting::TypeErrCtxt;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
 use rustc_middle::ty::subst::GenericArgKind;
-use rustc_middle::ty::{self, Const, Ty, TyCtxt};
+use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitable};
 use rustc_session::Session;
 use rustc_span::symbol::Ident;
 use rustc_span::{self, Span};
@@ -281,12 +281,15 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
         self.tcx().mk_projection(item_def_id, item_substs)
     }
 
-    fn normalize_ty_2(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
-        use rustc_middle::ty::TypeVisitable;
-        if ty.has_escaping_bound_vars() {
-            ty // FIXME: normalization and escaping regions
-        } else {
-            self.normalize_associated_types_in(span, ty)
+    fn probe_adt(&self, span: Span, ty: Ty<'tcx>) -> Option<ty::AdtDef<'tcx>> {
+        match ty.kind() {
+            ty::Adt(adt_def, _) => Some(*adt_def),
+            // FIXME: We should normalize even with escaping bound vars.
+            // See test/ui/associated-types/bound-region-variant-resolution.rs
+            ty::Projection(_) if !ty.has_escaping_bound_vars() => {
+                self.normalize_associated_types_in(span, ty).ty_adt_def()
+            }
+            _ => None,
         }
     }
 
@@ -295,7 +298,11 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
     }
 
     fn record_ty(&self, hir_id: hir::HirId, ty: Ty<'tcx>, span: Span) {
-        self.write_ty(hir_id, self.normalize_ty_2(span, ty))
+        let ty_normalized = match ty.has_escaping_bound_vars() {
+            false => self.normalize_associated_types_in(span, ty),
+            true => ty, // FIXME: normalization and escaping regions
+        };
+        self.write_ty(hir_id, ty_normalized)
     }
 }
 

src/test/ui/associated-types/bound-region-variant-resolution.rs

@@ -0,0 +1,15 @@
+// This is a bug!
+// We should emit the same error message regardless of
+// whether the projection type contains bound regions.
+
+// check-fail
+
+fn test<'x>() {
+    use std::ops::Deref;
+    None::<for<'y> fn(<&'x Option<()> as Deref>::Target::Some)>;
+    //~^ ERROR expected type, found variant
+    None::<for<'y> fn(<&'y Option<()> as Deref>::Target::Some)>;
+    //~^ ERROR ambiguous associated type
+}
+
+fn main() {}

src/test/ui/associated-types/bound-region-variant-resolution.stderr

@@ -0,0 +1,15 @@
+error: expected type, found variant `Some`
+  --> $DIR/bound-region-variant-resolution.rs:9:23
+   |
+LL |     None::<for<'y> fn(<&'x Option<()> as Deref>::Target::Some)>;
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0223]: ambiguous associated type
+  --> $DIR/bound-region-variant-resolution.rs:11:23
+   |
+LL |     None::<for<'y> fn(<&'y Option<()> as Deref>::Target::Some)>;
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use fully-qualified syntax: `<<&'y Option<()> as Deref>::Target as Trait>::Some`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0223`.