swiftlang
diff --git a/‎include/swift/AST/DiagnosticsSema.def
+3-3 b/‎include/swift/AST/DiagnosticsSema.def
+3-3
diff --git a/‎include/swift/Sema/CSBindings.h
+3-3 b/‎include/swift/Sema/CSBindings.h
+3-3
diff --git a/‎include/swift/Sema/CSFix.h
+5-5 b/‎include/swift/Sema/CSFix.h
+5-5
diff --git a/‎include/swift/Sema/CompletionContextFinder.h
+1-1 b/‎include/swift/Sema/CompletionContextFinder.h
+1-1
diff --git a/‎include/swift/Sema/Constraint.h
+1-1 b/‎include/swift/Sema/Constraint.h
+1-1
diff --git a/‎include/swift/Sema/ConstraintGraph.h
+1-1 b/‎include/swift/Sema/ConstraintGraph.h
+1-1
diff --git a/‎include/swift/Sema/ConstraintSystem.h
+13-13 b/‎include/swift/Sema/ConstraintSystem.h
+13-13
diff --git a/‎include/swift/Sema/IDETypeChecking.h
+2-2 b/‎include/swift/Sema/IDETypeChecking.h
+2-2
diff --git a/‎lib/Sema/BuilderTransform.cpp
+1-1 b/‎lib/Sema/BuilderTransform.cpp
+1-1
diff --git a/‎lib/Sema/CSApply.cpp
+9-9 b/‎lib/Sema/CSApply.cpp
+9-9
diff --git a/‎lib/Sema/CSBindings.cpp
+6-6 b/‎lib/Sema/CSBindings.cpp
+6-6
diff --git a/‎lib/Sema/CSClosure.cpp
+2-2 b/‎lib/Sema/CSClosure.cpp
+2-2
@@ -1160,7 +1160,7 @@ NOTE(unwrap_with_guard,none,
 ERROR(optional_base_not_unwrapped,none,
       "value of optional type %0 must be unwrapped to refer to member %1 of "
       "wrapped base type %2", (Type, DeclNameRef, Type))
-ERROR(invalid_optional_infered_keypath_root, none,
+ERROR(invalid_optional_inferred_keypath_root, none,
       "key path root inferred as optional type %0 must be unwrapped to refer to member %1 "
       "of unwrapped type %2", (Type, DeclNameRef, Type))
 NOTE(optional_base_chain,none,
@@ -4028,7 +4028,7 @@ ERROR(passing_noattrfunc_to_attrfunc,none,
       "passing %select{non-escaping|non-sendable}0 parameter %1 to function "
       "expecting %select{an @escaping|a @Sendable}0 closure",
       (unsigned, Identifier))
-ERROR(converting_noespace_param_to_generic_type,none,
+ERROR(converting_noescape_param_to_generic_type,none,
       "converting non-escaping parameter %0 to generic parameter %1 may allow it to escape",
       (Identifier, Type))
 ERROR(assigning_noattrfunc_to_attrfunc,none,
@@ -5654,7 +5654,7 @@ ERROR(attr_requires_availability_for_platform,none,
 // This doesn't display as an availability diagnostic, but it's
 // implemented there and fires when these subscripts are marked
 // unavailable, so it seems appropriate to put it here.
-ERROR(availabilty_string_subscript_migration, none,
+ERROR(availability_string_subscript_migration, none,
       "subscripts returning String were obsoleted in Swift 4; explicitly "
       "construct a String from subscripted result", ())
 
 
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the \c PotentialBindings class and its auxilary types
-// such as \c PotentialBinding, that are used to descibe bindings which
+// This file defines the \c PotentialBindings class and its auxiliary types
+// such as \c PotentialBinding, that are used to describe bindings which
 // a particular type variable could be bound to.
 //
 //===----------------------------------------------------------------------===//
@@ -422,7 +422,7 @@ class BindingSet {
   /// Determine whether this set has any "viable" (or non-hole) bindings.
   ///
   /// A viable binding could be - a direct or transitive binding
-  /// inferred from a constraint, literal binding, or defaltable
+  /// inferred from a constraint, literal binding, or defaultable
   /// binding.
   ///
   /// A hole is not considered a viable binding since it doesn't
 
@@ -103,7 +103,7 @@ enum class FixKind : uint8_t {
   GenericArgumentsMismatch,
 
   /// Fix up @autoclosure argument to the @autoclosure parameter,
-  /// to for a call to be able to foward it properly, since
+  /// to for a call to be able to forward it properly, since
   /// @autoclosure conversions are unsupported starting from
   /// Swift version 5.
   AutoClosureForwarding,
@@ -251,7 +251,7 @@ enum class FixKind : uint8_t {
   /// inferred in current context e.g. because it's a multi-statement closure.
   SpecifyClosureReturnType,
 
-  /// Object literal type coudn't be inferred because the module where
+  /// Object literal type couldn't be inferred because the module where
   /// the default type that implements the associated literal protocol
   /// is declared was not imported.
   SpecifyObjectLiteralTypeImport,
@@ -274,7 +274,7 @@ enum class FixKind : uint8_t {
   /// Allow key path to be bound to a function type with more than 1 argument
   AllowMultiArgFuncKeyPathMismatch,
 
-  /// Specify key path root type when it cannot be infered from context.
+  /// Specify key path root type when it cannot be inferred from context.
   SpecifyKeyPathRootType,
 
   /// Unwrap optional base on key path application.
@@ -321,7 +321,7 @@ enum class FixKind : uint8_t {
   AllowNoopExistentialToCFTypeCheckedCast,
 
   /// Allow a runtime checked cast where at compile time the from is
-  /// convertible, but runtime does not support such convertions. e.g.
+  /// convertible, but runtime does not support such conversions. e.g.
   /// function type casts.
   AllowUnsupportedRuntimeCheckedCast,
 
@@ -450,7 +450,7 @@ class ConstraintFix {
 
   /// Retrieve anchor expression associated with this fix.
   /// NOTE: such anchor comes directly from locator without
-  /// any simplication attempts.
+  /// any simplification attempts.
   ASTNode getAnchor() const;
   ConstraintLocator *getLocator() const { return Locator; }
 
 
@@ -74,7 +74,7 @@ class CompletionContextFinder : public ASTWalker {
     return hasContext(ContextKind::MultiStmtClosure);
   }
 
-  bool locatedInStringIterpolation() const {
+  bool locatedInStringInterpolation() const {
     return hasContext(ContextKind::StringInterpolation);
   }
 
 
@@ -817,7 +817,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,
   }
 
   /// Returns the number of resolved argument types for an applied disjunction
-  /// constriant. This is always zero for disjunctions that do not represent
+  /// constraint. This is always zero for disjunctions that do not represent
   /// an applied overload.
   unsigned countResolvedArgumentTypes(ConstraintSystem &cs) const;
 
 
@@ -436,7 +436,7 @@ class ConstraintGraph {
   SmallVector<Constraint *, 4> OrphanedConstraints;
 
   /// Increment the number of constraints considered per attempt
-  /// to contract constrant graph edges.
+  /// to contract constraint graph edges.
   void incrementConstraintsPerContractionCounter();
 
   /// The kind of change made to the graph.
 
@@ -296,7 +296,7 @@ class TypeVariableType::Implementation {
   void setRawOptions(unsigned bits) {
     getTypeVariable()->Bits.TypeVariableType.Options = bits;
     assert(getTypeVariable()->Bits.TypeVariableType.Options == bits
-           && "Trucation");
+           && "Truncation");
   }
 
   /// Whether this type variable can bind to an lvalue type.
@@ -2006,7 +2006,7 @@ class SolutionApplicationTarget {
         !expression.pattern->isImplicit();
   }
 
-  /// Check whether this is an initializaion for `async let` pattern.
+  /// Check whether this is an initialization for `async let` pattern.
   bool isAsyncLetInitializer() const {
     if (!(kind == Kind::expression &&
           expression.contextualPurpose == CTP_Initialization))
@@ -2843,7 +2843,7 @@ class ConstraintSystem {
 
     /// Disable the given constraint; this change will be rolled back
     /// when we exit the current solver scope.
-    void disableContraint(Constraint *constraint) {
+    void disableConstraint(Constraint *constraint) {
       constraint->setDisabled();
       disabledConstraints.push_back(constraint);
     }
@@ -3180,7 +3180,7 @@ class ConstraintSystem {
   ///
   /// \param solutions The set of solutions to filter.
   ///
-  /// \param minimize The flag which idicates if the
+  /// \param minimize The flag which indicates if the
   /// set of solutions should be filtered even if there is
   /// no single best solution, see `findBestSolution` for
   /// more details.
@@ -3374,7 +3374,7 @@ class ConstraintSystem {
     return known->second;
   }
 
-  /// Retrieve type type of the given declaration to be used in
+  /// Retrieve type of the given declaration to be used in
   /// constraint system, this is better than calling `getType()`
   /// directly because it accounts of constraint system flags.
   Type getVarType(const VarDecl *var);
@@ -3506,7 +3506,7 @@ class ConstraintSystem {
   std::pair<Type, OpenedArchetypeType *> openExistentialType(
       Type type, ConstraintLocator *locator);
 
-  /// Retrive the constraint locator for the given anchor and
+  /// Retrieve the constraint locator for the given anchor and
   /// path, uniqued and automatically infer the summary flags
   ConstraintLocator *
   getConstraintLocator(ASTNode anchor,
@@ -4058,12 +4058,12 @@ class ConstraintSystem {
   isRepresentativeFor(TypeVariableType *typeVar,
                       ConstraintLocator::PathElementKind kind) const;
 
-  /// Gets the VarDecl associateed with resolvedOverload, and the type of the
+  /// Gets the VarDecl associated with resolvedOverload, and the type of the
   /// projection if the decl has an associated property wrapper with a projectedValue.
   Optional<std::pair<VarDecl *, Type>>
   getPropertyWrapperProjectionInfo(SelectedOverload resolvedOverload);
 
-  /// Gets the VarDecl associateed with resolvedOverload, and the type of the
+  /// Gets the VarDecl associated with resolvedOverload, and the type of the
   /// backing storage if the decl has an associated property wrapper.
   Optional<std::pair<VarDecl *, Type>>
   getPropertyWrapperInformation(SelectedOverload resolvedOverload);
@@ -5715,7 +5715,7 @@ matchCallArguments(
 Expr *getArgumentLabelTargetExpr(Expr *fn);
 
 /// Given a type that includes an existential type that has been opened to
-/// the given type variable, type-erase occurences of that opened type
+/// the given type variable, type-erase occurrences of that opened type
 /// variable and anything that depends on it to their non-dependent bounds.
 Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
                                          TypeVariableType *openedTypeVar,
@@ -5787,7 +5787,7 @@ bool isPatternMatchingOperator(ASTNode node);
 /// "standard" comparison operator such as "==", "!=", ">" etc.
 bool isStandardComparisonOperator(ASTNode node);
 
-/// If given expression references operator overlaod(s)
+/// If given expression references operator overload(s)
 /// extract and produce name of the operator.
 Optional<Identifier> getOperatorName(Expr *expr);
 
@@ -6052,7 +6052,7 @@ class TypeVarBindingProducer : public BindingProducer<TypeVariableBinding> {
   /// be supertypes extracted from one of the current bindings
   /// or default literal types etc.
   ///
-  /// \returns true if some new bindings were sucessfully computed,
+  /// \returns true if some new bindings were successfully computed,
   /// false otherwise.
   bool computeNext();
 
@@ -6201,15 +6201,15 @@ bool isKnownKeyPathType(Type type);
 /// `{Writable, ReferenceWritable}KeyPath`.
 bool isKnownKeyPathDecl(ASTContext &ctx, ValueDecl *decl);
 
-/// Determine whether givne closure has any explicit `return`
+/// Determine whether given closure has any explicit `return`
 /// statements that could produce non-void result.
 bool hasExplicitResult(ClosureExpr *closure);
 
 /// Emit diagnostics for syntactic restrictions within a given solution
 /// application target.
 void performSyntacticDiagnosticsForTarget(
     const SolutionApplicationTarget &target,
-    bool isExprStmt,bool disableExprAvailabiltyChecking = false);
+    bool isExprStmt,bool disableExprAvailabilityChecking = false);
 
 /// Given a member of a protocol, check whether `Self` type of that
 /// protocol is contextually bound to some concrete type via same-type
 
@@ -144,7 +144,7 @@ namespace swift {
   /// Typecheck the given expression.
   bool typeCheckExpression(DeclContext *DC, Expr *&parsedExpr);
 
-  /// Type check a function body element which is at \p TagetLoc .
+  /// Type check a function body element which is at \p TargetLoc .
   bool typeCheckASTNodeAtLoc(DeclContext *DC, SourceLoc TargetLoc);
 
   /// Thunk around \c TypeChecker::typeCheckForCodeCompletion to make it
@@ -158,7 +158,7 @@ namespace swift {
   /// solutions. Such solutions can have any number of holes in them.
   ///
   /// \returns `true` if target was applicable and it was possible to infer
-  /// types for code completion, `false` othrewise.
+  /// types for code completion, `false` otherwise.
   bool typeCheckForCodeCompletion(
       constraints::SolutionApplicationTarget &target, bool needsPrecheck,
       llvm::function_ref<void(const constraints::Solution &)> callback);
 
@@ -1969,7 +1969,7 @@ class PreCheckResultBuilderApplication : public ASTWalker {
       auto *DC = Fn.getAsDeclContext();
       auto &diagEngine = DC->getASTContext().Diags;
 
-      // Suppress any diangostics which could be produced by this expression.
+      // Suppress any diagnostics which could be produced by this expression.
       DiagnosticTransaction transaction(diagEngine);
 
       HasError |= ConstraintSystem::preCheckExpression(
 
@@ -132,7 +132,7 @@ Solution::resolveConcreteDeclRef(ValueDecl *decl,
   if (!decl)
     return ConcreteDeclRef();
 
-  // Get the generic signatue of the decl and compute the substitutions.
+  // Get the generic signature of the decl and compute the substitutions.
   auto sig = decl->getInnermostDeclContext()->getGenericSignatureOfContext();
   auto subst = computeSubstitutions(sig, locator);
 
@@ -1300,7 +1300,7 @@ namespace {
 
         // If we're opening an existential:
         // - The type of 'memberRef' inside the thunk is written in terms of the
-        //   opened existental archetype.
+        //   opened existential archetype.
         // - The type of the thunk is written in terms of the
         //   erased existential bounds.
         Type opaqueValueTy = openedTy;
@@ -5779,7 +5779,7 @@ ArgumentList *ExprRewriter::coerceCallArguments(
 
       // Since it was allowed to pass function types to @autoclosure
       // parameters in Swift versions < 5, it has to be handled as
-      // a regular function coversion by `coerceToType`.
+      // a regular function conversion by `coerceToType`.
       if (isAutoClosureArgument(argExpr)) {
         // In Swift >= 5 mode we only allow `@autoclosure` arguments
         // to be used by value if parameter would return a function
@@ -5857,7 +5857,7 @@ ArgumentList *ExprRewriter::coerceCallArguments(
 
       // If parameter is an autoclosure, we need to make sure that:
       //   - argument type is coerced to parameter result type
-      //   - impilict autoclosure is created to wrap argument expression
+      //   - implicit autoclosure is created to wrap argument expression
       //   - new types are propagated to constraint system
       auto *closureType = param.getPlainType()->castTo<FunctionType>();
 
@@ -6852,8 +6852,8 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     // leave an explicit escape to noescape cast here such that SILGen can skip
     // the cast and emit a code for the escaping function.
     bool isInDefaultArgumentContext = false;
-    if (auto initalizerCtx = dyn_cast<Initializer>(dc))
-      isInDefaultArgumentContext = (initalizerCtx->getInitializerKind() ==
+    if (auto initializerCtx = dyn_cast<Initializer>(dc))
+      isInDefaultArgumentContext = (initializerCtx->getInitializerKind() ==
                                     InitializerKind::DefaultArgument);
     auto toEI = toFunc->getExtInfo();
     assert(toType->is<FunctionType>());
@@ -6995,7 +6995,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
           expr = cs.cacheType(
               new (ctx) FunctionConversionExpr(expr, escapingToFuncTy));
         }
-        // Apply an explict function conversion *only* for the escape to
+        // Apply an explicit function conversion *only* for the escape to
         // noescape conversion. This conversion will be stripped by the
         // default argument generator. (We can't return a @noescape function)
         auto newExpr =
@@ -7156,7 +7156,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
     return cs.cacheType(new (ctx) UnresolvedTypeConversionExpr(expr, toType));
 
   // Use an opaque type to abstract a value of the underlying concrete type.
-  // The full check here would be that `toType` and `fromType` are structually
+  // The full check here would be that `toType` and `fromType` are structurally
   // equal except in any position where `toType` has an opaque archetype. The
   // below is just an approximate check since the above would be expensive to
   // verify and still relies on the type checker ensuing `fromType` is
@@ -8679,7 +8679,7 @@ ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
   // used again. Here, however, we recover from a rewriting failure and continue
   // using the Rewriter. To make sure we don't continue with an ExprStack that
   // is still in the state when rewriting was aborted, save it here and restore
-  // it once rewritingt this target has finished.
+  // it once rewriting this target has finished.
   llvm::SaveAndRestore<SmallVector<Expr *, 8>> RestoreExprStack(
       Rewriter.ExprStack);
   auto &solution = Rewriter.solution;
 
@@ -353,7 +353,7 @@ void BindingSet::inferTransitiveProtocolRequirements(
     std::tie(parent, currentVar) = workList.pop_back_val();
 
     // At all of the protocols associated with current type variable
-    // are transitive to its parent, propogate them down the subtype/equivalence
+    // are transitive to its parent, propagate them down the subtype/equivalence
     // chain.
     if (parent) {
       propagateProtocolsTo(parent, bindings.getConformanceRequirements(),
@@ -378,7 +378,7 @@ void BindingSet::inferTransitiveProtocolRequirements(
                                      inferredProtocols.end());
     }
 
-    // Propogate inferred protocols to all of the members of the
+    // Propagate inferred protocols to all of the members of the
     // equivalence class.
     for (const auto &equivalence : bindings.Info.EquivalentTo) {
       auto eqBindings = inferredBindings.find(equivalence.first);
@@ -1301,7 +1301,7 @@ PotentialBindings::inferFromRelational(Constraint *constraint) {
       EquivalentTo.insert({bindingTypeVar, constraint});
 
       // Don't record adjacency between base and result types,
-      // this is just an auxiliary contraint to enforce ordering.
+      // this is just an auxiliary constraint to enforce ordering.
       break;
     }
 
@@ -1894,7 +1894,7 @@ TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
   unsigned defaultImpact = 1;
 
   if (auto *GP = TypeVar->getImpl().getGenericParameter()) {
-    // If it is represetative for a key path root, let's emit a more
+    // If it is representative for a key path root, let's emit a more
     // specific diagnostic.
     auto *keyPathRoot =
         cs.isRepresentativeFor(TypeVar, ConstraintLocator::KeyPathRoot);
@@ -2023,9 +2023,9 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
       if (argLoc && argLoc->isAfterCodeCompletionLoc())
         return false;
 
-      // Don't penailze solutions that have holes for ignored arguments.
+      // Don't penalize solutions that have holes for ignored arguments.
       if (cs.hasArgumentsIgnoredForCodeCompletion()) {
-        // Avoid simplifying the locator if the constriant system didn't ignore
+        // Avoid simplifying the locator if the constraint system didn't ignore
         // any arguments.
         auto argExpr = simplifyLocatorToAnchor(TypeVar->getImpl().getLocator());
         if (cs.isArgumentIgnoredForCodeCompletion(argExpr.dyn_cast<Expr *>())) {
 
@@ -149,7 +149,7 @@ class UnresolvedClosureParameterCollector : public ASTWalker {
 
 // MARK: Constraint generation
 
-/// Check whether it makes sense to convert this element into a constrant.
+/// Check whether it makes sense to convert this element into a constraint.
 static bool isViableElement(ASTNode element) {
   if (auto *decl = element.dyn_cast<Decl *>()) {
     // - Ignore variable declarations, they are handled by pattern bindings;
@@ -192,7 +192,7 @@ static void createConjunction(ConstraintSystem &cs,
     referencedVars.push_back(cs.getType(closure)->castTo<TypeVariableType>());
     // Body of the closure is always isolated from its context, only
     // its individual elements are allowed access to type information
-    // from the ouside e.g. parameters/result type.
+    // from the outside e.g. parameters/result type.
     isIsolated = true;
   }
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ class CompletionContextFinder : public ASTWalker {`
`74`	`74`	`return hasContext(ContextKind::MultiStmtClosure);`
`75`	`75`	`}`
`76`	`76`
`77`		`- bool locatedInStringIterpolation() const {`
	`77`	`+ bool locatedInStringInterpolation() const {`
`78`	`78`	`return hasContext(ContextKind::StringInterpolation);`
`79`	`79`	`}`
`80`	`80`
Original file line number	Diff line number	Diff line change
`@@ -817,7 +817,7 @@ class Constraint final : public llvm::ilist_node<Constraint>,`
`817`	`817`	`}`
`818`	`818`
`819`	`819`	`/// Returns the number of resolved argument types for an applied disjunction`
`820`		`- /// constriant. This is always zero for disjunctions that do not represent`
	`820`	`+ /// constraint. This is always zero for disjunctions that do not represent`
`821`	`821`	`/// an applied overload.`
`822`	`822`	`unsigned countResolvedArgumentTypes(ConstraintSystem &cs) const;`
`823`	`823`