Fix assorted issues

varkor · varkor · commit 0dccb7ce195f · 2018-08-23T18:55:34.000+01:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -2267,7 +2267,8 @@ impl<'a> LoweringContext<'a> {
                            -> hir::GenericParam {
         let mut bounds = self.lower_param_bounds(&param.bounds, itctx.reborrow());
         // TODO(const_generics): only create `hir::GenericParam` once.
-        match param.kind {
+
+        let (name, kind) = match param.kind {
             GenericParamKind::Lifetime => {
                 let was_collecting_in_band = self.is_collecting_in_band_lifetimes;
                 self.is_collecting_in_band_lifetimes = false;
@@ -2277,19 +2278,12 @@ impl<'a> LoweringContext<'a> {
                     hir::LifetimeName::Param(param_name) => param_name,
                     _ => hir::ParamName::Plain(lt.name.ident()),
                 };
-                let param = hir::GenericParam {
-                    id: lt.id,
-                    name: param_name,
-                    span: lt.span,
-                    pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
-                    attrs: self.lower_attrs(&param.attrs),
-                    bounds,
-                    kind: hir::GenericParamKind::Lifetime { in_band: false }
-                };
+
+                let kind = hir::GenericParamKind::Lifetime { in_band: false };
 
                 self.is_collecting_in_band_lifetimes = was_collecting_in_band;
 
-                param
+                (param_name, kind)
             }
             GenericParamKind::Type { ref default, .. } => {
                 // Don't expose `Self` (recovered "keyword used as ident" parse error).
@@ -2309,37 +2303,33 @@ impl<'a> LoweringContext<'a> {
                                    .collect();
                 }
 
-                hir::GenericParam {
-                    id: self.lower_node_id(param.id).node_id,
-                    name: hir::ParamName::Plain(ident),
-                    pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
-                    attrs: self.lower_attrs(&param.attrs),
-                    bounds,
-                    span: ident.span,
-                    kind: hir::GenericParamKind::Type {
-                        default: default.as_ref().map(|x| {
-                            self.lower_ty(x, ImplTraitContext::Disallowed)
-                        }),
-                        synthetic: param.attrs.iter()
-                                              .filter(|attr| attr.check_name("rustc_synthetic"))
-                                              .map(|_| hir::SyntheticTyParamKind::ImplTrait)
-                                              .next(),
-                    }
-                }
+                let kind = hir::GenericParamKind::Type {
+                    default: default.as_ref().map(|x| {
+                        self.lower_ty(x, ImplTraitContext::Disallowed)
+                    }),
+                    synthetic: param.attrs.iter()
+                                          .filter(|attr| attr.check_name("rustc_synthetic"))
+                                          .map(|_| hir::SyntheticTyParamKind::ImplTrait)
+                                          .next(),
+                };
+
+                (hir::ParamName::Plain(ident), kind)
             }
             GenericParamKind::Const { ref ty } => {
-                hir::GenericParam {
-                    id: self.lower_node_id(param.id).node_id,
-                    name: hir::ParamName::Plain(param.ident),
-                    span: param.ident.span,
-                    pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
-                    attrs: self.lower_attrs(&param.attrs),
-                    bounds,
-                    kind: hir::GenericParamKind::Const {
-                        ty: self.lower_ty(&ty, ImplTraitContext::Disallowed),
-                    }
-                }
+                (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const {
+                    ty: self.lower_ty(&ty, ImplTraitContext::Disallowed),
+                })
             }
+        };
+
+        hir::GenericParam {
+            id: self.lower_node_id(param.id).node_id,
+            name,
+            span: param.ident.span,
+            pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
+            attrs: self.lower_attrs(&param.attrs),
+            bounds,
+            kind,
         }
     }
 
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
@@ -1372,7 +1372,7 @@ fn object_lifetime_defaults_for_item(
             })
         }
         GenericParamKind::Const { .. } => {
-            // TODO(const_generics):
+            // Generic consts don't impose any constraints.
             None
         }
     })
diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs
@@ -61,7 +61,6 @@ pub enum TypeError<'tcx> {
 // Data structure used in const unification
 #[derive(Clone, Debug)]
 pub enum ConstError<'tcx> {
-    Types(ExpectedFound<&'tcx ty::Const<'tcx>>),
     Mismatch(ExpectedFound<&'tcx ty::Const<'tcx>>),
 }
 
diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs
@@ -591,26 +591,23 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
                                            -> RelateResult<'tcx, &'tcx Const<'tcx>>
     where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'a+'tcx, 'tcx: 'a
 {
-    if a.ty != b.ty {
-        // TODO(const_generics): replace with an assert
-        return Err(TypeError::ConstError(
-            ConstError::Types(expected_found(relation, &a, &b))
-        ));
-    }
+    assert!(a.ty != b.ty);
 
     let tcx = relation.tcx();
     // Currently, the values that can be unified are those that
     // implement both `PartialEq` and `Eq`, corresponding to
     // `structural_match` types.
     // FIXME(const_generics): check for `structural_match` synthetic attribute.
-    // TODO(const_generics): a == b is only valid if a, b are Scalar, ScalarPair, ByRef
     // TODO(const_generics): possibly need indirection for ByRef?
     // TODO(const_generics): Param should be a bug here
     match (a.val, b.val) {
         (ConstValue::Infer(_), _) | (_, ConstValue::Infer(_)) => {
             // The caller should handle these cases!
             bug!("var types encountered in super_relate_consts")
         }
+        (ConstValue::Param(_), _) | (_, ConstValue::Param(_)) => {
+            bug!("param types encountered in super_relate_consts")
+        }
         (ConstValue::Scalar(_), _) |
         (ConstValue::ScalarPair(..), _) |
         (ConstValue::ByRef(..), _)
@@ -622,20 +619,16 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
         (ConstValue::Unevaluated(a_def_id, a_substs), ConstValue::Unevaluated(b_def_id, b_substs))
             if a_def_id == b_def_id =>
         {
-            // TODO(const_generics): should just using an invariant (covariance) method
             let substs =
                 relation.relate_with_variance(ty::Variance::Invariant, &a_substs, &b_substs)?;
             Ok(tcx.mk_const(ty::Const {
                 val: ConstValue::Unevaluated(a_def_id, substs),
                 ty: a.ty,
             }))
-        }
-        (ConstValue::Param(ref a_p), ConstValue::Param(ref b_p)) if a_p.index == b_p.index => {
-            Ok(a)
         }
          _ => {
             Err(TypeError::ConstError(
-                ConstError::Types(expected_found(relation, &a, &b))
+                ConstError::Mismatch(expected_found(relation, &a, &b))
             ))
         }
     }
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
@@ -466,7 +466,6 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::ConstError<'a> {
         use ty::error::ConstError::*;
 
         match *self {
-            Types(ref x) => return tcx.lift(x).map(Types),
             Mismatch(ref x) => return tcx.lift(x).map(Mismatch),
         }
     }
