Treat ExprKind::Path and ExprKind::Struct the same for the purposes of path checking

Author: estebank

src/librustc_ast_lowering/path.rs

@@ -31,6 +31,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err));
 
         let proj_start = p.segments.len() - partial_res.unresolved_segments();
+        let mut type_param_in_enum = false;
         let path = self.arena.alloc(hir::Path {
             res: self.lower_res(partial_res.base_res()),
             segments: self.arena.alloc_from_iter(p.segments[..proj_start].iter().enumerate().map(
@@ -55,7 +56,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         Res::Def(DefKind::AssocTy, def_id) if i + 2 == proj_start => {
                             Some(parent_def_id(self, def_id))
                         }
-                        Res::Def(DefKind::Variant, def_id) if i + 1 == proj_start => {
+                        Res::Def(DefKind::Variant, def_id)
+                            if i + 2 == proj_start && segment.args.is_some() =>
+                        {
+                            // Handle `Enum::<Param>::Variant {}`.
+                            // We need to choose one here so that the method `res_to_ty` in
+                            // `astconv` works correctly, but it has to be *only* one, so track
+                            // whether we've already set the `DefId` in the previous segment.
+                            type_param_in_enum = true;
+                            Some(parent_def_id(self, def_id))
+                        }
+                        Res::Def(DefKind::Variant, def_id)
+                            if i + 1 == proj_start
+                                && (segment.args.is_some() || !type_param_in_enum) =>
+                        {
+                            // Handle `Enum::Variant::<Param> {}`.
                             Some(parent_def_id(self, def_id))
                         }
                         Res::Def(DefKind::Struct, def_id)

src/librustc_error_codes/error_codes/E0109.md

@@ -17,6 +17,6 @@ type X = u32; // ok!
 type Y = bool; // ok!
 ```
 
-Note that generic arguments for enum variant constructors go after the variant,
-not after the enum. For example, you would write `Option::None::<u32>`,
-rather than `Option::<u32>::None`.
+Note that generic arguments for enum variant constructors can go after the
+variant or after the enum. For example, you can write `Option::None::<u32>`,
+rather than `Option::<u32>::None`, but the later style is preferred.

src/librustc_typeck/astconv.rs

@@ -125,8 +125,8 @@ enum ConvertedBindingKind<'a, 'tcx> {
     Constraint(&'a [hir::GenericBound<'a>]),
 }
 
-#[derive(PartialEq)]
-enum GenericArgPosition {
+#[derive(PartialEq, Debug)]
+pub enum GenericArgPosition {
     Type,
     Value, // e.g., functions
     MethodCall,
@@ -195,6 +195,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         span: Span,
         def_id: DefId,
         item_segment: &hir::PathSegment<'_>,
+        generic_arg_position: GenericArgPosition,
     ) -> SubstsRef<'tcx> {
         let (substs, assoc_bindings, _) = self.create_substs_for_ast_path(
             span,
@@ -203,6 +204,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             item_segment.generic_args(),
             item_segment.infer_args,
             None,
+            generic_arg_position,
         );
 
         assoc_bindings.first().map(|b| Self::prohibit_assoc_ty_binding(self.tcx(), b.span));
@@ -630,6 +632,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         generic_args: &'a hir::GenericArgs<'_>,
         infer_args: bool,
         self_ty: Option<Ty<'tcx>>,
+        generic_arg_position: GenericArgPosition,
     ) -> (SubstsRef<'tcx>, Vec<ConvertedBinding<'a, 'tcx>>, Option<Vec<Span>>) {
         // If the type is parameterized by this region, then replace this
         // region with the current anon region binding (in other words,
@@ -661,7 +664,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             span,
             &generic_params,
             &generic_args,
-            GenericArgPosition::Type,
+            generic_arg_position,
             self_ty.is_some(),
             infer_args,
         );
@@ -804,6 +807,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         item_def_id: DefId,
         item_segment: &hir::PathSegment<'_>,
         parent_substs: SubstsRef<'tcx>,
+        generic_arg_position: GenericArgPosition,
     ) -> SubstsRef<'tcx> {
         if tcx.generics_of(item_def_id).params.is_empty() {
             self.prohibit_generics(slice::from_ref(item_segment));
@@ -817,6 +821,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 item_segment.generic_args(),
                 item_segment.infer_args,
                 None,
+                generic_arg_position,
             )
             .0
         }
@@ -1100,6 +1105,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             trait_segment.generic_args(),
             trait_segment.infer_args,
             Some(self_ty),
+            GenericArgPosition::Type,
         )
     }
 
@@ -1416,8 +1422,9 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         span: Span,
         did: DefId,
         item_segment: &hir::PathSegment<'_>,
+        generic_arg_position: GenericArgPosition,
     ) -> Ty<'tcx> {
-        let substs = self.ast_path_substs_for_ty(span, did, item_segment);
+        let substs = self.ast_path_substs_for_ty(span, did, item_segment, generic_arg_position);
         self.normalize_ty(span, self.tcx().at(span).type_of(did).subst(self.tcx(), substs))
     }
 
@@ -2253,6 +2260,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         item_def_id: DefId,
         trait_segment: &hir::PathSegment<'_>,
         item_segment: &hir::PathSegment<'_>,
+        generic_arg_position: GenericArgPosition,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
 
@@ -2305,13 +2313,36 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             item_def_id,
             item_segment,
             trait_ref.substs,
+            generic_arg_position,
         );
 
         debug!("qpath_to_ty: trait_ref={:?}", trait_ref);
 
         self.normalize_ty(span, tcx.mk_projection(item_def_id, item_substs))
     }
 
+    pub fn prohibit_multiple_params<'a, T: IntoIterator<Item = &'a hir::PathSegment<'a>>>(
+        &self,
+        segments: T,
+    ) -> bool {
+        let segments_with_params = segments
+            .into_iter()
+            .filter_map(|segment| segment.args.map(|_| segment.ident.span))
+            .collect::<Vec<_>>();
+        if segments_with_params.len() <= 1 {
+            return false;
+        }
+        self.tcx()
+            .sess
+            .struct_span_err(
+                segments_with_params,
+                "multiple segments with type parameters are not allowed",
+            )
+            .note("only a single path segment can specify type parameters")
+            .emit();
+        true
+    }
+
     pub fn prohibit_generics<'a, T: IntoIterator<Item = &'a hir::PathSegment<'a>>>(
         &self,
         segments: T,
@@ -2509,13 +2540,13 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         &self,
         opt_self_ty: Option<Ty<'tcx>>,
         path: &hir::Path<'_>,
-        permit_variants: bool,
+        generic_arg_position: GenericArgPosition,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
 
         debug!(
-            "res_to_ty(res={:?}, opt_self_ty={:?}, path_segments={:?})",
-            path.res, opt_self_ty, path.segments
+            "res_to_ty(res={:?}, opt_self_ty={:?}, path_segments={:?} generic_arg_pos={:?})",
+            path.res, opt_self_ty, path.segments, generic_arg_position
         );
 
         let span = path.span;
@@ -2525,7 +2556,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 assert!(ty::is_impl_trait_defn(tcx, did).is_none());
                 let item_segment = path.segments.split_last().unwrap();
                 self.prohibit_generics(item_segment.1);
-                let substs = self.ast_path_substs_for_ty(span, did, item_segment.0);
+                let substs =
+                    self.ast_path_substs_for_ty(span, did, item_segment.0, generic_arg_position);
                 self.normalize_ty(span, tcx.mk_opaque(did, substs))
             }
             Res::Def(DefKind::Enum, did)
@@ -2535,9 +2567,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             | Res::Def(DefKind::ForeignTy, did) => {
                 assert_eq!(opt_self_ty, None);
                 self.prohibit_generics(path.segments.split_last().unwrap().1);
-                self.ast_path_to_ty(span, did, path.segments.last().unwrap())
+                self.ast_path_to_ty(span, did, path.segments.last().unwrap(), generic_arg_position)
             }
-            Res::Def(kind @ DefKind::Variant, def_id) if permit_variants => {
+            Res::Def(kind @ DefKind::Variant, def_id)
+                if generic_arg_position == GenericArgPosition::Value =>
+            {
                 // Convert "variant type" as if it were a real type.
                 // The resulting `Ty` is type of the variant's enum for now.
                 assert_eq!(opt_self_ty, None);
@@ -2546,14 +2580,17 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     self.def_ids_for_value_path_segments(&path.segments, None, kind, def_id);
                 let generic_segs: FxHashSet<_> =
                     path_segs.iter().map(|PathSeg(_, index)| index).collect();
-                self.prohibit_generics(path.segments.iter().enumerate().filter_map(
-                    |(index, seg)| {
-                        if !generic_segs.contains(&index) { Some(seg) } else { None }
-                    },
-                ));
+
+                if !self.prohibit_multiple_params(path.segments.iter()) {
+                    self.prohibit_generics(path.segments.iter().enumerate().filter_map(
+                        |(index, seg)| {
+                            if !generic_segs.contains(&index) { Some(seg) } else { None }
+                        },
+                    ));
+                }
 
                 let PathSeg(def_id, index) = path_segs.last().unwrap();
-                self.ast_path_to_ty(span, *def_id, &path.segments[*index])
+                self.ast_path_to_ty(span, *def_id, &path.segments[*index], generic_arg_position)
             }
             Res::Def(DefKind::TyParam, def_id) => {
                 assert_eq!(opt_self_ty, None);
@@ -2588,6 +2625,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                     def_id,
                     &path.segments[path.segments.len() - 2],
                     path.segments.last().unwrap(),
+                    generic_arg_position,
                 )
             }
             Res::PrimTy(prim_ty) => {
@@ -2642,7 +2680,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             hir::TyKind::Path(hir::QPath::Resolved(ref maybe_qself, ref path)) => {
                 debug!("ast_ty_to_ty: maybe_qself={:?} path={:?}", maybe_qself, path);
                 let opt_self_ty = maybe_qself.as_ref().map(|qself| self.ast_ty_to_ty(qself));
-                self.res_to_ty(opt_self_ty, path, false)
+                self.res_to_ty(opt_self_ty, path, GenericArgPosition::Type)
             }
             hir::TyKind::Def(item_id, ref lifetimes) => {
                 let did = tcx.hir().local_def_id(item_id.id);

src/librustc_typeck/check/mod.rs

@@ -87,7 +87,7 @@ mod upvar;
 mod wfcheck;
 pub mod writeback;
 
-use crate::astconv::{AstConv, PathSeg};
+use crate::astconv::{AstConv, GenericArgPosition, PathSeg};
 use crate::middle::lang_items;
 use rustc::hir::map::blocks::FnLikeNode;
 use rustc::hir::map::Map;
@@ -2787,6 +2787,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
             item_def_id,
             item_segment,
             trait_ref.substs,
+            GenericArgPosition::Type,
         );
 
         self.tcx().mk_projection(item_def_id, item_substs)
@@ -4381,7 +4382,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         match *qpath {
             QPath::Resolved(ref maybe_qself, ref path) => {
                 let self_ty = maybe_qself.as_ref().map(|qself| self.to_ty(qself));
-                let ty = AstConv::res_to_ty(self, self_ty, path, true);
+                let ty = AstConv::res_to_ty(self, self_ty, path, GenericArgPosition::Value);
                 (path.res, ty)
             }
             QPath::TypeRelative(ref qself, ref segment) => {

src/librustc_typeck/collect.rs

@@ -14,7 +14,7 @@
 //! At present, however, we do run collection across all items in the
 //! crate as a kind of pass. This should eventually be factored away.
 
-use crate::astconv::{AstConv, Bounds, SizedByDefault};
+use crate::astconv::{AstConv, Bounds, GenericArgPosition, SizedByDefault};
 use crate::check::intrinsic::intrinsic_operation_unsafety;
 use crate::constrained_generic_params as cgp;
 use crate::lint;
@@ -349,6 +349,7 @@ impl AstConv<'tcx> for ItemCtxt<'tcx> {
                 item_def_id,
                 item_segment,
                 trait_ref.substs,
+                GenericArgPosition::Type,
             );
             self.tcx().mk_projection(item_def_id, item_substs)
         } else {

src/test/ui/enum/lifetime-in-def-not-in-path-issue-69356.rs

@@ -0,0 +1,24 @@
+// check-pass
+
+pub enum Foo<'a, T: 'a> {
+    Struct {},
+    Tuple(),
+    Unit,
+    Usage(&'a T),
+}
+
+pub fn main() {
+    let _ = Foo::<String>::Unit;
+    let _ = Foo::<String>::Tuple();
+    let _ = Foo::<String>::Struct {};
+    if let Foo::<String>::Unit = Foo::<String>::Unit {}
+    if let Foo::<String>::Tuple() = Foo::<String>::Tuple() {}
+    if let Foo::<String>::Struct {} = (Foo::<String>::Struct {}) {}
+    // // FIXME: these should be linted against.
+    let _ = Foo::Unit::<String>;
+    let _ = Foo::Tuple::<String>();
+    let _ = Foo::Struct::<String> {};
+    if let Foo::Unit::<String> = Foo::Unit::<String> {}
+    if let Foo::Tuple::<String>() = Foo::Tuple::<String>() {}
+    if let Foo::Struct::<String> {} = (Foo::Struct::<String> {}) {}
+}

src/test/ui/nll/user-annotations/pattern_substs_on_brace_enum_variant.rs

@@ -3,19 +3,48 @@ enum Foo<'a> {
 }
 
 fn in_let() {
+   let y = 22;
+   let foo = Foo::Bar { field: &y };
+   //~^ ERROR `y` does not live long enough
+   let Foo::Bar::<'static> { field: _z } = foo;
+}
+
+fn in_match() {
+   let y = 22;
+   let foo = Foo::Bar { field: &y };
+   //~^ ERROR `y` does not live long enough
+   match foo {
+       Foo::Bar::<'static> { field: _z } => {}
+   }
+}
+
+fn in_let_2() {
+   let y = 22;
+   let foo = Foo::Bar { field: &y };
+   //~^ ERROR `y` does not live long enough
+   let Foo::<'static>::Bar { field: _z } = foo;
+}
+
+fn in_match_2() {
+   let y = 22;
+   let foo = Foo::Bar { field: &y };
+   //~^ ERROR `y` does not live long enough
+   match foo {
+       Foo::<'static>::Bar { field: _z } => {}
+   }
+}
+
+fn in_let_3() {
     let y = 22;
     let foo = Foo::Bar { field: &y };
-    //~^ ERROR `y` does not live long enough
-    let Foo::Bar::<'static> { field: _z } = foo;
+    let Foo::Bar { field: _z } = foo;
 }
 
-fn in_match() {
+fn in_match_3() {
     let y = 22;
     let foo = Foo::Bar { field: &y };
-    //~^ ERROR `y` does not live long enough
     match foo {
-        Foo::Bar::<'static> { field: _z } => {
-        }
+        Foo::Bar { field: _z } => {}
     }
 }