Progress through the ICEs a little further

Author: varkor

src/librustc/ty/context.rs

@@ -2552,7 +2552,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_ty(Param(ParamTy { idx: index, name: name }))
     }
 
-    pub fn mk_const_param(self, index: u32, name: InternedString, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
+    pub fn mk_const_param(
+        self,
+        index: u32,
+        name: InternedString,
+        ty: Ty<'tcx>
+    ) -> &'tcx ty::Const<'tcx> {
         debug!("mk_const_param: index={} name={:?} ty={:?}", index, name, ty);
         self.mk_const(ty::Const {
             val: ConstValue::Param(ParamConst { index, name }),

src/librustc/ty/relate.rs

@@ -591,7 +591,7 @@ 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
 {
-    assert!(a.ty != b.ty);
+    assert_eq!(a.ty, b.ty);
 
     let tcx = relation.tcx();
     // Currently, the values that can be unified are those that
@@ -601,10 +601,13 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
     match (a.val, b.val) {
         (ConstValue::Infer(_), _) | (_, ConstValue::Infer(_)) => {
             // The caller should handle these cases!
-            bug!("var types encountered in super_relate_consts")
+            bug!("var types encountered in super_relate_consts: {:?} {:?}", a, b)
+        }
+        (ConstValue::Param(a_p), ConstValue::Param(b_p)) if a_p.index == b_p.index => {
+            Ok(a)
         }
         (ConstValue::Param(_), _) | (_, ConstValue::Param(_)) => {
-            bug!("param types encountered in super_relate_consts")
+            bug!("param types encountered in super_relate_consts: {:?} {:?}", a, b);
         }
         (ConstValue::Scalar(_), _) |
         (ConstValue::ScalarPair(..), _) |

src/librustc_mir/build/mod.rs

@@ -37,9 +37,6 @@ use util as mir_util;
 /// Construct the MIR for a given def-id.
 pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'tcx> {
     let id = tcx.hir.as_local_node_id(def_id).unwrap();
-    let unsupported = || {
-        span_bug!(tcx.hir.span(id), "can't build MIR for {:?}", def_id);
-    };
 
     // Figure out what primary body this item has.
     let body_id = match tcx.hir.get(id) {
@@ -50,7 +47,9 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t
 
         _ => match tcx.hir.maybe_body_owned_by(id) {
             Some(body) => body,
-            None => unsupported(),
+            None => {
+                span_bug!(tcx.hir.span(id), "can't build MIR for {:?}", def_id)
+            }
         },
     };
 

src/librustc_typeck/collect.rs

@@ -1169,13 +1169,38 @@ fn type_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             NodeTy(&hir::Ty { node: hir::TyKind::Array(_, ref constant), .. }) |
             NodeTy(&hir::Ty { node: hir::TyKind::Typeof(ref constant), .. }) |
             NodeExpr(&hir::Expr { node: ExprKind::Repeat(_, ref constant), .. })
-                if constant.id == node_id => tcx.types.usize,
+                if constant.id == node_id =>
+            {
+                tcx.types.usize
+            }
 
             NodeVariant(&Spanned { node: VariantKind { disr_expr: Some(ref e), .. }, .. })
-                if e.id == node_id => {
-                    tcx.adt_def(tcx.hir.get_parent_did(node_id))
-                        .repr.discr_type().to_ty(tcx)
+                if e.id == node_id =>
+            {
+                tcx.adt_def(tcx.hir.get_parent_did(node_id))
+                    .repr.discr_type().to_ty(tcx)
+            }
+
+            NodeExpr(&hir::Expr { node: ExprKind::Path(ref path), .. }) => {
+                match path {
+                    QPath::Resolved(_, ref path) => {
+                        match path.def {
+                            Def::Fn(def_id) => {
+                                let generics = tcx.generics_of(def_id);
+                                for param in &generics.params {
+                                    // if param.id == node_id {
+                                        // generics.param_def_id_to_index
+                                        return tcx.type_of(param.def_id);
+                                    // }
+                                }
+                                bug!("no such param");
+                            }
+                            x => bug!("other def {:?}", x),
+                        }
+                    }
+                    _ => bug!("other path"),
                 }
+            }
 
             x => {
                 bug!("unexpected const parent in type_of_def_id(): {:?}", x);