Spelling silgen

* actually
* arbitrary
* cargo-culted
* clazz
* constrained
* continuation
* coordinator
* coroutine
* derivative
* destroyer
* given
* have
* imported
* initialization
* items
* necessarily
* occurring
* omitting
* overridden
* parameter
* possible
* predecessor
* preparation
* resilience
* should
* struct
* that
* the
* throwing
* unexpectedly
* uniqueness
* using
* value
* villain

Signed-off-by: Josh Soref <[email protected]>

Author: jsoref

lib/SILGen/ArgumentSource.h

@@ -352,7 +352,7 @@ class PreparedArguments {
 
   /// Add an arbitrary argument source to these arguments.
   ///
-  /// An argument list with an arbtrary argument source can't generally
+  /// An argument list with an arbitrary argument source can't generally
   /// be copied.
   void addArbitrary(ArgumentSource &&arg) {
     assert(!isNull());

lib/SILGen/Conversion.h

@@ -298,7 +298,7 @@ class ConvertingInitialization final : public Initialization {
                            ManagedValue value, bool isInit) override;
 
   /// Given that the result of the given expression needs to sequentially
-  /// undergo the the given conversion and then this conversion, attempt to
+  /// undergo the given conversion and then this conversion, attempt to
   /// peephole the result.  If successful, the value will be set in this
   /// initialization.  The initialization will not yet be finished.
   bool tryPeephole(SILGenFunction &SGF, Expr *E, Conversion innerConversion);

lib/SILGen/RValue.h

@@ -51,7 +51,7 @@ class CleanupCloner;
 ///   cleanups. This is verified upon construction of an RValue.
 ///
 ///   2. All sub-ManagedValues with non-trivial ValueOwnershipKind must have the
-///   same ValueOwnershipKind. There is a subtle thing occuring here. Since all
+///   same ValueOwnershipKind. There is a subtle thing occurring here. Since all
 ///   addresses are viewed from an ownership perspective as having trivial
 ///   ownership, this causes the verification to ignore address only
 ///   values. Once we transition to opaque values, the verification will

lib/SILGen/SILGen.cpp

@@ -1309,7 +1309,7 @@ void SILGenModule::emitDifferentiabilityWitness(
   // NOTE(TF-893): Extending capacity is necessary when `origSilFnType` has
   // parameters corresponding to captured variables. These parameters do not
   // appear in the type of `origFnType`.
-  // TODO: If posssible, change `autodiff::getLoweredParameterIndices` to
+  // TODO: If possible, change `autodiff::getLoweredParameterIndices` to
   // take `CaptureInfo` into account.
   if (origSilFnType->getNumParameters() > silParamIndices->getCapacity())
     silParamIndices = silParamIndices->extendingCapacity(
@@ -1461,7 +1461,7 @@ void SILGenModule::emitConstructor(ConstructorDecl *decl) {
 
   if (declCtx->getSelfClassDecl()) {
     // Designated initializers for classes, as well as @objc convenience
-    // initializers, have have separate entry points for allocation and
+    // initializers, have separate entry points for allocation and
     // initialization.
     if (decl->isDesignatedInit() || decl->isObjC()) {
       emitOrDelayFunction(*this, constant);

lib/SILGen/SILGenApply.cpp

@@ -1504,8 +1504,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       // If we haven't allocated "self" yet at this point, do so.
       if (SGF.AllocatorMetatype) {
         bool usesObjCAllocation;
-        if (auto clas = dyn_cast<ClassDecl>(nominal)) {
-          usesObjCAllocation = usesObjCAllocator(clas);
+        if (auto clazz = dyn_cast<ClassDecl>(nominal)) {
+          usesObjCAllocation = usesObjCAllocator(clazz);
         } else {
           // In the protocol extension case, we should only be here if the callee
           // initializer is @objc.

lib/SILGen/SILGenBackDeploy.cpp

@@ -149,7 +149,7 @@ static void emitBackDeployForwardApplyAndReturnOrThrow(
     return;
   }
 
-  // The original function is neither throwing nor a couroutine. Apply it and
+  // The original function is neither throwing nor a coroutine. Apply it and
   // forward its results straight to the return block.
   auto *apply = SGF.B.createApply(loc, functionRef, subs, params);
   extractAllElements(apply, loc, SGF.B, directResults);

lib/SILGen/SILGenBridging.cpp

@@ -1135,7 +1135,7 @@ static ManagedValue emitCBridgedToNativeValue(
     }
 
     // Otherwise, we use more complicated logic that handles results that
-    // were unexpetedly null.
+    // were unexpectedly null.
 
     assert(bridgedType.isAnyClassReferenceType());
 

lib/SILGen/SILGenDecl.cpp

@@ -984,7 +984,7 @@ void EnumElementPatternInitialization::emitEnumMatch(
           // We must treat the boxed value as +0 since it may be shared. Copy it
           // if nontrivial.
           //
-          // NOTE: The APIs that we are usinng here will ensure that if we have
+          // NOTE: The APIs that we are using here will ensure that if we have
           // a trivial value, the load_borrow will become a load [trivial] and
           // the copies will be "automagically" elided.
           if (boxedTL.isLoadable() || !SGF.silConv.useLoweredAddresses()) {

lib/SILGen/SILGenDestructor.cpp

@@ -497,7 +497,7 @@ void SILGenFunction::emitObjCDestructor(SILDeclRef dtor) {
 
   B.createApply(cleanupLoc, superclassDtorValue, subMap, superSelf);
 
-  // We know that the givne value came in at +1, but we pass the relevant value
+  // We know that the given value came in at +1, but we pass the relevant value
   // as unowned to the destructor. Create a fake balance for the verifier to be
   // happy.
   B.createEndLifetime(cleanupLoc, superSelf);

lib/SILGen/SILGenExpr.cpp

@@ -5437,7 +5437,7 @@ RValue RValueEmitter::visitMakeTemporarilyEscapableExpr(
   RValue rvalue = visitSubExpr(borrowedClosure, false /* isClosureConsumable */);
 
   // Now create the verification of the withoutActuallyEscaping operand.
-  // Either we fail the uniquenes check (which means the closure has escaped)
+  // Either we fail the uniqueness check (which means the closure has escaped)
   // and abort or we continue and destroy the ultimate reference.
   auto isEscaping = SGF.B.createIsEscapingClosure(
       loc, borrowedClosure.getValue(),