@@ -1150,7 +1149,6 @@ EnumTypeFoldableImpl! {
 
 EnumTypeFoldableImpl! {
     impl<'tcx> TypeFoldable<'tcx> for ty::error::ConstError<'tcx> {
-        (ty::error::ConstError::Types)(x),
         (ty::error::ConstError::Mismatch)(x),
     }
 }
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -344,7 +344,7 @@ impl PrintContext {
                         GenericParamDefKind::Type { has_default, .. } => {
                             Some((param.def_id, has_default))
                         }
-                        GenericParamDefKind::Const { .. } => unimplemented!(), // TODO(const_generics):
+                        GenericParamDefKind::Const { .. } => None, // FIXME(const_generics:defaults)
                     }).peekable();
                 let has_default = {
                     let has_default = type_params.peek().map(|(_, has_default)| has_default);
diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs
@@ -90,8 +90,8 @@ impl OperandRef<'ll, 'tcx> {
 
         let val = match val.val {
             ConstValue::Unevaluated(..) => bug!(),
-            ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
-            ConstValue::Infer(_) => unimplemented!(), // TODO(const_generics)
+            ConstValue::Param(_) => bug!(),
+            ConstValue::Infer(_) => bug!(),
             ConstValue::Scalar(x) => {
                 let scalar = match layout.abi {
                     layout::Abi::Scalar(ref x) => x,
diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs
@@ -1336,10 +1336,9 @@ fn slice_pat_covered_by_constructor<'tcx>(
         ConstantValue(const_val) => {
             let val = match const_val.val {
                 ConstValue::Unevaluated(..) |
+                ConstValue::Param(_) | ConstValue::Infer(_) |
                 ConstValue::ByRef(..) => bug!("unexpected ConstValue: {:?}", const_val),
                 ConstValue::Scalar(val) | ConstValue::ScalarPair(val, _) => val,
-                ConstValue::Param(_) | // TODO(const_generics)
-                ConstValue::Infer(_) => unimplemented!(), // TODO(const_generics)
             };
             if let Ok(ptr) = val.to_ptr() {
                 let is_array_ptr = const_val.ty
diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs
@@ -306,7 +306,9 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'gcx, 'tcx>(
         match kind.unpack() {
             UnpackedKind::Lifetime(r) => rcx.sub_regions(origin(), parent_scope, r),
             UnpackedKind::Type(ty) => rcx.type_must_outlive(origin(), ty, parent_scope),
-            UnpackedKind::Const(_ct) => unimplemented!(), // TODO(const_generics):
+            UnpackedKind::Const(_) => {
+                // Generic consts don't add constraints.
+            }
         }
     }
     Ok(())
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1330,15 +1330,22 @@ pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item
         } else {
             for item in &m.items {
                 let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));
-                if generics.params.len() - generics.own_counts().lifetimes != 0 {
+                let own_counts = generics.own_counts();
+                if generics.params.len() - own_counts.lifetimes != 0 {
                     let mut err = struct_span_err!(tcx.sess, item.span, E0044,
                         "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`");
+                    if own_counts.types > 0 {
+                        err.help("use specialization instead of type parameters by replacing \
+                                  them with concrete types like `u32`");
+                    }
+                    if own_counts.consts > 0 {
+                        err.help("use specialization instead of const parameters by replacing \
+                                  them with concrete consts like `0`");
+                    }
+
                     err.emit();
                 }
 
@@ -1348,7 +1355,7 @@ pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item
             }
         }
       }
-      _ => {/* nothing to do */ }
+      _ => { /* nothing to do */ }
     }
 }
 
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -448,7 +448,7 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(
                 fcx.tcx.types.err.into()
             }
             GenericParamDefKind::Const { .. } => {
-                // TODO(const_generics): defaults
+                // FIXME(const_generics:defaults)
                 fcx.tcx.types.err.into()
             }
         }
@@ -600,11 +600,10 @@ fn check_existential_types<'a, 'fcx, 'gcx, 'tcx>(
                         for (subst, param) in substs.iter().zip(&generics.params) {
                             match subst.unpack() {
                                 ty::subst::UnpackedKind::Type(ty) => match ty.sty {
-                                    ty::Param(..) => {},
+                                    ty::Param(..) => {}
                                     // prevent `fn foo() -> Foo<u32>` from being defining
                                     _ => {
-                                        tcx
-                                            .sess
+                                        tcx.sess
                                             .struct_span_err(
                                                 span,
                                                 "non-defining existential type use \
@@ -619,7 +618,7 @@ fn check_existential_types<'a, 'fcx, 'gcx, 'tcx>(
                                                 ),
                                             )
                                             .emit();
-                                    },
+                                    }
                                 } // match ty
                                 ty::subst::UnpackedKind::Lifetime(region) => {
                                     let param_span = tcx.def_span(param.def_id);
@@ -642,9 +641,25 @@ fn check_existential_types<'a, 'fcx, 'gcx, 'tcx>(
                                         seen.entry(region).or_default().push(param_span);
                                     }
                                 }
-                                ty::subst::UnpackedKind::Const(_) => {
-                                    // TODO(const_generics)
-                                    unimplemented!()
+                                ty::subst::UnpackedKind::Const(ct) => match ct.val {
+                                    ConstValue::Param(_) => {}
+                                    _ => {
+                                        tcx.sess
+                                            .struct_span_err(
+                                                span,
+                                                "non-defining existential type use \
+                                                in defining scope",
+                                            )
+                                            .span_note(
+                                                tcx.def_span(param.def_id),
+                                                &format!(
+                                                    "used non-generic const {} for \
+                                                    generic parameter",
+                                                    ty,
+                                                ),
+                                            )
+                                            .emit();
+                                    }
                                 }
                             } // match subst
                         } // for (subst, param)
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -954,7 +954,6 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             Some(ty_param)
         }
 
-        // TODO(const_generics): should this be split out to put const parameters after type parameters?
         GenericParamKind::Const { ref ty } => {
             if param.name.ident().name == keywords::SelfType.name() {
                 span_bug!(param.span,  "`Self` should not be the name of a regular parameter");
diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs
@@ -108,15 +108,22 @@ fn inferred_outlives_crate<'tcx>(
         .map(|(&def_id, set)| {
             let vec: Vec<ty::Predicate<'tcx>> = set
                 .iter()
-                .map(
+                .filter_map(
                     |ty::OutlivesPredicate(kind1, region2)| match kind1.unpack() {
-                        UnpackedKind::Type(ty1) => ty::Predicate::TypeOutlives(ty::Binder::bind(
-                            ty::OutlivesPredicate(ty1, region2),
-                        )),
-                        UnpackedKind::Lifetime(region1) => ty::Predicate::RegionOutlives(
-                            ty::Binder::bind(ty::OutlivesPredicate(region1, region2)),
-                        ),
-                        UnpackedKind::Const(_ct) => unimplemented!(), // TODO(const_generics):
+                        UnpackedKind::Type(ty1) => {
+                            Some(ty::Predicate::TypeOutlives(ty::Binder::bind(
+                                ty::OutlivesPredicate(ty1, region2)
+                            )))
+                        }
+                        UnpackedKind::Lifetime(region1) => {
+                            Some(ty::Predicate::RegionOutlives(
+                                ty::Binder::bind(ty::OutlivesPredicate(region1, region2))
+                            ))
+                        }
+                        UnpackedKind::Const(_) => {
+                            // Generic consts don't impose any constraints.
+                            None
+                        }
                     },
                 )
                 .collect();
diff --git a/src/librustc_typeck/outlives/utils.rs b/src/librustc_typeck/outlives/utils.rs
@@ -126,7 +126,9 @@ pub fn insert_outlives_predicate<'tcx>(
             required_predicates.insert(ty::OutlivesPredicate(kind, outlived_region));
         }
 
-        UnpackedKind::Const(_ct) => unimplemented!(), // TODO(const_generics):
+        UnpackedKind::Const(_) => {
+            // Generic consts don't impose any constraints.
+        }
     }
 }
 
diff --git a/src/librustc_typeck/variance/constraints.rs b/src/librustc_typeck/variance/constraints.rs
@@ -390,7 +390,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 UnpackedKind::Type(ty) => {
                     self.add_constraints_from_ty(current, ty, variance_i)
                 }
-                UnpackedKind::Const(_ct) => unimplemented!(), // TODO(const_generics):
+                UnpackedKind::Const(_) => {
+                    // Generic consts don't add any constraints.
+                }
             }
         }
     }
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
@@ -785,9 +785,7 @@ impl<'a, 'tcx, 'rcx, 'cstore> AutoTraitFinder<'a, 'tcx, 'rcx, 'cstore> {
                         bounds.insert(0, GenericBound::maybe_sized(self.cx));
                     }
                 }
-                GenericParamDefKind::Const { .. } => {
-                    unimplemented!() // TODO(const_generics)
-                }
+                GenericParamDefKind::Const { .. } => {}
             }
         }
 
diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -1372,7 +1372,7 @@ fn object_lifetime_defaults_for_item(`
`1372`	`1372`	`})`
`1373`	`1373`	`}`
`1374`	`1374`	`GenericParamKind::Const { .. } => {`
`1375`		`- // TODO(const_generics):`
	`1375`	`+ // Generic consts don't impose any constraints.`
`1376`	`1376`	`None`
`1377`	`1377`	`}`
`1378`	`1378`	`})`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,6 @@ pub enum TypeError<'tcx> {`
`61`	`61`	`// Data structure used in const unification`
`62`	`62`	`#[derive(Clone, Debug)]`
`63`	`63`	`pub enum ConstError<'tcx> {`
`64`		`- Types(ExpectedFound<&'tcx ty::Const<'tcx>>),`
`65`	`64`	`Mismatch(ExpectedFound<&'tcx ty::Const<'tcx>>),`
`66`	`65`	`}`
`67`	`66`
Original file line number	Diff line number	Diff line change
`@@ -466,7 +466,6 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::ConstError<'a> {`
`466`	`466`	`use ty::error::ConstError::*;`
`467`	`467`
`468`	`468`	`match *self {`
`469`		`- Types(ref x) => return tcx.lift(x).map(Types),`
`470`	`469`	`Mismatch(ref x) => return tcx.lift(x).map(Mismatch),`
`471`	`470`	`}`
`472`	`471`	`}`
`@@ -1150,7 +1149,6 @@ EnumTypeFoldableImpl! {`
`1150`	`1149`
`1151`	`1150`	`EnumTypeFoldableImpl! {`
`1152`	`1151`	`impl<'tcx> TypeFoldable<'tcx> for ty::error::ConstError<'tcx> {`
`1153`		`- (ty::error::ConstError::Types)(x),`
`1154`	`1152`	`(ty::error::ConstError::Mismatch)(x),`
`1155`	`1153`	`}`
`1156`	`1154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -344,7 +344,7 @@ impl PrintContext {`
`344`	`344`	`GenericParamDefKind::Type { has_default, .. } => {`
`345`	`345`	`Some((param.def_id, has_default))`
`346`	`346`	`}`
`347`		`- GenericParamDefKind::Const { .. } => unimplemented!(), // TODO(const_generics):`
	`347`	`+ GenericParamDefKind::Const { .. } => None, // FIXME(const_generics:defaults)`
`348`	`348`	`}).peekable();`
`349`	`349`	`let has_default = {`
`350`	`350`	`let has_default = type_params.peek().map(\|(_, has_default)\| has_default);`
Original file line number	Diff line number	Diff line change
`@@ -306,7 +306,9 @@ pub fn check_safety_of_destructor_if_necessary<'a, 'gcx, 'tcx>(`
`306`	`306`	`match kind.unpack() {`
`307`	`307`	`UnpackedKind::Lifetime(r) => rcx.sub_regions(origin(), parent_scope, r),`
`308`	`308`	`UnpackedKind::Type(ty) => rcx.type_must_outlive(origin(), ty, parent_scope),`
`309`		`- UnpackedKind::Const(_ct) => unimplemented!(), // TODO(const_generics):`
	`309`	`+ UnpackedKind::Const(_) => {`
	`310`	`+ // Generic consts don't add constraints.`
	`311`	`+ }`
`310`	`312`	`}`
`311`	`313`	`}`
`312`	`314`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -1330,15 +1330,22 @@ pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item`
`1330`	`1330`	`} else {`
`1331`	`1331`	`for item in &m.items {`
`1332`	`1332`	`let generics = tcx.generics_of(tcx.hir.local_def_id(item.id));`
`1333`		`- if generics.params.len() - generics.own_counts().lifetimes != 0 {`
	`1333`	`+ let own_counts = generics.own_counts();`
	`1334`	`+ if generics.params.len() - own_counts.lifetimes != 0 {`
`1334`	`1335`	`let mut err = struct_span_err!(tcx.sess, item.span, E0044,`
`1335`	`1336`	`"foreign items may not have type or const parameters");`
`1336`	`1337`	`err.span_label(item.span, "can't have type or const parameters");`
`1337`	`1338`	`// FIXME: once we start storing spans for type arguments, turn this into a`
`1338`	`1339`	`// suggestion.`
`1339`		`- // TODO(const_generics): help message`
`1340`		`- err.help("use specialization instead of type parameters by replacing them \`
`1341`		- with concrete types like `u32`");
	`1340`	`+ if own_counts.types > 0 {`
	`1341`	`+ err.help("use specialization instead of type parameters by replacing \`
	`1342`	+ them with concrete types like `u32`");
	`1343`	`+ }`
	`1344`	`+ if own_counts.consts > 0 {`
	`1345`	`+ err.help("use specialization instead of const parameters by replacing \`
	`1346`	+ them with concrete consts like `0`");
	`1347`	`+ }`
	`1348`	`+`
`1342`	`1349`	`err.emit();`
`1343`	`1350`	`}`
`1344`	`1351`
`@@ -1348,7 +1355,7 @@ pub fn check_item_type<'a,'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, it: &'tcx hir::Item`
`1348`	`1355`	`}`
`1349`	`1356`	`}`
`1350`	`1357`	`}`
`1351`		`- _ => {/* nothing to do */ }`
	`1358`	`+ _ => { /* nothing to do */ }`
`1352`	`1359`	`}`
`1353`	`1360`	`}`
`1354`	`1361`