Auto merge of #100707 - dzvon:fix-typo, r=davidtwco
Fix a bunch of typo This PR will fix some typos detected by [typos]. I only picked the ones I was sure were spelling errors to fix, mostly in the comments. [typos]: https://github.com/crate-ci/typos
This commit is contained in:
commit
b32223fec1
140 changed files with 171 additions and 171 deletions
|
@ -1179,7 +1179,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
|||
) -> hir::Ty<'hir> {
|
||||
// Check whether we should interpret this as a bare trait object.
|
||||
// This check mirrors the one in late resolution. We only introduce this special case in
|
||||
// the rare occurence we need to lower `Fresh` anonymous lifetimes.
|
||||
// the rare occurrence we need to lower `Fresh` anonymous lifetimes.
|
||||
// The other cases when a qpath should be opportunistically made a trait object are handled
|
||||
// by `ty_path`.
|
||||
if qself.is_none()
|
||||
|
|
|
@ -1800,7 +1800,7 @@ pub(crate) enum ForbiddenLetReason {
|
|||
NotSupportedOr(Span),
|
||||
/// A let chain with invalid parentheses
|
||||
///
|
||||
/// For exemple, `let 1 = 1 && (expr && expr)` is allowed
|
||||
/// For example, `let 1 = 1 && (expr && expr)` is allowed
|
||||
/// but `(let 1 = 1 && (let 1 = 1 && (let 1 = 1))) && let a = 1` is not
|
||||
NotSupportedParentheses(Span),
|
||||
}
|
||||
|
|
|
@ -342,7 +342,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
|
|||
|
||||
let ret_place = codegen_place(fx, destination);
|
||||
|
||||
// Handle special calls like instrinsics and empty drop glue.
|
||||
// Handle special calls like intrinsics and empty drop glue.
|
||||
let instance = if let ty::FnDef(def_id, substs) = *fn_ty.kind() {
|
||||
let instance = ty::Instance::resolve(fx.tcx, ty::ParamEnv::reveal_all(), def_id, substs)
|
||||
.unwrap()
|
||||
|
|
|
@ -59,7 +59,7 @@ pub(crate) fn check_constants(fx: &mut FunctionCx<'_, '_, '_>) -> bool {
|
|||
ErrorHandled::TooGeneric => {
|
||||
span_bug!(
|
||||
constant.span,
|
||||
"codgen encountered polymorphic constant: {:?}",
|
||||
"codegen encountered polymorphic constant: {:?}",
|
||||
err
|
||||
);
|
||||
}
|
||||
|
|
|
@ -203,7 +203,7 @@ pub(crate) fn codegen_intrinsic_call<'tcx>(
|
|||
sym::transmute => {
|
||||
crate::base::codegen_panic(fx, "Transmuting to uninhabited type.", source_info);
|
||||
}
|
||||
_ => unimplemented!("unsupported instrinsic {}", intrinsic),
|
||||
_ => unimplemented!("unsupported intrinsic {}", intrinsic),
|
||||
}
|
||||
return;
|
||||
};
|
||||
|
|
|
@ -540,7 +540,7 @@ pub fn linking_symbol_name_for_instance_in_crate<'tcx>(
|
|||
.map(|fnabi| (fnabi.conv, &fnabi.args[..]))
|
||||
.unwrap_or((Conv::Rust, &[]));
|
||||
|
||||
// Decorate symbols with prefices, suffices and total number of bytes of arguments.
|
||||
// Decorate symbols with prefixes, suffixes and total number of bytes of arguments.
|
||||
// Reference: https://docs.microsoft.com/en-us/cpp/build/reference/decorated-names?view=msvc-170
|
||||
let (prefix, suffix) = match conv {
|
||||
Conv::X86Fastcall => ("@", "@"),
|
||||
|
|
|
@ -191,7 +191,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
|||
// errored or at least linted
|
||||
ErrorHandled::Reported(_) | ErrorHandled::Linted => {}
|
||||
ErrorHandled::TooGeneric => {
|
||||
span_bug!(const_.span, "codgen encountered polymorphic constant: {:?}", err)
|
||||
span_bug!(const_.span, "codegen encountered polymorphic constant: {:?}", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -320,7 +320,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
let (a_offset, b_offset) =
|
||||
match (self.ptr_try_get_alloc_id(a), self.ptr_try_get_alloc_id(b)) {
|
||||
(Err(a), Err(b)) => {
|
||||
// Neither poiner points to an allocation.
|
||||
// Neither pointer points to an allocation.
|
||||
// If these are inequal or null, this *will* fail the deref check below.
|
||||
(a, b)
|
||||
}
|
||||
|
|
|
@ -437,7 +437,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
msg,
|
||||
})
|
||||
}
|
||||
// Ensure we never consider the null pointer dereferencable.
|
||||
// Ensure we never consider the null pointer dereferenceable.
|
||||
if M::Provenance::OFFSET_IS_ADDR {
|
||||
assert_ne!(ptr.addr(), Size::ZERO);
|
||||
}
|
||||
|
@ -914,7 +914,7 @@ impl<'tcx, 'a, Prov: Provenance, Extra> AllocRefMut<'a, 'tcx, Prov, Extra> {
|
|||
self.write_scalar(alloc_range(offset, self.tcx.data_layout().pointer_size), val)
|
||||
}
|
||||
|
||||
/// Mark the entire referenced range as uninitalized
|
||||
/// Mark the entire referenced range as uninitialized
|
||||
pub fn write_uninit(&mut self) -> InterpResult<'tcx> {
|
||||
Ok(self
|
||||
.alloc
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
//! This file implements "place projections"; basically a symmetric API for 3 types: MPlaceTy, OpTy, PlaceTy.
|
||||
//!
|
||||
//! OpTy and PlaceTy genrally work by "let's see if we are actually an MPlaceTy, and do something custom if not".
|
||||
//! OpTy and PlaceTy generally work by "let's see if we are actually an MPlaceTy, and do something custom if not".
|
||||
//! For PlaceTy, the custom thing is basically always to call `force_allocation` and then use the MPlaceTy logic anyway.
|
||||
//! For OpTy, the custom thing on field pojections has to be pretty clever (since `Operand::Immediate` can have fields),
|
||||
//! but for array/slice operations it only has to worry about `Operand::Uninit`. That makes the value part trivial,
|
||||
|
|
|
@ -217,7 +217,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
// When comparing the PassMode, we have to be smart about comparing the attributes.
|
||||
let arg_attr_compat = |a1: &ArgAttributes, a2: &ArgAttributes| {
|
||||
// There's only one regular attribute that matters for the call ABI: InReg.
|
||||
// Everything else is things like noalias, dereferencable, nonnull, ...
|
||||
// Everything else is things like noalias, dereferenceable, nonnull, ...
|
||||
// (This also applies to pointee_size, pointee_align.)
|
||||
if a1.regular.contains(ArgAttribute::InReg) != a2.regular.contains(ArgAttribute::InReg)
|
||||
{
|
||||
|
@ -556,7 +556,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
.tcx
|
||||
.struct_tail_erasing_lifetimes(receiver_place.layout.ty, self.param_env);
|
||||
let ty::Dynamic(data, ..) = receiver_tail.kind() else {
|
||||
span_bug!(self.cur_span(), "dyanmic call on non-`dyn` type {}", receiver_tail)
|
||||
span_bug!(self.cur_span(), "dynamic call on non-`dyn` type {}", receiver_tail)
|
||||
};
|
||||
|
||||
// Get the required information from the vtable.
|
||||
|
|
|
@ -32,7 +32,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
|
|||
Ok(vtable_ptr.into())
|
||||
}
|
||||
|
||||
/// Returns a high-level representation of the entires of the given vtable.
|
||||
/// Returns a high-level representation of the entries of the given vtable.
|
||||
pub fn get_vtable_entries(
|
||||
&self,
|
||||
vtable: Pointer<Option<M::Provenance>>,
|
||||
|
|
|
@ -29,7 +29,7 @@ impl Fingerprint {
|
|||
// quality hash values, let's still combine the two values because the
|
||||
// Fingerprints in DefPathHash have the StableCrateId portion which is
|
||||
// the same for all DefPathHashes from the same crate. Combining the
|
||||
// two halfs makes sure we get a good quality hash in such cases too.
|
||||
// two halves makes sure we get a good quality hash in such cases too.
|
||||
self.0.wrapping_mul(3).wrapping_add(self.1)
|
||||
}
|
||||
|
||||
|
@ -120,7 +120,7 @@ impl FingerprintHasher for crate::unhash::Unhasher {
|
|||
// quality hash values, let's still combine the two values because the
|
||||
// Fingerprints in DefPathHash have the StableCrateId portion which is
|
||||
// the same for all DefPathHashes from the same crate. Combining the
|
||||
// two halfs makes sure we get a good quality hash in such cases too.
|
||||
// two halves makes sure we get a good quality hash in such cases too.
|
||||
//
|
||||
// Since `Unhasher` is used only in the context of HashMaps, it is OK
|
||||
// to combine the two components in an order-independent way (which is
|
||||
|
|
|
@ -430,7 +430,7 @@ impl TtParser {
|
|||
}
|
||||
}
|
||||
MatcherLoc::Delimited => {
|
||||
// Entering the delimeter is trivial.
|
||||
// Entering the delimiter is trivial.
|
||||
mp.idx += 1;
|
||||
self.cur_mps.push(mp);
|
||||
}
|
||||
|
|
|
@ -976,7 +976,7 @@ impl<'tt> TokenSet<'tt> {
|
|||
self.maybe_empty = false;
|
||||
}
|
||||
|
||||
// Adds `tok` to the set for `self`, marking sequence as non-empy.
|
||||
// Adds `tok` to the set for `self`, marking sequence as non-empty.
|
||||
fn add_one(&mut self, tt: TtHandle<'tt>) {
|
||||
if !self.tokens.contains(&tt) {
|
||||
self.tokens.push(tt);
|
||||
|
|
|
@ -199,7 +199,7 @@ fn ty_to_string<'tcx>(infcx: &InferCtxt<'_, 'tcx>, ty: Ty<'tcx>) -> String {
|
|||
}
|
||||
|
||||
/// We don't want to directly use `ty_to_string` for closures as their type isn't really
|
||||
/// something users are familar with. Directly printing the `fn_sig` of closures also
|
||||
/// something users are familiar with. Directly printing the `fn_sig` of closures also
|
||||
/// doesn't work as they actually use the "rust-call" API.
|
||||
fn closure_as_fn_str<'tcx>(infcx: &InferCtxt<'_, 'tcx>, ty: Ty<'tcx>) -> String {
|
||||
let ty::Closure(_, substs) = ty.kind() else { unreachable!() };
|
||||
|
|
|
@ -1333,7 +1333,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
|
|||
/// `resolve_vars_if_possible` as well as `fully_resolve`.
|
||||
///
|
||||
/// Make sure to call [`InferCtxt::process_registered_region_obligations`]
|
||||
/// first, or preferrably use [`InferCtxt::check_region_obligations_and_report_errors`]
|
||||
/// first, or preferably use [`InferCtxt::check_region_obligations_and_report_errors`]
|
||||
/// to do both of these operations together.
|
||||
pub fn resolve_regions_and_report_errors(
|
||||
&self,
|
||||
|
|
|
@ -100,7 +100,7 @@ impl Default for InferCtxtUndoLogs<'_> {
|
|||
}
|
||||
|
||||
/// The UndoLogs trait defines how we undo a particular kind of action (of type T). We can undo any
|
||||
/// action that is convertable into an UndoLog (per the From impls above).
|
||||
/// action that is convertible into an UndoLog (per the From impls above).
|
||||
impl<'tcx, T> UndoLogs<T> for InferCtxtUndoLogs<'tcx>
|
||||
where
|
||||
UndoLog<'tcx>: From<T>,
|
||||
|
|
|
@ -176,7 +176,7 @@ pub fn parse_check_cfg(specs: Vec<String>) -> CheckCfg {
|
|||
let ident = arg.ident().expect("multi-segment cfg key");
|
||||
names_valid.insert(ident.name.to_string());
|
||||
} else {
|
||||
error!("`names()` arguments must be simple identifers");
|
||||
error!("`names()` arguments must be simple identifiers");
|
||||
}
|
||||
}
|
||||
continue 'specs;
|
||||
|
@ -204,7 +204,7 @@ pub fn parse_check_cfg(specs: Vec<String>) -> CheckCfg {
|
|||
continue 'specs;
|
||||
} else {
|
||||
error!(
|
||||
"`values()` first argument must be a simple identifer"
|
||||
"`values()` first argument must be a simple identifier"
|
||||
);
|
||||
}
|
||||
} else if args.is_empty() {
|
||||
|
|
|
@ -268,7 +268,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
|
|||
},
|
||||
ty::Closure(..) => {
|
||||
cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
|
||||
// FIXME(davidtwco): this isn't properly translatable becauses of the
|
||||
// FIXME(davidtwco): this isn't properly translatable because of the
|
||||
// pre/post strings
|
||||
lint.build(fluent::lint::unused_closure)
|
||||
.set_arg("count", plural_len)
|
||||
|
@ -281,7 +281,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
|
|||
}
|
||||
ty::Generator(..) => {
|
||||
cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
|
||||
// FIXME(davidtwco): this isn't properly translatable becauses of the
|
||||
// FIXME(davidtwco): this isn't properly translatable because of the
|
||||
// pre/post strings
|
||||
lint.build(fluent::lint::unused_generator)
|
||||
.set_arg("count", plural_len)
|
||||
|
@ -310,7 +310,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
|
|||
) -> bool {
|
||||
if let Some(attr) = cx.tcx.get_attr(def_id, sym::must_use) {
|
||||
cx.struct_span_lint(UNUSED_MUST_USE, span, |lint| {
|
||||
// FIXME(davidtwco): this isn't properly translatable becauses of the pre/post
|
||||
// FIXME(davidtwco): this isn't properly translatable because of the pre/post
|
||||
// strings
|
||||
let mut err = lint.build(fluent::lint::unused_def);
|
||||
err.set_arg("pre", descr_pre_path);
|
||||
|
|
|
@ -3206,7 +3206,7 @@ declare_lint! {
|
|||
/// [future-incompatible]: ../index.md#future-incompatible-lints
|
||||
pub REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS,
|
||||
Warn,
|
||||
"tranparent type contains an external ZST that is marked #[non_exhaustive] or contains private fields",
|
||||
"transparent type contains an external ZST that is marked #[non_exhaustive] or contains private fields",
|
||||
@future_incompatible = FutureIncompatibleInfo {
|
||||
reference: "issue #78586 <https://github.com/rust-lang/rust/issues/78586>",
|
||||
};
|
||||
|
|
|
@ -86,7 +86,7 @@ impl<'tcx> BasicBlocks<'tcx> {
|
|||
///
|
||||
/// You will only ever need this if you have also called [`BasicBlocks::as_mut_preserves_cfg`].
|
||||
/// All other methods that allow you to mutate the basic blocks also call this method
|
||||
/// themselves, thereby avoiding any risk of accidentaly cache invalidation.
|
||||
/// themselves, thereby avoiding any risk of accidentally cache invalidation.
|
||||
pub fn invalidate_cfg_cache(&mut self) {
|
||||
self.predecessor_cache.invalidate();
|
||||
self.switch_source_cache.invalidate();
|
||||
|
|
|
@ -1457,7 +1457,7 @@ pub struct PlaceRef<'tcx> {
|
|||
// Once we stop implementing `Ord` for `DefId`,
|
||||
// this impl will be unnecessary. Until then, we'll
|
||||
// leave this impl in place to prevent re-adding a
|
||||
// dependnecy on the `Ord` impl for `DefId`
|
||||
// dependency on the `Ord` impl for `DefId`
|
||||
impl<'tcx> !PartialOrd for PlaceRef<'tcx> {}
|
||||
|
||||
impl<'tcx> Place<'tcx> {
|
||||
|
|
|
@ -332,7 +332,7 @@ pub enum StatementKind<'tcx> {
|
|||
/// First, all three operands are evaluated. `src` and `dest` must each be a reference, pointer,
|
||||
/// or `Box` pointing to the same type `T`. `count` must evaluate to a `usize`. Then, `src` and
|
||||
/// `dest` are dereferenced, and `count * size_of::<T>()` bytes beginning with the first byte of
|
||||
/// the `src` place are copied to the continguous range of bytes beginning with the first byte
|
||||
/// the `src` place are copied to the contiguous range of bytes beginning with the first byte
|
||||
/// of `dest`.
|
||||
///
|
||||
/// **Needs clarification**: In what order are operands computed and dereferenced? It should
|
||||
|
@ -378,7 +378,7 @@ pub enum FakeReadCause {
|
|||
/// Some(closure_def_id).
|
||||
/// Otherwise, the value of the optional LocalDefId will be None.
|
||||
//
|
||||
// We can use LocaDefId here since fake read statements are removed
|
||||
// We can use LocalDefId here since fake read statements are removed
|
||||
// before codegen in the `CleanupNonCodegenStatements` pass.
|
||||
ForMatchedPlace(Option<LocalDefId>),
|
||||
|
||||
|
|
|
@ -1151,7 +1151,7 @@ rustc_queries! {
|
|||
/// Used by rustdoc.
|
||||
query rendered_const(def_id: DefId) -> String {
|
||||
storage(ArenaCacheSelector<'tcx>)
|
||||
desc { |tcx| "rendering constant intializer of `{}`", tcx.def_path_str(def_id) }
|
||||
desc { |tcx| "rendering constant initializer of `{}`", tcx.def_path_str(def_id) }
|
||||
cache_on_disk_if { def_id.is_local() }
|
||||
separate_provide_extern
|
||||
}
|
||||
|
|
|
@ -115,7 +115,7 @@ impl Node {
|
|||
matches!(self, Node::Trait(..))
|
||||
}
|
||||
|
||||
/// Trys to find the associated item that implements `trait_item_def_id`
|
||||
/// Tries to find the associated item that implements `trait_item_def_id`
|
||||
/// defined in this node.
|
||||
///
|
||||
/// If this returns `None`, the item can potentially still be found in
|
||||
|
|
|
@ -1498,17 +1498,17 @@ impl<'tcx> TyCtxt<'tcx> {
|
|||
// Create a dependency to the crate to be sure we re-execute this when the amount of
|
||||
// definitions change.
|
||||
self.ensure().hir_crate(());
|
||||
// Leak a read lock once we start iterating on definitions, to prevent adding new onces
|
||||
// Leak a read lock once we start iterating on definitions, to prevent adding new ones
|
||||
// while iterating. If some query needs to add definitions, it should be `ensure`d above.
|
||||
let definitions = self.definitions.leak();
|
||||
definitions.iter_local_def_id()
|
||||
}
|
||||
|
||||
pub fn def_path_table(self) -> &'tcx rustc_hir::definitions::DefPathTable {
|
||||
// Create a dependency to the crate to be sure we reexcute this when the amount of
|
||||
// Create a dependency to the crate to be sure we re-execute this when the amount of
|
||||
// definitions change.
|
||||
self.ensure().hir_crate(());
|
||||
// Leak a read lock once we start iterating on definitions, to prevent adding new onces
|
||||
// Leak a read lock once we start iterating on definitions, to prevent adding new ones
|
||||
// while iterating. If some query needs to add definitions, it should be `ensure`d above.
|
||||
let definitions = self.definitions.leak();
|
||||
definitions.def_path_table()
|
||||
|
@ -1517,10 +1517,10 @@ impl<'tcx> TyCtxt<'tcx> {
|
|||
pub fn def_path_hash_to_def_index_map(
|
||||
self,
|
||||
) -> &'tcx rustc_hir::def_path_hash_map::DefPathHashMap {
|
||||
// Create a dependency to the crate to be sure we reexcute this when the amount of
|
||||
// Create a dependency to the crate to be sure we re-execute this when the amount of
|
||||
// definitions change.
|
||||
self.ensure().hir_crate(());
|
||||
// Leak a read lock once we start iterating on definitions, to prevent adding new onces
|
||||
// Leak a read lock once we start iterating on definitions, to prevent adding new ones
|
||||
// while iterating. If some query needs to add definitions, it should be `ensure`d above.
|
||||
let definitions = self.definitions.leak();
|
||||
definitions.def_path_hash_to_def_index_map()
|
||||
|
|
|
@ -266,7 +266,7 @@ impl<'tcx> Generics {
|
|||
// Filter the default arguments.
|
||||
//
|
||||
// This currently uses structural equality instead
|
||||
// of semantic equivalance. While not ideal, that's
|
||||
// of semantic equivalence. While not ideal, that's
|
||||
// good enough for now as this should only be used
|
||||
// for diagnostics anyways.
|
||||
own_params.end -= self
|
||||
|
|
|
@ -756,7 +756,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
|
|||
// * the element type and length of the single array field, if
|
||||
// the first field is of array type, or
|
||||
//
|
||||
// * the homogenous field type and the number of fields.
|
||||
// * the homogeneous field type and the number of fields.
|
||||
let (e_ty, e_len, is_array) = if let ty::Array(e_ty, _) = f0_ty.kind() {
|
||||
// First ADT field is an array:
|
||||
|
||||
|
|
|
@ -702,7 +702,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
|
|||
let local_id = self.var_local_id(var, for_guard);
|
||||
let source_info = self.source_info(span);
|
||||
self.cfg.push(block, Statement { source_info, kind: StatementKind::StorageLive(local_id) });
|
||||
// Altough there is almost always scope for given variable in corner cases
|
||||
// Although there is almost always scope for given variable in corner cases
|
||||
// like #92893 we might get variable with no scope.
|
||||
if let Some(region_scope) = self.region_scope_tree.var_scope(var.0.local_id) && schedule_drop{
|
||||
self.schedule_drop(span, region_scope, local_id, DropKind::Storage);
|
||||
|
|
|
@ -13,7 +13,7 @@ pub(crate) fn dump_closure_profile<'tcx>(tcx: TyCtxt<'tcx>, closure_instance: In
|
|||
.append(true)
|
||||
.open(&format!("closure_profile_{}.csv", std::process::id()))
|
||||
else {
|
||||
eprintln!("Cound't open file for writing closure profile");
|
||||
eprintln!("Couldn't open file for writing closure profile");
|
||||
return;
|
||||
};
|
||||
|
||||
|
|
|
@ -1578,7 +1578,7 @@ impl<'a> Parser<'a> {
|
|||
Applicability::MachineApplicable,
|
||||
);
|
||||
|
||||
// Replace `'label: non_block_expr` with `'label: {non_block_expr}` in order to supress future errors about `break 'label`.
|
||||
// Replace `'label: non_block_expr` with `'label: {non_block_expr}` in order to suppress future errors about `break 'label`.
|
||||
let stmt = self.mk_stmt(span, StmtKind::Expr(expr));
|
||||
let blk = self.mk_block(vec![stmt], BlockCheckMode::Default, span);
|
||||
self.mk_expr(span, ExprKind::Block(blk, label))
|
||||
|
@ -2578,7 +2578,7 @@ impl<'a> Parser<'a> {
|
|||
}
|
||||
|
||||
pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm> {
|
||||
// Used to check the `let_chains` and `if_let_guard` features mostly by scaning
|
||||
// Used to check the `let_chains` and `if_let_guard` features mostly by scanning
|
||||
// `&&` tokens.
|
||||
fn check_let_expr(expr: &Expr) -> (bool, bool) {
|
||||
match expr.kind {
|
||||
|
|
|
@ -281,7 +281,7 @@ impl TokenCursor {
|
|||
if delim != Delimiter::Invisible {
|
||||
return (Token::new(token::OpenDelim(delim), sp.open), Spacing::Alone);
|
||||
}
|
||||
// No open delimeter to return; continue on to the next iteration.
|
||||
// No open delimiter to return; continue on to the next iteration.
|
||||
}
|
||||
};
|
||||
} else if let Some(frame) = self.stack.pop() {
|
||||
|
|
|
@ -49,7 +49,7 @@ impl Node {
|
|||
///
|
||||
/// For example, `ast::Visitor` has `visit_ident`, but `Ident`s are always
|
||||
/// stored inline within other AST nodes, so we don't implement `visit_ident`
|
||||
/// here. In constrast, we do implement `visit_expr` because `ast::Expr` is
|
||||
/// here. In contrast, we do implement `visit_expr` because `ast::Expr` is
|
||||
/// always stored as `P<ast::Expr>`, and every such expression should be
|
||||
/// measured separately.
|
||||
///
|
||||
|
|
|
@ -1368,7 +1368,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
|
|||
return;
|
||||
}
|
||||
|
||||
// We may fail to resolve higher-ranked lifetimes that are mentionned by APIT.
|
||||
// We may fail to resolve higher-ranked lifetimes that are mentioned by APIT.
|
||||
// AST-based resolution does not care for impl-trait desugaring, which are the
|
||||
// responibility of lowering. This may create a mismatch between the resolution
|
||||
// AST found (`region_def_id`) which points to HRTB, and what HIR allows.
|
||||
|
|
|
@ -1991,7 +1991,7 @@ impl<'a> Resolver<'a> {
|
|||
_ => panic!("invalid arg index"),
|
||||
}
|
||||
}
|
||||
// Cache the lookup to avoid parsing attributes for an iterm multiple times.
|
||||
// Cache the lookup to avoid parsing attributes for an item multiple times.
|
||||
self.legacy_const_generic_args.insert(def_id, Some(ret.clone()));
|
||||
return Some(ret);
|
||||
}
|
||||
|
|
|
@ -441,7 +441,7 @@ impl<'a> ResolverExpand for Resolver<'a> {
|
|||
}
|
||||
PathResult::Indeterminate => indeterminate = true,
|
||||
// We can only be sure that a path doesn't exist after having tested all the
|
||||
// posibilities, only at that time we can return false.
|
||||
// possibilities, only at that time we can return false.
|
||||
PathResult::Failed { .. } => {}
|
||||
PathResult::Module(_) => panic!("unexpected path resolution"),
|
||||
}
|
||||
|
|
|
@ -2311,7 +2311,7 @@ impl Target {
|
|||
load_builtin(target_triple).expect("built-in target")
|
||||
}
|
||||
TargetTriple::TargetJson { .. } => {
|
||||
panic!("built-in targets doens't support target-paths")
|
||||
panic!("built-in targets doesn't support target-paths")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3,7 +3,7 @@ use crate::spec::{cvs, LinkerFlavor, TargetOptions};
|
|||
pub fn opts() -> TargetOptions {
|
||||
// We cannot use `-nodefaultlibs` because compiler-rt has to be passed
|
||||
// as a path since it's not added to linker search path by the default.
|
||||
// There were attemts to make it behave like libgcc (so one can just use -l<name>)
|
||||
// There were attempts to make it behave like libgcc (so one can just use -l<name>)
|
||||
// but LLVM maintainers rejected it: https://reviews.llvm.org/D51440
|
||||
let pre_link_args =
|
||||
TargetOptions::link_args(LinkerFlavor::Gcc, &["-nolibc", "--unwindlib=none"]);
|
||||
|
|
|
@ -191,7 +191,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::GoalData<RustInterner<'tcx>>> for ty::Predi
|
|||
GenericArgKind::Const(..) => {
|
||||
chalk_ir::GoalData::All(chalk_ir::Goals::empty(interner))
|
||||
}
|
||||
GenericArgKind::Lifetime(lt) => bug!("unexpect well formed predicate: {:?}", lt),
|
||||
GenericArgKind::Lifetime(lt) => bug!("unexpected well formed predicate: {:?}", lt),
|
||||
},
|
||||
|
||||
ty::PredicateKind::ObjectSafe(t) => chalk_ir::GoalData::DomainGoal(
|
||||
|
|
|
@ -416,7 +416,7 @@ pub(crate) mod rustc {
|
|||
// begin with the field's visibility
|
||||
tree = tree.then(Self::def(Def::Field(field_def)));
|
||||
|
||||
// compute the field's layout charactaristics
|
||||
// compute the field's layout characteristics
|
||||
let field_layout = layout_of(tcx, field_ty)?.clamp_align(min_align, max_align);
|
||||
|
||||
// next comes the field's padding
|
||||
|
|
|
@ -101,7 +101,7 @@ pub(super) fn check_fn<'a, 'tcx>(
|
|||
decl.output.span(),
|
||||
param_env,
|
||||
));
|
||||
// If we replaced declared_ret_ty with infer vars, then we must be infering
|
||||
// If we replaced declared_ret_ty with infer vars, then we must be inferring
|
||||
// an opaque type, so set a flag so we can improve diagnostics.
|
||||
fcx.return_type_has_opaque = ret_ty != declared_ret_ty;
|
||||
|
||||
|
@ -1543,7 +1543,7 @@ fn detect_discriminant_duplicate<'tcx>(
|
|||
None => {
|
||||
// At this point we know this discriminant is a duplicate, and was not explicitly
|
||||
// assigned by the user. Here we iterate backwards to fetch the HIR for the last
|
||||
// explictly assigned discriminant, and letting the user know that this was the
|
||||
// explicitly assigned discriminant, and letting the user know that this was the
|
||||
// increment startpoint, and how many steps from there leading to the duplicate
|
||||
if let Some((n, hir::Variant { span, ident, .. })) =
|
||||
vs[..idx].iter().rev().enumerate().find(|v| v.1.disr_expr.is_some())
|
||||
|
@ -1566,7 +1566,7 @@ fn detect_discriminant_duplicate<'tcx>(
|
|||
};
|
||||
|
||||
// Here we loop through the discriminants, comparing each discriminant to another.
|
||||
// When a duplicate is detected, we instatiate an error and point to both
|
||||
// When a duplicate is detected, we instantiate an error and point to both
|
||||
// initial and duplicate value. The duplicate discriminant is then discarded by swapping
|
||||
// it with the last element and decrementing the `vec.len` (which is why we have to evaluate
|
||||
// `discrs.len()` anew every iteration, and why this could be tricky to do in a functional
|
||||
|
|
|
@ -153,7 +153,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
|||
) {
|
||||
let tcx = self.tcx;
|
||||
|
||||
// Conceptually, we've got some number of expected inputs, and some number of provided aguments
|
||||
// Conceptually, we've got some number of expected inputs, and some number of provided arguments
|
||||
// and we can form a grid of whether each argument could satisfy a given input:
|
||||
// in1 | in2 | in3 | ...
|
||||
// arg1 ? | | |
|
||||
|
|
|
@ -497,7 +497,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
|
|||
let expr_place = return_if_err!(self.mc.cat_expr(expr));
|
||||
f(self);
|
||||
if let Some(els) = els {
|
||||
// borrowing because we need to test the descriminant
|
||||
// borrowing because we need to test the discriminant
|
||||
self.maybe_read_scrutinee(expr, expr_place.clone(), from_ref(pat).iter());
|
||||
self.walk_block(els)
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue