Make sure places where Generics::own_counts was called took consts into account

yodaldevoid · varkor · varkor · commit 2bcc43cd1308 · 2018-08-23T18:48:46.000+01:00
Signed-off-by: Gabriel Smith &lt;ga29smith@gmail.com&gt;
Co-authored-by: varkor &lt;github@varkor.com&gt;
diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
@@ -241,6 +241,11 @@ impl<'hir> MapEntry<'hir> {
                 }
             }
 
+            EntryGenericParam(_, _, _) => {
+                // TODO(const_generics): defaults
+                None
+            }
+
             _ => None
         }
     }
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -1368,7 +1368,8 @@ fn object_lifetime_defaults_for_item(
             })
         }
         GenericParamKind::Const { .. } => {
-            unimplemented!() // TODO(const_generics):
+            // TODO(const_generics):
+            None
         }
     })
     .collect()
diff --git a/src/librustc/ty/flags.rs b/src/librustc/ty/flags.rs
@@ -235,10 +235,16 @@ impl FlagComputation {
 
     fn add_const(&mut self, constant: &ty::Const) {
         self.add_ty(constant.ty);
-        // TODO(const_generics): `Param`
-        if let ConstValue::Unevaluated(_, substs) = constant.val {
-            self.add_flags(TypeFlags::HAS_PROJECTION);
-            self.add_substs(substs);
+        match constant.val {
+            ConstValue::Unevaluated(_, substs) => {
+                self.add_flags(TypeFlags::HAS_PROJECTION);
+                self.add_substs(substs);
+            }
+            ConstVal::Param(_) => {
+                self.add_flags(TypeFlags::HAS_FREE_LOCAL_NAMES);
+                self.add_flags(TypeFlags::HAS_PARAMS);
+            }
+            _ => {}
         }
     }
 
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -918,7 +918,6 @@ impl<'a, 'gcx, 'tcx> Generics<'tcx> {
         self.parent_count + self.params.len()
     }
 
-    // TODO(const_generics): check uses for places where consts need to be taken into account
     pub fn own_counts(&self) -> GenericParamCount {
         // We could cache this as a property of `GenericParamCount`, but
         // the aim is to refactor this away entirely eventually and the
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
@@ -1116,7 +1116,8 @@ fn create_mono_items_for_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                         continue;
                     }
 
-                    if tcx.generics_of(method.def_id).own_counts().types != 0 {
+                    let counts = tcx.generics_of(method.def_id).own_counts();
+                    if counts.types + counts.consts != 0 {
                         continue;
                     }
 
diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
@@ -386,9 +386,10 @@ fn unsafe_derive_on_repr_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: D
 
     // FIXME: when we make this a hard error, this should have its
     // own error code.
-    let message = if tcx.generics_of(def_id).own_counts().types != 0 {
+    let counts = tcx.generics_of(def_id).own_counts();
+    let message = if counts.types + counts.consts != 0 {
         "#[derive] can't be used on a #[repr(packed)] struct with \
-         type parameters (error E0133)".to_string()
+         type or const parameters (error E0133)".to_string()
     } else {
         "#[derive] can't be used on a #[repr(packed)] struct that \
          does not derive Copy (error E0133)".to_string()
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
@@ -641,6 +641,61 @@ fn compare_number_of_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         return Err(ErrorReported);
     }
 
+    let num_impl_m_const_params = impl_m_generics.own_counts().consts;
+    let num_trait_m_const_params = trait_m_generics.own_counts().consts;
+
+    if num_impl_m_const_params != num_trait_m_const_params {
+        let impl_m_node_id = tcx.hir.as_local_node_id(impl_m.def_id).unwrap();
+        let impl_m_item = tcx.hir.expect_impl_item(impl_m_node_id);
+        let span = if impl_m_item.generics.params.is_empty() {
+            impl_m_span
+        } else {
+            impl_m_item.generics.span
+        };
+
+        let mut err = struct_span_err!(tcx.sess,
+                                       span,
+                                       E0049, // TDOO(const_generics): new error code?
+                                       "method `{}` has {} const parameter{} but its trait \
+                                        declaration has {} const parameter{}",
+                                       trait_m.name,
+                                       num_impl_m_const_params,
+                                       if num_impl_m_const_params == 1 { "" } else { "s" },
+                                       num_trait_m_const_params,
+                                       if num_trait_m_const_params == 1 {
+                                           ""
+                                       } else {
+                                           "s"
+                                       });
+
+        let mut suffix = None;
+
+        if let Some(span) = trait_item_span {
+            err.span_label(span,
+                           format!("expected {}",
+                                    &if num_trait_m_const_params != 1 {
+                                        format!("{} const parameters", num_trait_m_const_params)
+                                    } else {
+                                        format!("{} const parameter", num_trait_m_const_params)
+                                    }));
+        } else {
+            suffix = Some(format!(", expected {}", num_trait_m_const_params));
+        }
+
+        err.span_label(span,
+                       format!("found {}{}",
+                                &if num_impl_m_const_params != 1 {
+                                    format!("{} const parameters", num_impl_m_const_params)
+                                } else {
+                                    format!("1 const parameter")
+                                },
+                                suffix.as_ref().map(|s| &s[..]).unwrap_or("")));
+
+        err.emit();
+
+        return Err(ErrorReported);
+    }
+
     Ok(())
 }
 
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1332,10 +1332,11 @@ pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item
                 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
                 if generics.params.len() - generics.own_counts().lifetimes != 0 {
                     let mut err = struct_span_err!(tcx.sess, item.span, E0044,
-                        "foreign items may not have type parameters");
-                    err.span_label(item.span, "can't have type parameters");
+                        "foreign items may not have type or const parameters");
+                    err.span_label(item.span, "can't have type or const parameters");
                     // FIXME: once we start storing spans for type arguments, turn this into a
                     // suggestion.
+                    // TODO(const_generics): help message
                     err.help("use specialization instead of type parameters by replacing them \
                               with concrete types like `u32`");
                     err.emit();
@@ -5161,14 +5162,17 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     }
 }
 
-//TODO: Const Params
 pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                        generics: &ty::Generics,
                                        ty: Ty<'tcx>) {
     let own_counts = generics.own_counts();
-    debug!("check_bounds_are_used(n_tps={}, ty={:?})", own_counts.types, ty);
+    debug!("check_bounds_are_used(n_tps={}, n_cts={}, ty={:?})",
+        own_counts.types,
+        own_counts.consts,
+        ty
+    );
 
-    if own_counts.types == 0 {
+    if own_counts.types + own_counts.consts == 0 {
         return;
     }
     // Make a vector of booleans initially false, set to true when used.
@@ -5199,6 +5203,24 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 .emit();
         }
     }
+
+    // TODO(const_generics): is there even a way to walk all consts?
+    //let mut consts_used = vec![false; own_counts.types];
+    //
+    //let consts = generics.params.iter().filter(|param| match param.kind {
+    //    ty::GenericParamDefKind::Const { .. } => true,
+    //    _ => false,
+    //});
+    //for (&used, param) in consts_used.iter().zip(consts) {
+    //    if !used {
+    //        let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
+    //        let span = tcx.hir.span(id);
+    //        // TODO(const_generics): new error code
+    //        struct_span_err!(tcx.sess, span, E0091, "const parameter `{}` is unused", param.name)
+    //            .span_label(span, "unused const parameter")
+    //            .emit();
+    //    }
+    //}
 }
 
 fn fatally_break_rust(sess: &Session) {
diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs
@@ -431,7 +431,7 @@ impl Foo for Bar {
 
 E0049: r##"
 This error indicates that an attempted implementation of a trait method
-has the wrong number of type parameters.
+has the wrong number of type or const parameters.
 
 For example, the trait below has a method `foo` with a type parameter `T`,
 but the implementation of `foo` for the type `Bar` is missing this parameter:

Original file line number	Diff line number	Diff line change
`@@ -241,6 +241,11 @@ impl<'hir> MapEntry<'hir> {`
`241`	`241`	`}`
`242`	`242`	`}`
`243`	`243`
	`244`	`+ EntryGenericParam(_, _, _) => {`
	`245`	`+ // TODO(const_generics): defaults`
	`246`	`+ None`
	`247`	`+ }`
	`248`	`+`
`244`	`249`	`_ => None`
`245`	`250`	`}`
`246`	`251`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1368,7 +1368,8 @@ fn object_lifetime_defaults_for_item(`
`1368`	`1368`	`})`
`1369`	`1369`	`}`
`1370`	`1370`	`GenericParamKind::Const { .. } => {`
`1371`		`- unimplemented!() // TODO(const_generics):`
	`1371`	`+ // TODO(const_generics):`
	`1372`	`+ None`
`1372`	`1373`	`}`
`1373`	`1374`	`})`
`1374`	`1375`	`.collect()`
Original file line number	Diff line number	Diff line change
`@@ -918,7 +918,6 @@ impl<'a, 'gcx, 'tcx> Generics<'tcx> {`
`918`	`918`	`self.parent_count + self.params.len()`
`919`	`919`	`}`
`920`	`920`
`921`		`- // TODO(const_generics): check uses for places where consts need to be taken into account`
`922`	`921`	`pub fn own_counts(&self) -> GenericParamCount {`
`923`	`922`	// We could cache this as a property of `GenericParamCount`, but
`924`	`923`	`// the aim is to refactor this away entirely eventually and the`
Original file line number	Diff line number	Diff line change
`@@ -1116,7 +1116,8 @@ fn create_mono_items_for_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,`
`1116`	`1116`	`continue;`
`1117`	`1117`	`}`
`1118`	`1118`
`1119`		`- if tcx.generics_of(method.def_id).own_counts().types != 0 {`
	`1119`	`+ let counts = tcx.generics_of(method.def_id).own_counts();`
	`1120`	`+ if counts.types + counts.consts != 0 {`
`1120`	`1121`	`continue;`
`1121`	`1122`	`}`
`1122`	`1123`