fix typos (#1016)

The typos were found with the "typos" spell checker.[1]

[1]: https://github.com/crate-ci/typos

Author: kkysen

analysis/runtime/src/handlers.rs

@@ -91,7 +91,7 @@ macro_rules! hook_fn {
     }};
 }
 
-/// List of functions we want hooked for the lifetime analyis runtime.
+/// List of functions we want hooked for the lifetime analysis runtime.
 ///
 /// For functions in [`HOOK_FUNCTIONS`], the tracing passes
 /// the return value of the traced function as the last argument to the trace hook for it.

c2rust-analyze/src/borrowck/type_check.rs

@@ -368,7 +368,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
                 if let Some(true) = op.constant().cloned().map(util::is_null_const) {
                     // Here we relabel `expect_ty` to utilize the permissions it carries
                     // but substitute the rest of its `Label`s' parts with fresh origins
-                    // Othwerise, this is conceptually similar to labeling the cast target
+                    // Otherwise, this is conceptually similar to labeling the cast target
                     // `ty`. We would simply do that, but do not have the information necessary
                     // to set its permissions.
                     self.relabel_fresh_origins(expect_ty)
@@ -380,7 +380,7 @@ impl<'tcx> TypeChecker<'tcx, '_> {
                 let op_lty = self.visit_operand(op);
                 // Here we relabel `expect_ty` to utilize the permissions it carries
                 // but substitute the rest of its `Label`s' parts with fresh origins
-                // Othwerise, this is conceptually similar to labeling the cast target
+                // Otherwise, this is conceptually similar to labeling the cast target
                 // `ty`. We would simply do that, but do not have the information necessary
                 // to set its permissions.
                 let result_lty = self.relabel_fresh_origins(expect_ty);

c2rust-analyze/src/rewrite/apply.rs

@@ -258,7 +258,7 @@ impl<S: Sink> Emitter<'_, S> {
     /// Emit the text of `rw` into `self.sink`, using `Sink` methods to paste in the expression
     /// being rewritten or its subexpressions if needed.
     ///
-    /// `prec` is the precedence of the surrounding context.  Each operatior is assigned a
+    /// `prec` is the precedence of the surrounding context.  Each operator is assigned a
     /// precedence number, where a higher precedence number means the operator binds more tightly.
     /// For example, `a + b * c` parses as `a + (b * c)`, not `(a + b) * c`, because `*` binds more
     /// tightly than `+`; this means `*` will have a higher precedence number than `+`.  Nesting a

c2rust-ast-exporter/src/AstExporter.cpp

@@ -1901,7 +1901,7 @@ class TranslateASTVisitor final
         // Unfortunately, if there are two 'extern' variables in different
         // functions that should be the same at link time, Clang groups them.
         // That is unhelpful for us though, since we need to convert them into
-        // two seperate `extern` blocks.
+        // two separate `extern` blocks.
         if (!VD->isCanonicalDecl() && !VD->isExternC()) {
             // Emit non-canonical decl so we have a placeholder to attach comments to
             std::vector<void *> childIds = {VD->getCanonicalDecl()};
@@ -2201,7 +2201,7 @@ class TranslateASTVisitor final
                          cbor_encode_uint(array, bitWidth);
                      });
 
-        // This might be the only occurence of this type in the translation unit
+        // This might be the only occurrence of this type in the translation unit
         typeEncoder.VisitQualType(t);
 
         return true;

c2rust-refactor/doc/literate/annot.py

@@ -217,7 +217,7 @@ def __init__(self):
         self.acc = []
 
     def add(self, span: Span[T]):
-        '''Add `span` to the result sequnece, merging it with the previous span
+        '''Add `span` to the result sequence, merging it with the previous span
         if it overlaps.  In case of overlap, the merged span retains the label
         of the first span provided with `add`.'''
         if len(self.acc) > 0 and span.start <= self.acc[-1].end:

c2rust-refactor/doc/rewrite.md

@@ -76,10 +76,10 @@ rewrite_expr '__x + 1' '11 * __x'
 In each case, the expression bound to the `__x` metavariable is substituted
 into the right-hand side of the multiplication in the replacement.
 
-## Multiple occurences
+## Multiple occurrences
 
 Finally, the same metavariable can appear multiple times in the pattern.  In
-that case, the pattern matches only if each occurence of the metavariable
+that case, the pattern matches only if each occurrence of the metavariable
 matches the same expression.  For example:
 
 ```rust refactor-target hidden

c2rust-refactor/doc/select.md

@@ -775,7 +775,7 @@ which `mark_uses` cannot handle.
 
 For purposes of `mark_callers`, a "use" is a function call (`foo::bar()`) or
 method call (`x.foo()`) expression where the function or method being called is
-one of the marked definitons.
+one of the marked definitions.
 
 ### `mark_arg_uses`
 

c2rust-refactor/gen/rewrite.py

@@ -51,7 +51,7 @@
 
 The generated `Rewrite` impl will by default try either `equal` or `recursive`
 (depending on type kind), then `print`.  If one of these strategies is
-unavailabe (due to missing impls), it will be skipped.  If no strategies are
+unavailable (due to missing impls), it will be skipped.  If no strategies are
 available, code generation raises an error.
 
 For the three built-in strategies:

c2rust-refactor/misc/rustfmt-clean-parens.diff

@@ -4,7 +4,7 @@ in `c2rust-refactor` would insert unnecessary parentheses around (at least) ever
 splice point, and this seemed like the easiest way to clean it up.  The
 approach taken here involves some ugly hacks (see the `ExprKind::Paren` case
 below), so it's probably not suitable for upstreaming in its current form.  I
-think this patch is now obsolete, thanks to improvemens in the `c2rust-refactor`
+think this patch is now obsolete, thanks to improvements in the `c2rust-refactor`
 rewriter, but I'm leaving a copy here anyway in case it turns out to be useful.
 
 

c2rust-refactor/scripts/upgrade_ptr_to_ref.lua

@@ -858,7 +858,7 @@ function Visitor:rewrite_deref_expr(expr, output_slice)
                     expr:to_method_call("as_ptr", {expr})
                 end
 
-                -- For immut refs we skip the superflous as_ref call,
+                -- For immut refs we skip the superfluous as_ref call,
                 -- so we can also skip one of the corresponding derefs
                 if is_mut or cfg:is_box_any() then
                     expr:to_unary("Deref", expr)
@@ -1434,7 +1434,7 @@ function Visitor:flat_map_stmt(stmt, walk)
     -- a = a.offset(x);
     --
     -- where "a" is a mutable slice ref. In particular, we're just looking for the
-    -- offset assignment here (locals handeled elsewhere). We rewrite it to:
+    -- offset assignment here (locals handled elsewhere). We rewrite it to:
     --
     -- {
     --     let tup = a[.unwrap()].split_at_mut(x);

c2rust-refactor/src/analysis/ownership/README.md

@@ -151,7 +151,7 @@ path permissions reflects the transitive nature of access restrictions in Rust:
 for example, if a struct field `x.f` has type `&mut T`, but `x` is an immutable
 reference (`&S`), then only immutable access is allowed to `*x.f`.
 
-The two additional constraints introduced by assigments are (1) the path
+The two additional constraints introduced by assignments are (1) the path
 permission of the LHS must be no lower than WRITE, and (2) the path permission
 of the RHS must be no lower than the permission of the LHS pointer type.
 Constraint (1) prevents writing through a READ pointer, or through any path
@@ -325,7 +325,7 @@ There are four annotation types currently supported by the ownership system.
 
   The `ownership_mono` annotation can appear multiple times on a single
   function to provide multiple monomorphic signatures.  However, if it appears
-  at all, monomorphization inference will be completely overriden for the
+  at all, monomorphization inference will be completely overridden for the
   annotated function, and only the provided signatures will be used in callee
   argument inference and later transformations.
 

c2rust-refactor/src/analysis/ownership/constraint.rs

@@ -191,7 +191,7 @@ impl<'lty, 'tcx> Perm<'lty> {
         }
     }
 
-    /// Iterater over each atomic (non-`Min`) permission that appears in `self`.
+    /// Iterator over each atomic (non-`Min`) permission that appears in `self`.
     pub fn for_each_atom<F: FnMut(Perm<'lty>)>(&self, callback: &mut F) {
         match *self {
             Perm::Min(ps) => {
@@ -285,7 +285,7 @@ impl<'lty, 'tcx> ConstraintSet<'lty> {
         for &(a, b) in other.less.iter() {
             let (a2, b2) = (subst_one(a), subst_one(b));
             debug!(
-                "IMPORT CONSTRANT: {:?} <= {:?} (substituted from {:?} <= {:?})",
+                "IMPORT CONSTRAINT: {:?} <= {:?} (substituted from {:?} <= {:?})",
                 a2, b2, a, b
             );
             self.add(a2, b2);

c2rust-refactor/src/reflect.rs

@@ -112,7 +112,7 @@ impl<'a, 'tcx> Reflector<'a, 'tcx> {
                 }
             }
             // `Bound` is "used only when preparing a trait query", so hopefully we never actually
-            // encouter one.
+            // encounter one.
             Bound(..) => mk().infer_ty(),
             // No idea what `Placeholder` is, but it sounds like something rustc-internal.
             Placeholder(..) => mk().infer_ty(),

c2rust-refactor/src/transform/externs.rs

@@ -138,7 +138,7 @@ pub fn fix_users(
                         expect!([e.kind] ExprKind::Call(_, ref mut args) => {
                             if let Some(ty) = cx.opt_node_type(args[i].id) {
                                 if ty_compare.eq_tys(ty, new_ty) {
-                                    // We don't need to conver this type, it already matches
+                                    // We don't need to convert this type, it already matches
                                     return;
                                 }
                             }

c2rust-refactor/src/transform/lifetime_analysis.rs

@@ -56,7 +56,7 @@ impl Transform for InstrumentCmd {
     }
 }
 
-/// List of functions we want hooked for the lifetime analyis runtime (see
+/// List of functions we want hooked for the lifetime analysis runtime (see
 /// ../../runtime/src/lib.rs for the implementations of these hooks)
 const HOOK_FUNCTIONS: &[&'static str] = c2rust_analysis_rt::HOOK_FUNCTIONS;
 

c2rust-refactor/src/util/cursor.rs

@@ -275,7 +275,7 @@ impl<T> Cursor<T> {
 
     /// Extract the elements between `start` and `end`, transform them using `func`, and insert the
     /// results in their place.  Afterward, the cursor points past the end of the replacement
-    /// sequnece.
+    /// sequence.
     pub fn replace_range<F>(&mut self, start: Mark, end: Mark, func: F)
     where
         F: FnOnce(Vec<T>) -> Vec<T>,

c2rust-refactor/tests/misc/debug_callees.rs

@@ -29,8 +29,8 @@ fn main() {
     S.g();  // Inherent ethod call
     S::g(&S);   // Inherent method call using type-dependent path
     S.h();      // Trait method call
-    S::h(&S);   // Trait method call using type-depedent path (Self)
-    T::h(&S);   // Trait method call using type-depedent path (trait)
+    S::h(&S);   // Trait method call using type-dependent path (Self)
+    T::h(&S);   // Trait method call using type-dependent path (trait)
     <S as T>::h(&S);    // Trait method call with explicit Self type
     FN_PTR();   // Call via (static) function pointer
     closure();  // Closure call / overloaded `Fn`

c2rust-transpile/src/c_ast/mod.rs

@@ -310,7 +310,7 @@ impl TypedAstContext {
     }
 
     /// Follow a chain of typedefs and return true iff the last typedef is named
-    /// `__buitin_va_list` thus naming the type clang uses to represent `va_list`s.
+    /// `__builtin_va_list` thus naming the type clang uses to represent `va_list`s.
     pub fn is_builtin_va_list(&self, typ: CTypeId) -> bool {
         match self.index(typ).kind {
             CTypeKind::Typedef(decl) => match &self.index(decl).kind {

c2rust-transpile/src/cfg/mod.rs

@@ -691,7 +691,7 @@ impl<Lbl: Clone + Ord + Hash + Debug, Stmt> Cfg<Lbl, Stmt> {
 
         self.nodes.retain(|lbl, _| visited.contains(lbl));
         self.loops.filter_unreachable(&visited);
-        // TODO mutliple info
+        // TODO multiple info
     }
 
     /// Removes empty blocks whose terminator is just a `Jump` by merging them with the block they
@@ -974,7 +974,7 @@ pub struct DeclStmtStore {
 ///
 ///  1. declare and initialize
 ///  2. declare only (and incidentally zero-initialize)
-///  3. intialize only (if the declaration has already been emitted)
+///  3. initialize only (if the declaration has already been emitted)
 ///
 #[derive(Clone, Debug)]
 pub struct DeclStmtInfo {

c2rust-transpile/src/cfg/relooper.rs

@@ -308,7 +308,7 @@ impl RelooperState {
             (predecessor_map, strict_reachable_from)
         };
 
-        // Try to match an existing branch point (from the intial C). See `MultipleInfo` for more
+        // Try to match an existing branch point (from the initial C). See `MultipleInfo` for more
         // information on this.
         let mut recognized_c_multiple = false;
         if let Some(ref multiple_info) = self.multiple_info {

c2rust-transpile/src/lib.rs

@@ -529,7 +529,7 @@ fn get_output_path(
     ancestor_path: &Path,
     build_dir: &Path,
 ) -> PathBuf {
-    // When an output file name is not explictly specified, we should convert files
+    // When an output file name is not explicitly specified, we should convert files
     // with dashes to underscores, as they are not allowed in rust file names.
     let file_name = input_path
         .file_name()

c2rust-transpile/src/translator/literals.rs

@@ -160,7 +160,7 @@ impl<'c> Translation<'c> {
         }
     }
 
-    /// Convert an initialization list into an expresion. These initialization lists can be
+    /// Convert an initialization list into an expression. These initialization lists can be
     /// used as array literals, struct literals, and union literals in code.
     pub fn convert_init_list(
         &self,

c2rust-transpile/src/translator/mod.rs

@@ -108,7 +108,7 @@ pub struct ExprContext {
     decay_ref: DecayRef,
     is_bitfield_write: bool,
 
-    // We will be refering to the expression by address. In this context we
+    // We will be referring to the expression by address. In this context we
     // can't index arrays because they may legally go out of bounds. We also
     // need to explicitly cast function references to fn() so we get their
     // address in function pointer literals.
@@ -208,7 +208,7 @@ pub struct FuncContext {
     /// The name of the function we're currently translating
     name: Option<String>,
     /// The name we give to the Rust function argument corresponding
-    /// to the elipsis in variadic C functions.
+    /// to the ellipsis in variadic C functions.
     va_list_arg_name: Option<String>,
     /// The va_list decls that are either `va_start`ed or `va_copy`ed.
     va_list_decl_ids: Option<IndexSet<CDeclId>>,
@@ -460,7 +460,7 @@ fn clean_path(mod_names: &RefCell<IndexMap<String, PathBuf>>, path: Option<&path
         mod_names.insert(file_path.clone(), path.to_path_buf());
     } else {
         let mod_path = mod_names.get(&file_path.clone()).unwrap();
-        // A collision in the module names has occured.
+        // A collision in the module names has occurred.
         // Ex: types.h can be included from
         // /usr/include/bits and /usr/include/sys
         if mod_path != path {
@@ -557,7 +557,7 @@ pub fn translate(
 
                         // Detect case where typedef and struct share the same name.
                         // In this case the purpose of the typedef was simply to eliminate
-                        // the need for the 'struct' tag when refering to the type name.
+                        // the need for the 'struct' tag when referring to the type name.
                         Struct {
                             name: Some(ref target_name),
                             ..
@@ -2097,7 +2097,7 @@ impl<'c> Translation<'c> {
                     mk()
                 };
 
-                // Force mutability due to the potential for raw pointers occuring in the type
+                // Force mutability due to the potential for raw pointers occurring in the type
                 // and because we may be assigning to these variables in the external initializer
                 let mut static_def = static_def.span(span).mutbl();
                 if has_thread_duration {

c2rust-transpile/src/translator/structs.rs

@@ -212,7 +212,7 @@ impl<'a> Translation<'a> {
                         let end_bit = platform_bit_offset + bitfield_width;
 
                         // Add to the total byte size of the bitfield group only if
-                        // we have not already enountered this byte
+                        // we have not already encountered this byte
                         for bit in platform_bit_offset..end_bit {
                             let byte = bit / 8;
 
@@ -234,7 +234,7 @@ impl<'a> Translation<'a> {
                         let end_bit = platform_bit_offset + bitfield_width;
 
                         // Add to the total byte size of the bitfield group only if
-                        // we have not already enountered this byte
+                        // we have not already encountered this byte
                         for bit in platform_bit_offset..end_bit {
                             let byte = bit / 8;
 

c2rust-transpile/src/translator/variadic.rs

@@ -228,7 +228,7 @@ impl<'c> Translation<'c> {
     }
 
     /// Update the current function context by i) enabling the C variadics feature, ii) naming the
-    /// Rust function argument that corresponds to the elipsis in the original C function, and iii)
+    /// Rust function argument that corresponds to the ellipsis in the original C function, and iii)
     /// building a list of variable declarations to be translated into `VaListImpl`s. Returns the
     /// name of the `VaList` function argument for convenience.
     pub fn register_va_decls(&self, body: CStmtId) -> String {

dynamic_instrumentation/README.md

@@ -9,4 +9,4 @@ ${CARGO_TARGET_DIR:-target}/debug/c2rust-instrument --metadata analysis/tests/mi
 This instruments the binary built from main.rs with dynamic memory tracing, and
 outputs the necessary metadata to match up instrumentation points to source code
 into `metadata.bc`. We then run the binary, printing output to the
-debug console and using the aformentioned metadata file.
+debug console and using the aforementioned metadata file.

dynamic_instrumentation/src/instrument.rs

@@ -166,7 +166,7 @@ impl<'tcx> MutVisitor<'tcx> for RewriteAddressTakenLocals<'tcx> {
                 && (is_non_assignment_use || is_assignment_to_local_projection)
                 // maintain drop semantics for original address-taken local -- the liveness
                 // properties of its address are not necessarily the same, and dropping
-                // `(*_y)` is undesireable
+                // `(*_y)` is undesirable
                 && !context.is_drop()
             {
                 // add deref
@@ -231,7 +231,7 @@ impl<'tcx> MutVisitor<'tcx> for RewriteAddressTakenLocals<'tcx> {
         }
 
         // when the address-taken local is assigned to for the first time, we know it's active,
-        // so insert `_y = &raw x` just below that assignment, which is neccessary because
+        // so insert `_y = &raw x` just below that assignment, which is necessary because
         // otherwise the address-taking statement would be taking the address of an uninitialized
         // variable. For assignment statements, place `_y = &raw _x` one statement below. For
         // terminators with a destination to the address-taken local, or drop and replace

scripts/package.py

@@ -220,7 +220,7 @@ def _parse_args() -> argparse.Namespace:
 
     subparsers = parser.add_subparsers(dest='subcommand', required=True)
 
-    subparsers.add_parser('check', help='Check repo in preperation for publishing')
+    subparsers.add_parser('check', help='Check repo in preparation for publishing')
 
     subparsers.add_parser('package', help='Package crates')
 

tests/gotos/src/early_returns.c

@@ -1,4 +1,4 @@
-// This shoud translate to straightforward one-armed if's
+// This should translate to straightforward one-armed if's
 int early_returns(int a) {
     if (a == 2) {
         return 2;

tests/gotos/src/idiomatic_nested_loops.c

@@ -1,4 +1,4 @@
-// This shoud translate to a straightforward `break` with a loop label 
+// This should translate to a straightforward `break` with a loop label 
 int break_multiple(int x) {
   /* comment1 */
 

tests/gotos/src/idiomatic_switch.c

@@ -1,4 +1,4 @@
-// This shoud translate to a straightforward `match`.
+// This should translate to a straightforward `match`.
 int idiomatic_switch(int x) {
 
     switch (1 + x) {

tests/gotos/src/label_break_trigger.c

@@ -1,5 +1,5 @@
 // This function doesn't do anything interesting, so we aren't checking its
-// intputs or outputs. However, it does have interesting control flow, so
+// inputs or outputs. However, it does have interesting control flow, so
 // we do check that we can generate compiling code for it.
 void triggers_label_break(void) {
 lbl: