//! The second pass over the AST determines the set of constraints.
//! We walk the set of items and, for each member, generate new constraints.
-use dep_graph::DepTrackingMapConfig;
use hir::def_id::DefId;
use middle::resolve_lifetime as rl;
use rustc::ty::subst::Substs;
use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::maps::ItemVariances;
use rustc::hir::map as hir_map;
use syntax::ast;
use rustc::hir;
use super::terms::VarianceTerm::*;
use super::xform::*;
+use dep_graph::DepNode::ItemSignature as VarianceDepNode;
+
pub struct ConstraintContext<'a, 'tcx: 'a> {
pub terms_cx: TermsContext<'a, 'tcx>,
};
// See README.md for a discussion on dep-graph management.
- tcx.visit_all_item_likes_in_krate(|def_id| ItemVariances::to_dep_node(&def_id),
- &mut constraint_cx);
+ tcx.visit_all_item_likes_in_krate(VarianceDepNode, &mut constraint_cx);
constraint_cx
}
hir::ItemFn(..) |
hir::ItemMod(..) |
hir::ItemForeignMod(..) |
+ hir::ItemGlobalAsm(..) |
hir::ItemTy(..) |
hir::ItemImpl(..) |
hir::ItemDefaultImpl(..) => {}
}
fn add_constraints_from_trait_ref(&mut self,
- generics: &ty::Generics<'tcx>,
+ generics: &ty::Generics,
trait_ref: ty::TraitRef<'tcx>,
variance: VarianceTermPtr<'a>) {
debug!("add_constraints_from_trait_ref: trait_ref={:?} variance={:?}",
// This edge is actually implied by the call to
// `lookup_trait_def`, but I'm trying to be future-proof. See
// README.md for a discussion on dep-graph management.
- self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id));
+ self.tcx().dep_graph.read(VarianceDepNode(trait_ref.def_id));
self.add_constraints_from_substs(generics,
trait_ref.def_id,
/// in a context with the generics defined in `generics` and
/// ambient variance `variance`
fn add_constraints_from_ty(&mut self,
- generics: &ty::Generics<'tcx>,
+ generics: &ty::Generics,
ty: Ty<'tcx>,
variance: VarianceTermPtr<'a>) {
debug!("add_constraints_from_ty(ty={:?}, variance={:?})",
self.add_constraints_from_mt(generics, mt, variance);
}
- ty::TyTuple(subtys) => {
+ ty::TyTuple(subtys, _) => {
for &subty in subtys {
self.add_constraints_from_ty(generics, subty, variance);
}
// This edge is actually implied by the call to
// `lookup_trait_def`, but I'm trying to be future-proof. See
// README.md for a discussion on dep-graph management.
- self.tcx().dep_graph.read(ItemVariances::to_dep_node(&def.did));
+ self.tcx().dep_graph.read(VarianceDepNode(def.did));
self.add_constraints_from_substs(generics,
def.did,
// This edge is actually implied by the call to
// `lookup_trait_def`, but I'm trying to be future-proof. See
// README.md for a discussion on dep-graph management.
- self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id));
+ self.tcx().dep_graph.read(VarianceDepNode(trait_ref.def_id));
self.add_constraints_from_substs(generics,
trait_ref.def_id,
}
}
- ty::TyFnDef(.., &ty::BareFnTy { ref sig, .. }) |
- ty::TyFnPtr(&ty::BareFnTy { ref sig, .. }) => {
+ ty::TyFnDef(.., sig) |
+ ty::TyFnPtr(sig) => {
self.add_constraints_from_sig(generics, sig, variance);
}
/// Adds constraints appropriate for a nominal type (enum, struct,
/// object, etc) appearing in a context with ambient variance `variance`
fn add_constraints_from_substs(&mut self,
- generics: &ty::Generics<'tcx>,
+ generics: &ty::Generics,
def_id: DefId,
- type_param_defs: &[ty::TypeParameterDef<'tcx>],
+ type_param_defs: &[ty::TypeParameterDef],
region_param_defs: &[ty::RegionParameterDef],
substs: &Substs<'tcx>,
variance: VarianceTermPtr<'a>) {
/// Adds constraints appropriate for a function with signature
/// `sig` appearing in a context with ambient variance `variance`
fn add_constraints_from_sig(&mut self,
- generics: &ty::Generics<'tcx>,
- sig: &ty::PolyFnSig<'tcx>,
+ generics: &ty::Generics,
+ sig: ty::PolyFnSig<'tcx>,
variance: VarianceTermPtr<'a>) {
let contra = self.contravariant(variance);
for &input in sig.0.inputs() {
/// Adds constraints appropriate for a region appearing in a
/// context with ambient variance `variance`
fn add_constraints_from_region(&mut self,
- generics: &ty::Generics<'tcx>,
+ generics: &ty::Generics,
region: &'tcx ty::Region,
variance: VarianceTermPtr<'a>) {
match *region {
/// Adds constraints appropriate for a mutability-type pair
/// appearing in a context with ambient variance `variance`
fn add_constraints_from_mt(&mut self,
- generics: &ty::Generics<'tcx>,
+ generics: &ty::Generics,
mt: &ty::TypeAndMut<'tcx>,
variance: VarianceTermPtr<'a>) {
match mt.mutbl {