Implemented param env translation.

Author: ibabushkin

src/lib.rs

@@ -7,6 +7,7 @@
 extern crate quickcheck;
 
 extern crate rustc;
+extern crate rustc_data_structures;
 extern crate rustc_errors;
 extern crate semver;
 extern crate syntax;

src/semcheck/translate.rs

@@ -1,16 +1,39 @@
 use rustc::hir::def_id::DefId;
-use rustc::ty::{Region, Ty, TyCtxt};
+use rustc::ty::{ParamEnv, Predicate, Region, Ty, TyCtxt};
 use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
 
+use rustc_data_structures::accumulate_vec::AccumulateVec;
+
 use semcheck::mapping::IdMapping;
 
 use std::collections::HashMap;
 
+/// Construct an parameter index map for an item.
+fn construct_index_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, old_def_id: DefId)
+    -> HashMap<u32, DefId>
+{
+    let mut index_map = HashMap::new();
+    let old_generics = tcx.generics_of(old_def_id);
+
+    for type_ in &old_generics.types {
+        index_map.insert(type_.index, type_.def_id);
+    }
+    if let Some(did) = old_generics.parent {
+        let parent_generics = tcx.generics_of(did);
+
+        for type_ in &parent_generics.types {
+            index_map.insert(type_.index, type_.def_id);
+        }
+    }
+
+    index_map
+}
+
 /// Translate all old `DefId`s in the object to their new counterparts, if possible.
-pub fn translate<'a, 'tcx, T>(id_mapping: &IdMapping,
-                              tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                              index_map: &HashMap<u32, DefId>,
-                              old: &T) -> T
+fn translate<'a, 'tcx, T>(id_mapping: &IdMapping,
+                          tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                          index_map: &HashMap<u32, DefId>,
+                          old: &T) -> T
     where T: TypeFoldable<'tcx>
 {
     use rustc::ty::{AdtDef, Binder, ExistentialProjection, ExistentialTraitRef};
@@ -25,7 +48,7 @@ pub fn translate<'a, 'tcx, T>(id_mapping: &IdMapping,
                 tcx.mk_adt(new_adt, substs)
             },
             TyRef(region, type_and_mut) => {
-                tcx.mk_ref(translate_region(tcx, id_mapping, region), type_and_mut)
+                tcx.mk_ref(translate_region(id_mapping, tcx, region), type_and_mut)
             },
             TyFnDef(did, substs) => {
                 tcx.mk_fn_def(id_mapping.get_new_id(did), substs)
@@ -87,9 +110,9 @@ pub fn translate<'a, 'tcx, T>(id_mapping: &IdMapping,
 }
 
 /// Translate all old `DefId`s in the region to their new counterparts, if possible.
-pub fn translate_region<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
-                                  id_mapping: &IdMapping,
-                                  region: Region<'tcx>) -> Region<'tcx> {
+fn translate_region<'a, 'tcx>(id_mapping: &IdMapping,
+                              tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                              region: Region<'tcx>) -> Region<'tcx> {
     use rustc::ty::{EarlyBoundRegion, FreeRegion};
     use rustc::ty::BoundRegion::BrNamed;
     use rustc::ty::RegionKind::*;
@@ -124,20 +147,95 @@ pub fn translate_item_type<'a, 'tcx>(id_mapping: &IdMapping,
                                      tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                      old_def_id: DefId,
                                      old: Ty<'tcx>) -> Ty<'tcx> {
-    let mut index_map = HashMap::new();
-    let old_generics = tcx.generics_of(old_def_id);
+    translate(id_mapping, tcx, &construct_index_map(tcx, old_def_id), &old)
+}
 
-    for type_ in &old_generics.types {
-        index_map.insert(type_.index, type_.def_id);
+/// Translate all old `DefId`s in the predicate to their new counterparts, if possible.
+fn translate_predicate<'a, 'tcx>(id_mapping: &IdMapping,
+                                     tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                     index_map: &HashMap<u32, DefId>,
+                                     predicate: Predicate<'tcx>) -> Predicate<'tcx> {
+    use rustc::ty::{EquatePredicate, OutlivesPredicate, ProjectionPredicate, ProjectionTy,
+                    SubtypePredicate, TraitPredicate, TraitRef};
+
+    match predicate {
+        Predicate::Trait(trait_predicate) => {
+            Predicate::Trait(trait_predicate.map_bound(|t_pred| {
+                TraitPredicate {
+                    trait_ref: TraitRef {
+                        def_id: id_mapping.get_new_id(t_pred.trait_ref.def_id),
+                        substs: t_pred.trait_ref.substs,
+                    }
+                }
+            }))
+        },
+        Predicate::Equate(equate_predicate) => {
+            Predicate::Equate(equate_predicate.map_bound(|e_pred| {
+                let l = translate(id_mapping, tcx, index_map, &e_pred.0);
+                let r = translate(id_mapping, tcx, index_map, &e_pred.1);
+                EquatePredicate(l, r)
+            }))
+        },
+        Predicate::RegionOutlives(region_outlives_predicate) => {
+            Predicate::RegionOutlives(region_outlives_predicate.map_bound(|r_pred| {
+                let l = translate_region(id_mapping, tcx, &r_pred.0);
+                let r = translate_region(id_mapping, tcx, &r_pred.1);
+                OutlivesPredicate(l, r)
+            }))
+        },
+        Predicate::TypeOutlives(type_outlives_predicate) => {
+            Predicate::TypeOutlives(type_outlives_predicate.map_bound(|r_pred| {
+                let l = translate(id_mapping, tcx, index_map, &r_pred.0);
+                let r = translate_region(id_mapping, tcx, &r_pred.1);
+                OutlivesPredicate(l, r)
+            }))
+        },
+        Predicate::Projection(projection_predicate) => {
+            Predicate::Projection(projection_predicate.map_bound(|p_pred| {
+                ProjectionPredicate {
+                    projection_ty: ProjectionTy {
+                        substs: p_pred.projection_ty.substs, // TODO: maybe this needs handling
+                        item_def_id: id_mapping.get_new_id(p_pred.projection_ty.item_def_id),
+                    },
+                    ty: translate(id_mapping, tcx, index_map, &p_pred.ty),
+                }
+            }))
+        },
+        Predicate::WellFormed(ty) =>
+            Predicate::WellFormed(translate(id_mapping, tcx, index_map, &ty)),
+        Predicate::ObjectSafe(did) => Predicate::ObjectSafe(id_mapping.get_new_id(did)),
+        Predicate::ClosureKind(did, kind) =>
+            Predicate::ClosureKind(id_mapping.get_new_id(did), kind),
+        Predicate::Subtype(subtype_predicate) => {
+            Predicate::Subtype(subtype_predicate.map_bound(|s_pred| {
+                let l = translate(id_mapping, tcx, index_map, &s_pred.a);
+                let r = translate(id_mapping, tcx, index_map, &s_pred.b);
+                SubtypePredicate {
+                    a_is_expected: s_pred.a_is_expected,
+                    a: l,
+                    b: r,
+                }
+            }))
+        },
     }
+}
 
-    if let Some(did) = old_generics.parent {
-        let parent_generics = tcx.generics_of(did);
-
-        for type_ in &parent_generics.types {
-            index_map.insert(type_.index, type_.def_id);
-        }
+/// Translate all old `DefId`s in the `ParamEnv` to their new counterparts, if possible.
+///
+/// This computes the mapping of type parameters needed as well.
+pub fn translate_param_env<'a, 'tcx>(id_mapping: &IdMapping,
+                                     tcx: TyCtxt<'a, 'tcx, 'tcx>,
+                                     old_def_id: DefId,
+                                     param_env: ParamEnv<'tcx>) -> ParamEnv<'tcx> {
+    let index_map = construct_index_map(tcx, old_def_id);
+    let res = param_env
+        .caller_bounds
+        .iter()
+        .map(|p| translate_predicate(id_mapping, tcx, &index_map, *p))
+        .collect::<AccumulateVec<[_; 8]>>();
+
+    ParamEnv {
+        caller_bounds: tcx.intern_predicates(&res),
+        reveal: param_env.reveal,
     }
-
-    translate(id_mapping, tcx, &index_map, &old)
 }