diff options
Diffstat (limited to 'compiler/rustc_trait_selection/src/traits')
10 files changed, 19 insertions, 19 deletions
diff --git a/compiler/rustc_trait_selection/src/traits/codegen.rs b/compiler/rustc_trait_selection/src/traits/codegen.rs index 4b6784aee97..249205f8b12 100644 --- a/compiler/rustc_trait_selection/src/traits/codegen.rs +++ b/compiler/rustc_trait_selection/src/traits/codegen.rs @@ -46,8 +46,8 @@ pub fn codegen_fulfill_obligation<'tcx>( Ok(Some(selection)) => selection, Ok(None) => { // Ambiguity can happen when monomorphizing during trans - // expands to some humongo type that never occurred - // statically -- this humongo type can then overflow, + // expands to some humongous type that never occurred + // statically -- this humongous type can then overflow, // leading to an ambiguous result. So report this as an // overflow bug, since I believe this is the only case // where ambiguity can result. diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs index ec4f8084e21..40c3f4047ae 100644 --- a/compiler/rustc_trait_selection/src/traits/coherence.rs +++ b/compiler/rustc_trait_selection/src/traits/coherence.rs @@ -114,7 +114,7 @@ where } // In the case where we detect an error, run the check again, but - // this time tracking intercrate ambuiguity causes for better + // this time tracking intercrate ambiguity causes for better // diagnostics. (These take time and can lead to false errors.) tcx.infer_ctxt().enter(|infcx| { let selcx = &mut SelectionContext::intercrate(&infcx); @@ -762,7 +762,7 @@ fn ty_is_local_constructor(ty: Ty<'_>, in_crate: InCrate) -> bool { ty::Foreign(did) => def_id_is_local(did, in_crate), ty::Opaque(..) => { // This merits some explanation. - // Normally, opaque types are not involed when performing + // Normally, opaque types are not involved when performing // coherence checking, since it is illegal to directly // implement a trait on an opaque type. However, we might // end up looking at an opaque type during coherence checking diff --git a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs index d114515eca1..2b9cc75f1b7 100644 --- a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs +++ b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs @@ -408,7 +408,7 @@ impl<'a, 'tcx> AbstractConstBuilder<'a, 'tcx> { } /// Builds the abstract const by walking the thir and bailing out when - /// encountering an unspported operation. + /// encountering an unsupported operation. fn build(mut self) -> Result<&'tcx [Node<'tcx>], ErrorGuaranteed> { debug!("Abstractconstbuilder::build: body={:?}", &*self.body); self.recurse_build(self.body_id)?; @@ -701,7 +701,7 @@ struct ConstUnifyCtxt<'tcx> { impl<'tcx> ConstUnifyCtxt<'tcx> { // Substitutes generics repeatedly to allow AbstractConsts to unify where a - // ConstKind::Unevalated could be turned into an AbstractConst that would unify e.g. + // ConstKind::Unevaluated could be turned into an AbstractConst that would unify e.g. // Param(N) should unify with Param(T), substs: [Unevaluated("T2", [Unevaluated("T3", [Param(N)])])] #[inline] #[instrument(skip(self), level = "debug")] diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 39da99ac252..505d78d800a 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -230,7 +230,7 @@ fn suggest_restriction<'tcx>( { // We know we have an `impl Trait` that doesn't satisfy a required projection. - // Find all of the ocurrences of `impl Trait` for `Trait` in the function arguments' + // Find all of the occurrences of `impl Trait` for `Trait` in the function arguments' // types. There should be at least one, but there might be *more* than one. In that // case we could just ignore it and try to identify which one needs the restriction, // but instead we choose to suggest replacing all instances of `impl Trait` with `T` diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs index 1b862834467..c004848c6c8 100644 --- a/compiler/rustc_trait_selection/src/traits/fulfill.rs +++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs @@ -61,7 +61,7 @@ pub struct FulfillmentContext<'tcx> { // Should this fulfillment context register type-lives-for-region // obligations on its parent infcx? In some cases, region // obligations are either already known to hold (normalization) or - // hopefully verifed elsewhere (type-impls-bound), and therefore + // hopefully verified elsewhere (type-impls-bound), and therefore // should not be checked. // // Note that if we are normalizing a type that we already diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs index 88750f272c8..8240f5c542a 100644 --- a/compiler/rustc_trait_selection/src/traits/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/mod.rs @@ -539,7 +539,7 @@ fn prepare_vtable_segments<'tcx, T>( // the main traversal loop: // basically we want to cut the inheritance directed graph into a few non-overlapping slices of nodes // that each node is emitted after all its descendents have been emitted. - // so we convert the directed graph into a tree by skipping all previously visted nodes using a visited set. + // so we convert the directed graph into a tree by skipping all previously visited nodes using a visited set. // this is done on the fly. // Each loop run emits a slice - it starts by find a "childless" unvisited node, backtracking upwards, and it // stops after it finds a node that has a next-sibling node. diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs index d4ec677a0b1..6bba6b19b90 100644 --- a/compiler/rustc_trait_selection/src/traits/project.rs +++ b/compiler/rustc_trait_selection/src/traits/project.rs @@ -1566,7 +1566,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>( // fn bar<T:SomeTrait<Foo=usize>>(...) { ... } // ``` // - // Doesn't the `T : Sometrait<Foo=usize>` predicate help + // Doesn't the `T : SomeTrait<Foo=usize>` predicate help // resolve `T::Foo`? And of course it does, but in fact // that single predicate is desugared into two predicates // in the compiler: a trait predicate (`T : SomeTrait`) and a @@ -1989,7 +1989,7 @@ fn confirm_impl_candidate<'cx, 'tcx>( // Get obligations corresponding to the predicates from the where-clause of the // associated type itself. // Note: `feature(generic_associated_types)` is required to write such -// predicates, even for non-generic associcated types. +// predicates, even for non-generic associated types. fn assoc_ty_own_obligations<'cx, 'tcx>( selcx: &mut SelectionContext<'cx, 'tcx>, obligation: &ProjectionTyObligation<'tcx>, diff --git a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs index 8997a7895ab..25cc6e9f9f2 100644 --- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs +++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs @@ -58,7 +58,7 @@ impl<'cx, 'tcx> AtExt<'tcx> for At<'cx, 'tcx> { return InferOk { value: kinds, obligations }; } - // Errors and ambiuity in dropck occur in two cases: + // Errors and ambiguity in dropck occur in two cases: // - unresolved inference variables at the end of typeck // - non well-formed types where projections cannot be resolved // Either of these should have created an error before. diff --git a/compiler/rustc_trait_selection/src/traits/relationships.rs b/compiler/rustc_trait_selection/src/traits/relationships.rs index b13646ba1a0..56bdeafeeca 100644 --- a/compiler/rustc_trait_selection/src/traits/relationships.rs +++ b/compiler/rustc_trait_selection/src/traits/relationships.rs @@ -23,7 +23,7 @@ pub(crate) fn update<'tcx, T>( ..tpred.trait_ref }; - // Then contstruct a new obligation with Self = () added + // Then construct a new obligation with Self = () added // to the ParamEnv, and see if it holds. let o = rustc_infer::traits::Obligation::new( ObligationCause::dummy(), diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs index 42f17721f9b..1271b679d5c 100644 --- a/compiler/rustc_trait_selection/src/traits/select/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs @@ -562,7 +562,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { { // If the result is something that we can cache, then mark this // entry as 'complete'. This will allow us to skip evaluating the - // suboligations at all the next time we evaluate the projection + // subobligations at all the next time we evaluate the projection // predicate. self.infcx .inner @@ -751,7 +751,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // provisional caches entries and inserting them into the evaluation cache // // This ensures that when a query reads this entry from the evaluation cache, - // it will end up (transitively) dependening on all of the incr-comp dependencies + // it will end up (transitively) depending on all of the incr-comp dependencies // created during the evaluation of this trait. For example, evaluating a trait // will usually require us to invoke `type_of(field_def_id)` to determine the // constituent types, and we want any queries reading from this evaluation @@ -1475,7 +1475,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { /// `No` if it does not. Return `Ambiguous` in the case that the projection type is a GAT, /// and applying this env_predicate constrains any of the obligation's GAT substitutions. /// - /// This behavior is a somewhat of a hack to prevent overconstraining inference variables + /// This behavior is a somewhat of a hack to prevent over-constraining inference variables /// in cases like #91762. pub(super) fn match_projection_projections( &mut self, @@ -1729,7 +1729,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // marker trait impls. // // Without this restriction, we could end up accidentally - // constrainting inference variables based on an arbitrarily + // constraining inference variables based on an arbitrarily // chosen trait impl. // // Imagine we have the following code: @@ -1758,7 +1758,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // some other means (e.g. type-checking of a function). We will // then be in a position to drop marker trait candidates // without constraining inference variables (since there are - // none left to constrin) + // none left to constrain) // 2) Be left with some unconstrained inference variables. We // will then correctly report an inference error, since the // existence of multiple marker trait impls tells us nothing @@ -2518,7 +2518,7 @@ struct ProvisionalEvaluationCache<'tcx> { /// - `A B C` and we add a cache for the result of C (DFN 2) /// - Then we have a stack `A B D` where `D` has DFN 3 /// - We try to solve D by evaluating E: `A B D E` (DFN 4) - /// - `E` generates various cache entries which have cyclic dependices on `B` + /// - `E` generates various cache entries which have cyclic dependencies on `B` /// - `A B D E F` and so forth /// - the DFN of `F` for example would be 5 /// - then we determine that `E` is in error -- we will then clear |