Fix some typos in SwiftCompilerSources/Sources

Author: valeriyvan

SwiftCompilerSources/Sources/AST/SubstitutionMap.swift

@@ -68,7 +68,7 @@ public struct SubstitutionMap: CustomStringConvertible, NoReflectionChildren {
     TypeArray(bridged: bridged.getReplacementTypes())
   }
 
-  /// The single replacement type if it's guarnateed that the substitution map has a single replacement type.
+  /// The single replacement type if it's guaranteed that the substitution map has a single replacement type.
   public var replacementType: Type {
     assert(replacementTypes.count == 1)
     return replacementTypes[0]

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -97,8 +97,8 @@ struct AliasAnalysis {
         return false
       }
     }
-    // Finaly use escape info to check if one address "escapes" to the other address.
-    return v1.allContainedAddresss.canAddressAlias(with: v2.allContainedAddresss, context)
+    // Finally use escape info to check if one address "escapes" to the other address.
+    return v1.allContainedAddresses.canAddressAlias(with: v2.allContainedAddresses, context)
   }
 
   static func register() {
@@ -339,7 +339,7 @@ struct AliasAnalysis {
         return .noEffects
       }
       if destroy.isDeadEnd {
-        // We don't have to take deinit effects into acount for a `destroy_value [dead_end]`.
+        // We don't have to take deinit effects into account for a `destroy_value [dead_end]`.
         // Such destroys are lowered to no-ops and will not call any deinit.
         return .noEffects
       }
@@ -471,7 +471,7 @@ struct AliasAnalysis {
   }
 
   // To avoid quadratic complexity for large functions, we limit the amount of work that the EscapeUtils are
-  // allowed to to. This keeps the complexity linear.
+  // allowed to do. This keeps the complexity linear.
   //
   // This arbitrary limit is good enough for almost all functions. It lets
   // the EscapeUtils do several hundred up/down walks which is much more than needed in most cases.
@@ -481,14 +481,14 @@ struct AliasAnalysis {
       for _ in function.instructions { numInsts += 1 }
       cache.estimatedFunctionSize = numInsts
     }
-    return 1000000 / cache.estimatedFunctionSize!
+    return 1_000_000 / cache.estimatedFunctionSize!
   }
 
   /// Returns true if the `instruction` (which in general writes to memory) is immutable in a certain scope,
   /// defined by `address`.
   ///
   /// That means that even if we don't know anything about `instruction`, we can be sure
-  /// that `instruction` cannot write to `address`, if it's inside the addresse's scope.
+  /// that `instruction` cannot write to `address`, if it's inside the address's scope.
   /// An immutable scope is for example a read-only `begin_access`/`end_access` scope.
   /// Another example is a borrow scope of an immutable copy-on-write buffer.
   private func isImmutable(instruction: Instruction, inScopeOf address: Value) -> Bool {
@@ -797,7 +797,7 @@ private struct FullApplyEffectsVisitor : EscapeVisitorWithResult {
 
 // In contrast to a full apply, the effects of a partial_apply don't depend on the callee
 // (a partial_apply doesn't call anything, it just creates a thick function pointer).
-// The only effects come from capturing the arguments (either consuming or guaranteeed).
+// The only effects come from capturing the arguments (either consuming or guaranteed).
 private struct PartialApplyEffectsVisitor : EscapeVisitorWithResult {
   let partialApply: PartialApplyInst
   var result = SideEffects.Memory.noEffects

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -240,7 +240,7 @@ extension InstructionRange {
       }
       return .containsEnd
     }
-    // Neither end-point is contained. If a backward path walk encouters this range, then it must overlap this
+    // Neither end-point is contained. If a backward path walk encounters this range, then it must overlap this
     // range. Otherwise, it is disjoint.
     var backwardBlocks = BasicBlockWorklist(context)
     defer { backwardBlocks.deinitialize() }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CopyToBorrowOptimization.swift

@@ -39,7 +39,7 @@ import SIL
 /// ```
 
 /// The optimization can be done if:
-/// * In caseof a `load`: during the (forward-extended) lifetime of the loaded value the
+/// * In case of a `load`: during the (forward-extended) lifetime of the loaded value the
 ///                       memory location is not changed.
 /// * In case of a `copy_value`: the (guaranteed) lifetime of the source operand extends
 ///                       the lifetime of the copied value.

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DeadStoreElimination.swift

@@ -76,7 +76,7 @@ let deadStoreElimination = FunctionPass(name: "dead-store-elimination") {
 
 private func tryEliminate(store: StoreInst, complexityBudget: inout Int, _ context: FunctionPassContext) {
   // Check if the type can be expanded without a significant increase to code
-  // size. This pass splits values into its consitutent parts which effectively
+  // size. This pass splits values into its constituent parts which effectively
   // expands the value into projections which can increase code size.
   if !store.hasValidOwnershipForDeadStoreElimination || !store.source.type.shouldExpand(context) {
     return

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -66,7 +66,7 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
       // For now, if the mark_dependence wasn't recognized as a lifetime dependency, or if the dependencies uses are not
       // in scope, conservatively settle it as escaping. For example, it is not uncommon for the pointer value returned
       // by `unsafeAddress` to outlive its `self` argument. This will not be diagnosed as an error, but the
-      // mark_dependence will hanceforth be treated as an unknown use by the optimizer.  In the future, we should not
+      // mark_dependence will henceforth be treated as an unknown use by the optimizer.  In the future, we should not
       // need to set this flag during diagnostics because, for escapable types, mark_dependence [unresolved] will all be
       // settled during an early LifetimeNormalization pass.
       markDep.settleToEscaping(context)
@@ -422,8 +422,8 @@ private struct LifetimeVariable {
 ///
 /// This supports store-to-yield. Storing to a yield is an escape unless the yielded memory location depends on another
 /// lifetime that already depends on the current scope. When setter depends on 'newValue', 'newValue' is stored to the
-/// yielded address, and the yielded addrses depends on the lifetime of 'self'. A mark_dependence should have already
-/// been inserted for that lifetime depenence:
+/// yielded address, and the yielded addresses depends on the lifetime of 'self'. A mark_dependence should have already
+/// been inserted for that lifetime dependence:
 ///
 ///   (%a, %t) = begin_apply %f(%self)
 ///              : $@yield_once @convention(method) (@inout Self) -> _inherit(0) @yields @inout Self.field
@@ -459,7 +459,7 @@ extension DependentAddressUseDefWalker: AddressUseDefWalker {
   }
 }
 
-/// Walk down lifetime depenence uses. For each check that all dependent
+/// Walk down lifetime dependence uses. For each check that all dependent
 /// leaf uses are non-escaping and within the dependence scope. The walk
 /// starts with add address for .access dependencies. The walk can
 /// transition from an address to a value at a load. The walk can

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -191,8 +191,8 @@ private extension LifetimeDependentApply.LifetimeSourceInfo {
       // (a) the result or yield is never returned from this function
       //
       // (b) the inherited lifetime has a dependence root within this function (it comes from a dependent function
-      // argument or scoped dependence). In this case, when that depedence root is diagnosed, the analysis will find
-      // transtive uses of this apply's result.
+      // argument or scoped dependence). In this case, when that dependence root is diagnosed, the analysis will find
+      // transitive uses of this apply's result.
       //
       // (c) the dependent value is passed to another call with a dependent inout argument, or it is stored to a yielded
       // address of a coroutine that has a dependent inout argument. In this case, a mark_dependence will already be
@@ -346,7 +346,7 @@ func gatherVariableIntroducers(for value: Value, _ context: Context)
 ///
 ///     dependsOn(lvalue.computed) // finds the temporary value directly returned by a getter.
 ///
-/// SILGen emits temporary copies that violate lifetime dependence semantcs. This utility looks through such temporary
+/// SILGen emits temporary copies that violate lifetime dependence semantics. This utility looks through such temporary
 /// copies, stopping at a value that introduces an immutable variable: move_value [var_decl] or begin_borrow [var_decl],
 /// or at an access of a mutable variable: begin_access [read] or begin_access [modify].
 ///

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -666,7 +666,7 @@ extension ScopeExtension {
 
     log("Scope fixup for dependent uses:\n\(useRange)")
 
-    // Lifetime dependenent uses may not be dominated by `innermostScope`. The dependent value may be used by a phi or
+    // Lifetime dependent uses may not be dominated by `innermostScope`. The dependent value may be used by a phi or
     // stored into a memory location. The access may be conditional relative to such uses. If any use was not dominated,
     // then `useRange` will include the function entry. There is no way to directly check if `useRange` is
     // valid. `useRange.blockRange.isValid` is not a strong enough check because it will always succeed when
@@ -695,12 +695,12 @@ extension ScopeExtension {
     var extendedUseRange = InstructionRange(begin: useRange.begin!, ends: useRange.ends, context)
 
     // Insert the first instruction of the exit blocks to mimic `useRange`. There is no way to directly copy
-    // `useRange`. Inserting the exit block instructions is innacurate, but for the purpose of canExtend() below, it has
+    // `useRange`. Inserting the exit block instructions is inaccurate, but for the purpose of canExtend() below, it has
     // the same effect as a copy of `useRange`.
     extendedUseRange.insert(contentsOf: useRange.exits)
     defer { extendedUseRange.deinitialize() }
 
-    // Append each scope that needs extention to scopesToExtend from the inner to the outer scope.
+    // Append each scope that needs extension to scopesToExtend from the inner to the outer scope.
     for extScope in scopes.reversed() {
       // An outer scope might not originally cover one of its inner scopes. Therefore, extend 'extendedUseRange' to to
       // cover this scope's end instructions. The extended scope must at least cover the original scopes because the

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -248,7 +248,7 @@ private func removeBridgingCodeInPredecessors(of block: BasicBlock, _ context: F
 /// ```
 ///   switch_enum %0             // returned instruction
 /// some_bb(%1):
-///   %2 = enum #some(%1)        // only in case of ObjC -> Swift briding
+///   %2 = enum #some(%1)        // only in case of ObjC -> Swift bridging
 ///   %3 = apply %bridging(%2)   // returned by `isBridging`
 ///   %4 = enum #some(%3)
 ///   br continue_bb(%4)
@@ -338,7 +338,7 @@ func isBridgeToSwiftCall(_ value: Value) -> ApplyInst? {
   let funcName = bridgingFunc.name
   guard  bridgingFunc.hasSemanticsAttribute("bridgeFromObjectiveC") ||
          // Currently the semantics attribute is not used, so test for specific functions, too.
-         // TODO: remove those checks once the briding functions are annotate with "bridgeFromObjectiveC"
+         // TODO: remove those checks once the bridging functions are annotated with "bridgeFromObjectiveC"
          //       in Foundation.
          //
          // String._unconditionallyBridgeFromObjectiveC(_:)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -286,7 +286,7 @@ private struct ComputeOuterBlockrange : EscapeVisitorWithResult {
     result.insert(operandsDefinitionBlock)
 
     // We need to explicitly add predecessor blocks of phis because they
-    // are not necesesarily visited during the down-walk in `isEscaping()`.
+    // are not necessarily visited during the down-walk in `isEscaping()`.
     // This is important for the special case where there is a back-edge from the
     // inner range to the inner rage's begin-block:
     //

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyMarkDependence.swift

@@ -19,7 +19,7 @@ extension MarkDependenceInst : OnoneSimplifiable, SILCombineSimplifiable {
   func simplify(_ context: SimplifyContext) {
     if isRedundant ||
        // A literal lives forever, so no mark_dependence is needed.
-       // This pattern can occur after StringOptimization when a utf8CString of a literal is replace
+       // This pattern can occur after StringOptimization when a utf8CString of a literal is replaced
        // by the string_literal itself.
        value.isLiteral
     {

SwiftCompilerSources/Sources/Optimizer/Utilities/BorrowUtils.swift

@@ -465,7 +465,7 @@ func computeBorrowLiveRange(for value: Value, _ context: FunctionPassContext)
   for beginBorrow in value.getBorrowIntroducers(context) {
     /// FIXME: Remove calls to computeKnownLiveness() as soon as lifetime completion runs immediately after
     /// SILGen. Instead, this should compute linear liveness for borrowed value by switching over BeginBorrowValue, just
-    /// like LifetimeDependenc.Scope.computeRange().
+    /// like LifetimeDependence.Scope.computeRange().
     ranges.push((beginBorrow, computeKnownLiveness(for: beginBorrow.value, context)))
   }
   return ranges

SwiftCompilerSources/Sources/Optimizer/Utilities/ForwardingUtils.swift

@@ -303,7 +303,7 @@ extension ForwardingDefUseWalker {
 /// gatherLifetimeIntroducers().
 ///
 /// TODO: make the visitor non-escaping once Swift supports stored
-/// non-escaping closues.
+/// non-escaping closures.
 func visitForwardedUses(introducer: Value, _ context: Context,
   visitor: @escaping (ForwardingUseResult) -> WalkResult)
 -> WalkResult {

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -175,7 +175,7 @@ func specializeWitnessTable(for conformance: Conformance,
 }
 
 /// Specializes the default methods of a non-generic witness table.
-/// Default implementations (in protocol extentions) of non-generic protocol methods have a generic
+/// Default implementations (in protocol extensions) of non-generic protocol methods have a generic
 /// self argument. Specialize such methods with the concrete type. Note that it is important to also
 /// specialize inherited conformances so that the concrete self type is correct, even for derived classes.
 private func specializeDefaultMethods(for conformance: Conformance,
@@ -238,7 +238,7 @@ private func specializeDefaultMethods(for conformance: Conformance,
 
 private extension Function {
   // True, if this is a non-generic method which might have a generic self argument.
-  // Default implementations (in protocol extentions) of non-generic protocol methods have a generic
+  // Default implementations (in protocol extensions) of non-generic protocol methods have a generic
   // self argument.
   func isNonGenericWitnessMethod(_ context: some Context) -> Bool {
     switch loweredFunctionType.invocationGenericSignatureOfFunction.genericParameters.count {

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -382,7 +382,7 @@ extension LifetimeDependence.Scope {
 }
 
 extension LifetimeDependence.Scope {
-  /// Ignore "irrelevent" borrow scopes: load_borrow or begin_borrow without [var_decl]
+  /// Ignore "irrelevant" borrow scopes: load_borrow or begin_borrow without [var_decl]
   func ignoreBorrowScope(_ context: some Context) -> LifetimeDependence.Scope? {
     guard case let .borrowed(beginBorrowVal) = self else {
       return nil
@@ -560,7 +560,7 @@ protocol LifetimeDependenceDefUseWalker : ForwardingDefUseWalker,
 }
 
 extension LifetimeDependenceDefUseWalker {
-  // Use a distict context name to avoid rdar://123424566 (Unable to open existential)
+  // Use a distinct context name to avoid rdar://123424566 (Unable to open existential)
   var walkerContext: Context { context }
 }
 
@@ -824,7 +824,7 @@ extension LifetimeDependenceDefUseWalker {
 
 // Helpers
 extension LifetimeDependenceDefUseWalker {
-  // Visit uses of borrowing instruction (operandOwnerhip == .borrow).
+  // Visit uses of borrowing instruction (operandOwnership == .borrow).
   private mutating func visitAllBorrowUses(
     of operand: Operand, by borrowInst: BorrowingInstruction) -> WalkResult {
     switch borrowInst {
@@ -855,7 +855,7 @@ extension LifetimeDependenceDefUseWalker {
     }
   }
 
-  // Visit a dependent local variable (alloc_box), or temporary storage (alloc_stack). The depenedency is typically from
+  // Visit a dependent local variable (alloc_box), or temporary storage (alloc_stack). The dependency is typically from
   // storing a dependent value at `address`, but may be from an outright `mark_dependence_addr`.
   //
   // This handles stores of the entire value and stores into a member. Storing into a member makes the entire aggregate
@@ -1110,7 +1110,7 @@ private struct LifetimeDependenceUsePrinter : LifetimeDependenceDefUseWalker {
 ///
 ///     dependsOn(lvalue.computed) // finds the temporary value directly returned by a getter.
 ///
-/// SILGen emits temporary copies that violate lifetime dependence semantcs. This utility looks through such temporary
+/// SILGen emits temporary copies that violate lifetime dependence semantics. This utility looks through such temporary
 /// copies, stopping at a value that introduces an immutable variable: move_value [var_decl] or begin_borrow [var_decl],
 /// or at an access of a mutable variable: begin_access [read] or begin_access [modify].
 ///
@@ -1238,7 +1238,7 @@ extension LifetimeDependenceUseDefAddressWalker {
       if let addressorSelf = beginAccess.unsafeAddressorSelf {
         return walkUp(newLifetime: addressorSelf)
       }
-      // Ignore the acces scope for trivial values regardless of whether it is singly-initialized. Trivial values do not
+      // Ignore the access scope for trivial values regardless of whether it is singly-initialized. Trivial values do not
       // need to be kept alive in memory and can be safely be overwritten in the same scope. Lifetime dependence only
       // cares that the loaded value is within the lexical scope of the trivial value's variable declaration. Rather
       // than skipping all access scopes, call 'walkUp' on each nested access in case one of them needs to redirect the

SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift

@@ -12,7 +12,7 @@
 ///
 /// SIL operates on three kinds of addressable memory:
 ///
-/// 1. Temporary RValues. These are recognied by AddressInitializationWalker. These largely disappear with opaque SIL
+/// 1. Temporary RValues. These are recognized by AddressInitializationWalker. These largely disappear with opaque SIL
 /// values.
 ///
 /// 2. Local variables. These are always introduced by either a VarDeclInstruction or a Function argument with non-nil
@@ -774,7 +774,7 @@ extension LocalVariableReachableAccess {
 
   /// This performs a forward CFG walk to find all uses of this local variable reachable after `begin`.
   ///
-  /// If `lifetime` is true, then this gathers the full known lifetime, includeing destroys and reassignments ignoring
+  /// If `lifetime` is true, then this gathers the full known lifetime, including destroys and reassignments ignoring
   /// escapes.
   ///
   /// If `lifetime` is false, then this returns `false` if the walk ended early because of a reachable escape.

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -84,7 +84,7 @@ func computeKnownLiveness(for definingValue: Value, visitInnerUses: Bool = false
                                         visitInnerUses: visitInnerUses, context).acquireRange
 }
 
-/// If any interior pointer may escape, then record the first instance here. If 'ignoseEscape' is true, this
+/// If any interior pointer may escape, then record the first instance here. If 'ignoreEscape' is true, this
 /// immediately aborts the walk, so further instances are unavailable.
 ///
 /// .escaping may either be a non-address operand with

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -189,7 +189,7 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
 
     // If Package-CMO is enabled, we serialize package, public, and @usableFromInline decls as
     // [serialized_for_package].
-    // Their bodies must not, however, leak into @inlinable functons (that are [serialized])
+    // Their bodies must not, however, leak into @inlinable functions (that are [serialized])
     // since they are inlined outside of their defining module.
     //
     // If this callee is [serialized_for_package], the caller must be either non-serialized