Skip to content

run rustfmt on librustc_typecheck/variance folder #34092

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 1 commit into from
Closed

run rustfmt on librustc_typecheck/variance folder #34092

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
158 changes: 79 additions & 79 deletions src/librustc_typeck/variance/constraints.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -39,7 +39,7 @@ pub struct ConstraintContext<'a, 'tcx: 'a> {
invariant: VarianceTermPtr<'a>,
bivariant: VarianceTermPtr<'a>,

pub constraints: Vec<Constraint<'a>> ,
pub constraints: Vec<Constraint<'a>>,
}

/// Declares that the variable `decl_id` appears in a location with
Expand All @@ -51,8 +51,7 @@ pub struct Constraint<'a> {
}

pub fn add_constraints_from_crate<'a, 'tcx>(terms_cx: TermsContext<'a, 'tcx>)
-> ConstraintContext<'a, 'tcx>
{
-> ConstraintContext<'a, 'tcx> {
let tcx = terms_cx.tcx;
let covariant = terms_cx.arena.alloc(ConstantTerm(ty::Covariant));
let contravariant = terms_cx.arena.alloc(ConstantTerm(ty::Contravariant));
Expand Down Expand Up @@ -113,16 +112,16 @@ impl<'a, 'tcx, 'v> Visitor<'v> for ConstraintContext<'a, 'tcx> {
hir::ItemForeignMod(..) |
hir::ItemTy(..) |
hir::ItemImpl(..) |
hir::ItemDefaultImpl(..) => {
}
hir::ItemDefaultImpl(..) => {}
}
}
}

/// Is `param_id` a lifetime according to `map`?
fn is_lifetime(map: &hir_map::Map, param_id: ast::NodeId) -> bool {
match map.find(param_id) {
Some(hir_map::NodeLifetime(..)) => true, _ => false
Some(hir_map::NodeLifetime(..)) => true,
_ => false,
}
}

Expand All @@ -145,13 +144,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
let tcx = self.terms_cx.tcx;
assert!(is_lifetime(&tcx.map, param_id));
match tcx.named_region_map.defs.get(&param_id) {
Some(&rl::DefEarlyBoundRegion(_, _, lifetime_decl_id))
=> lifetime_decl_id,
Some(&rl::DefEarlyBoundRegion(_, _, lifetime_decl_id)) => lifetime_decl_id,
Some(_) => bug!("should not encounter non early-bound cases"),

// The lookup should only fail when `param_id` is
// itself a lifetime binding: use it as the decl_id.
None => param_id,
None => param_id,
}

}
Expand All @@ -165,14 +163,15 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
// parameter (by inspecting parent of its binding declaration
// to see if it is introduced by a type or by a fn/impl).

