From d2ff5d696cfa6003b10a124910259fe5a5885271 Mon Sep 17 00:00:00 2001 From: Diogo Sousa Date: Fri, 10 Aug 2018 18:13:43 +0100 Subject: [PATCH] Typos and style fixes. --- src/librustc/traits/auto_trait.rs | 8 ++++---- src/librustc/traits/fulfill.rs | 3 +-- src/librustc/traits/mod.rs | 2 +- src/librustc/traits/select.rs | 20 ++++++++++--------- .../obligation_forest/mod.rs | 6 +++--- .../obligation_forest/test.rs | 8 +++----- 6 files changed, 23 insertions(+), 24 deletions(-) diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs index 8f106a081253..79fc9b449238 100644 --- a/src/librustc/traits/auto_trait.rs +++ b/src/librustc/traits/auto_trait.rs @@ -73,16 +73,16 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { /// ``` /// struct Foo { data: Box } /// ``` - + /// /// then this might return that Foo: Send if T: Send (encoded in the AutoTraitResult type). /// The analysis attempts to account for custom impls as well as other complex cases. This /// result is intended for use by rustdoc and other such consumers. - + /// /// (Note that due to the coinductive nature of Send, the full and correct result is actually /// quite simple to generate. That is, when a type has no custom impl, it is Send iff its field /// types are all Send. So, in our example, we might have that Foo: Send if Box: Send. /// But this is often not the best way to present to the user.) - + /// /// Warning: The API should be considered highly unstable, and it may be refactored or removed /// in the future. pub fn find_auto_trait_generics( @@ -288,7 +288,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { // hold. // // One additional consideration is supertrait bounds. Normally, a ParamEnv is only ever - // consutrcted once for a given type. As part of the construction process, the ParamEnv will + // constructed once for a given type. As part of the construction process, the ParamEnv will // have any supertrait bounds normalized - e.g. if we have a type 'struct Foo', the // ParamEnv will contain 'T: Copy' and 'T: Clone', since 'Copy: Clone'. When we construct our // own ParamEnv, we need to do this ourselves, through traits::elaborate_predicates, or else diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index 19ee2c1aabfa..0f330504334a 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -45,7 +45,6 @@ impl<'tcx> ForestObligation for PendingPredicateObligation<'tcx> { /// along. Once all type inference constraints have been generated, the /// method `select_all_or_error` can be used to report any remaining /// ambiguous cases as errors. - pub struct FulfillmentContext<'tcx> { // A list of all obligations that have been registered with this // fulfillment context. @@ -89,7 +88,7 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> { /// Attempts to select obligations using `selcx`. fn select(&mut self, selcx: &mut SelectionContext<'a, 'gcx, 'tcx>) - -> Result<(),Vec>> { + -> Result<(), Vec>> { debug!("select(obligation-forest-size={})", self.predicates.len()); let mut errors = Vec::new(); diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index 6b1092814a40..f394fbd9c7b4 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -644,7 +644,7 @@ pub fn normalize_param_env_or_error<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // have the errors get reported at a defined place (e.g., // during typeck). Instead I have all parameter // environments, in effect, going through this function - // and hence potentially reporting errors. This ensurse of + // and hence potentially reporting errors. This ensures of // course that we never forget to normalize (the // alternative seemed like it would involve a lot of // manual invocations of this fn -- and then we'd have to diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index ab71d13ab068..7e504094ad86 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -582,7 +582,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { match self.confirm_candidate(obligation, candidate) { Err(SelectionError::Overflow) => { assert!(self.query_mode == TraitQueryMode::Canonical); - return Err(SelectionError::Overflow); + Err(SelectionError::Overflow) }, Err(e) => Err(e), Ok(candidate) => Ok(Some(candidate)) @@ -879,7 +879,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { // must be met of course). One obvious case this comes up is // marker traits like `Send`. Think of a linked list: // - // struct List { data: T, next: Option>> { + // struct List { data: T, next: Option>> } // // `Box>` will be `Send` if `T` is `Send` and // `Option>>` is `Send`, and in turn @@ -1407,7 +1407,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { stack: &TraitObligationStack<'o, 'tcx>) -> Result, SelectionError<'tcx>> { - let TraitObligationStack { obligation, .. } = *stack; + let obligation = stack.obligation; let ref obligation = Obligation { param_env: obligation.param_env, cause: obligation.cause.clone(), @@ -1788,9 +1788,9 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { } fn assemble_candidates_from_auto_impls(&mut self, - obligation: &TraitObligation<'tcx>, - candidates: &mut SelectionCandidateSet<'tcx>) - -> Result<(), SelectionError<'tcx>> + obligation: &TraitObligation<'tcx>, + candidates: &mut SelectionCandidateSet<'tcx>) + -> Result<(), SelectionError<'tcx>> { // OK to skip binder here because the tests we do below do not involve bound regions let self_ty = *obligation.self_ty().skip_binder(); @@ -2433,7 +2433,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { fn confirm_candidate(&mut self, obligation: &TraitObligation<'tcx>, candidate: SelectionCandidate<'tcx>) - -> Result,SelectionError<'tcx>> + -> Result, SelectionError<'tcx>> { debug!("confirm_candidate({:?}, {:?})", obligation, @@ -2612,11 +2612,11 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { let mut obligations = self.collect_predicates_for_types( obligation.param_env, cause, - obligation.recursion_depth+1, + obligation.recursion_depth + 1, trait_def_id, nested); - let trait_obligations = self.in_snapshot(|this, snapshot| { + let trait_obligations: Vec> = self.in_snapshot(|this, snapshot| { let poly_trait_ref = obligation.predicate.to_poly_trait_ref(); let (trait_ref, skol_map) = this.infcx().skolemize_late_bound_regions(&poly_trait_ref); @@ -2630,6 +2630,8 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> { snapshot) }); + // Adds the predicates from the trait. Note that this contains a `Self: Trait` + // predicate as usual. It won't have any effect since auto traits are coinductive. obligations.extend(trait_obligations); debug!("vtable_auto_impl: obligations={:?}", obligations); diff --git a/src/librustc_data_structures/obligation_forest/mod.rs b/src/librustc_data_structures/obligation_forest/mod.rs index 7ef88852685d..094c1cec31ac 100644 --- a/src/librustc_data_structures/obligation_forest/mod.rs +++ b/src/librustc_data_structures/obligation_forest/mod.rs @@ -187,7 +187,7 @@ impl ObligationForest { -> Result<(), ()> { if self.done_cache.contains(obligation.as_predicate()) { - return Ok(()) + return Ok(()); } match self.waiting_cache.entry(obligation.as_predicate().clone()) { @@ -269,8 +269,8 @@ impl ObligationForest { self.nodes[index]); let result = match self.nodes[index] { - Node { state: ref _state, ref mut obligation, .. } - if _state.get() == NodeState::Pending => + Node { ref state, ref mut obligation, .. } + if state.get() == NodeState::Pending => { processor.process_obligation(obligation) } diff --git a/src/librustc_data_structures/obligation_forest/test.rs b/src/librustc_data_structures/obligation_forest/test.rs index 527a1ef0ec44..c27a65e34310 100644 --- a/src/librustc_data_structures/obligation_forest/test.rs +++ b/src/librustc_data_structures/obligation_forest/test.rs @@ -59,8 +59,9 @@ impl ObligationProcessor for ClosureObligationProcessor(&mut self, _cycle: I, _marker: PhantomData<&'c Self::Obligation>) - where I: Clone + Iterator { - } + where I: Clone + Iterator + { + } } @@ -350,11 +351,8 @@ fn done_dependency() { }, |_|{})); assert_eq!(ok, vec!["(A,B,C): Sized"]); assert_eq!(err.len(), 0); - - } - #[test] fn orphan() { // check that orphaned nodes are handled correctly