let check_result = |this:&ConstraintContext| -> bool {
let check_result = |this: &ConstraintContext| -> bool {
let tcx = this.terms_cx.tcx;
let decl_id = this.find_binding_for_lifetime(param_id);
// Currently only called on lifetimes; double-checking that.
assert!(is_lifetime(&tcx.map, param_id));
let parent_id = tcx.map.get_parent(decl_id);
let parent = tcx.map.find(parent_id).unwrap_or_else(
|| bug!("tcx.map missing entry for id: {}", parent_id));
let parent = tcx.map
.find(parent_id)
.unwrap_or_else(|| bug!("tcx.map missing entry for id: {}", parent_id));

let is_inferred;
macro_rules! cannot_happen { () => { {
Expand All @@ -187,14 +186,14 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
hir::ItemTy(..) |
hir::ItemEnum(..) |
hir::ItemStruct(..) |
hir::ItemTrait(..) => is_inferred = true,
hir::ItemFn(..) => is_inferred = false,
_ => cannot_happen!(),
hir::ItemTrait(..) => is_inferred = true,
hir::ItemFn(..) => is_inferred = false,
_ => cannot_happen!(),
}
}
hir_map::NodeTraitItem(..) => is_inferred = false,
hir_map::NodeImplItem(..) => is_inferred = false,
_ => cannot_happen!(),
hir_map::NodeTraitItem(..) => is_inferred = false,
hir_map::NodeImplItem(..) => is_inferred = false,
_ => cannot_happen!(),
}

return is_inferred;
Expand Down Expand Up @@ -237,21 +236,18 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
fn add_constraint(&mut self,
InferredIndex(index): InferredIndex,
variance: VarianceTermPtr<'a>) {
debug!("add_constraint(index={}, variance={:?})",
index, variance);
self.constraints.push(Constraint { inferred: InferredIndex(index),
variance: variance });
debug!("add_constraint(index={}, variance={:?})", index, variance);
self.constraints.push(Constraint {
inferred: InferredIndex(index),
variance: variance,
});
}

fn contravariant(&mut self,
variance: VarianceTermPtr<'a>)
-> VarianceTermPtr<'a> {
fn contravariant(&mut self, variance: VarianceTermPtr<'a>) -> VarianceTermPtr<'a> {
self.xform(variance, self.contravariant)
}

fn invariant(&mut self,
variance: VarianceTermPtr<'a>)
-> VarianceTermPtr<'a> {
fn invariant(&mut self, variance: VarianceTermPtr<'a>) -> VarianceTermPtr<'a> {
self.xform(variance, self.invariant)
}

Expand All @@ -264,23 +260,16 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
}
}

fn xform(&mut self,
v1: VarianceTermPtr<'a>,
v2: VarianceTermPtr<'a>)
-> VarianceTermPtr<'a> {
fn xform(&mut self, v1: VarianceTermPtr<'a>, v2: VarianceTermPtr<'a>) -> VarianceTermPtr<'a> {
match (*v1, *v2) {
(_, ConstantTerm(ty::Covariant)) => {
// Applying a "covariant" transform is always a no-op
v1
}

(ConstantTerm(c1), ConstantTerm(c2)) => {
self.constant_term(c1.xform(c2))
}
(ConstantTerm(c1), ConstantTerm(c2)) => self.constant_term(c1.xform(c2)),

_ => {
&*self.terms_cx.arena.alloc(TransformTerm(v1, v2))
}
_ => &*self.terms_cx.arena.alloc(TransformTerm(v1, v2)),
}
}

Expand All @@ -299,13 +288,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
// README.md for a discussion on dep-graph management.
self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id));

self.add_constraints_from_substs(
generics,
trait_ref.def_id,
trait_def.generics.types.as_slice(),
trait_def.generics.regions.as_slice(),
trait_ref.substs,
variance);
self.add_constraints_from_substs(generics,
trait_ref.def_id,
trait_def.generics.types.as_slice(),
trait_def.generics.regions.as_slice(),
trait_ref.substs,
variance);
}

/// Adds constraints appropriate for an instance of `ty` appearing
Expand All @@ -321,9 +309,12 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {

match ty.sty {
ty::TyBool |
ty::TyChar | ty::TyInt(_) | ty::TyUint(_) |
ty::TyFloat(_) | ty::TyStr => {
/* leaf type -- noop */
ty::TyChar |
ty::TyInt(_) |
ty::TyUint(_) |
ty::TyFloat(_) |
ty::TyStr => {
// leaf type -- noop
}

ty::TyClosure(..) => {
Expand All @@ -340,7 +331,6 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
self.add_constraints_from_ty(generics, typ, variance);
}


ty::TyRawPtr(ref mt) => {
self.add_constraints_from_mt(generics, mt, variance);
}
Expand All @@ -367,13 +357,16 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
assert!(item_type.generics.regions.is_empty_in(subst::SelfSpace));
assert!(item_type.generics.regions.is_empty_in(subst::FnSpace));

self.add_constraints_from_substs(
generics,
def.did,
item_type.generics.types.get_slice(subst::TypeSpace),
item_type.generics.regions.get_slice(subst::TypeSpace),
substs,
variance);
self.add_constraints_from_substs(generics,
def.did,
item_type.generics
.types
.get_slice(subst::TypeSpace),
item_type.generics
.regions
.get_slice(subst::TypeSpace),
substs,
variance);
}

ty::TyProjection(ref data) => {
Expand All @@ -385,19 +378,17 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
// README.md for a discussion on dep-graph management.
self.tcx().dep_graph.read(ItemVariances::to_dep_node(&trait_ref.def_id));

self.add_constraints_from_substs(
generics,
trait_ref.def_id,
trait_def.generics.types.as_slice(),
trait_def.generics.regions.as_slice(),
trait_ref.substs,
variance);
self.add_constraints_from_substs(generics,
trait_ref.def_id,
trait_def.generics.types.as_slice(),
trait_def.generics.regions.as_slice(),
trait_ref.substs,
variance);
}

ty::TyTrait(ref data) => {
let poly_trait_ref =
data.principal_trait_ref_with_self_ty(self.tcx(),
self.tcx().types.err);
let poly_trait_ref = data.principal_trait_ref_with_self_ty(self.tcx(),
self.tcx().types.err);

// The type `Foo<T+'a>` is contravariant w/r/t `'a`:
let contra = self.contravariant(variance);
Expand Down Expand Up @@ -440,7 +431,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {

ty::TyInfer(..) => {
bug!("unexpected type encountered in \
variance inference: {}", ty);
variance inference: {}",
ty);
}
}
}
Expand All @@ -460,20 +452,25 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
variance);

for p in type_param_defs {
let variance_decl =
self.declared_variance(p.def_id, def_id, TypeParam,
p.space, p.index as usize);
let variance_decl = self.declared_variance(p.def_id,
def_id,
TypeParam,
p.space,
p.index as usize);
let variance_i = self.xform(variance, variance_decl);
let substs_ty = *substs.types.get(p.space, p.index as usize);
debug!("add_constraints_from_substs: variance_decl={:?} variance_i={:?}",
variance_decl, variance_i);
variance_decl,
variance_i);
self.add_constraints_from_ty(generics, substs_ty, variance_i);
}

for p in region_param_defs {
let variance_decl =
self.declared_variance(p.def_id, def_id,
RegionParam, p.space, p.index as usize);
let variance_decl = self.declared_variance(p.def_id,
def_id,
RegionParam,
p.space,
p.index as usize);
let variance_i = self.xform(variance, variance_decl);
let substs_r = *substs.regions.get(p.space, p.index as usize);
self.add_constraints_from_region(generics, substs_r, variance_i);
Expand Down Expand Up @@ -503,24 +500,27 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
variance: VarianceTermPtr<'a>) {
match region {
ty::ReEarlyBound(ref data) => {
let def_id =
generics.regions.get(data.space, data.index as usize).def_id;
let def_id = generics.regions.get(data.space, data.index as usize).def_id;
let node_id = self.tcx().map.as_local_node_id(def_id).unwrap();
if self.is_to_be_inferred(node_id) {
let index = self.inferred_index(node_id);
self.add_constraint(index, variance);
}
}

ty::ReStatic => { }
ty::ReStatic => {}

ty::ReLateBound(..) => {
// We do not infer variance for region parameters on
// methods or in fn types.
}

ty::ReFree(..) | ty::ReScope(..) | ty::ReVar(..) |
ty::ReSkolemized(..) | ty::ReEmpty | ty::ReErased => {
ty::ReFree(..) |
ty::ReScope(..) |
ty::ReVar(..) |
ty::ReSkolemized(..) |
ty::ReEmpty |
ty::ReErased => {
// We don't expect to see anything but 'static or bound
// regions when visiting member types or method types.
bug!("unexpected region encountered in variance \
Expand Down
1 change: 0 additions & 1 deletion src/librustc_typeck/variance/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,4 +34,3 @@ pub fn infer_variance<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
solve::solve_constraints(constraints_cx);
tcx.variance_computed.set(true);
}

Loading