[TypeChecker/SE-0307] NFC: Fix typos and clarify a couple of comments

Thanks Xiaodi Wu!

Author: xedin

include/swift/AST/Types.h

@@ -800,7 +800,8 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Check if this is a nominal type defined at the top level of the Swift module
   bool isStdlibType();
 
-  /// Check if this is a CGFloat type from `CoreGraphics` module.
+  /// Check if this is a CGFloat type from CoreGraphics framework
+  /// on macOS or Foundation on Linux.
   bool isCGFloatType();
 
   /// Check if this is a Double type from standard library.

include/swift/Basic/LangOptions.h

@@ -580,7 +580,7 @@ namespace swift {
     /// See \ref FrontendOptions.PrintFullConvention
     bool PrintFullConvention = false;
 
-    /// Disallow Double and CGFloat types to be used interchangeably.
+    /// Disallow Double and CGFloat types from being used interchangeably.
     bool DisableImplicitDoubleCGFloatConversion = false;
   };
 

include/swift/Sema/Constraint.h

@@ -262,7 +262,7 @@ enum class ConversionRestrictionKind {
   /// an implicit CGFloat initializer call.
   DoubleToCGFloat,
   /// Implicit conversion from a value of CGFloat type to a value of Double type
-  /// via an implicit call to an initializer passing CGFloat value.
+  /// via an implicit Double initializer call passing a CGFloat value.
   CGFloatToDouble,
 };
 

include/swift/Sema/ConstraintSystem.h

@@ -794,7 +794,7 @@ enum ScoreKind {
   SK_ForceUnchecked,
   /// An implicit conversion from a value of one type (lhs)
   /// to another type (rhs) via implicit initialization of
-  /// `rhs` type which an argument of `lhs` value.
+  /// `rhs` type with an argument of `lhs` value.
   SK_ImplicitValueConversion,
   /// A user-defined conversion.
   SK_UserConversion,
@@ -1406,7 +1406,7 @@ enum class ConstraintSystemFlags {
   /// `__attribute__((ns_consumed))`.
   UseClangFunctionTypes = 0x80,
 
-  /// Disallow to use Double and CGFloat interchangeably through means of
+  /// Disallow using Double and CGFloat interchangeably by means of
   /// an implicit value conversion.
   DisableImplicitDoubleCGFloatConversion = 0x100,
 };

lib/AST/Type.cpp

@@ -822,7 +822,7 @@ bool TypeBase::isCGFloatType() {
     return false;
 
   auto *module = DC->getParentModule();
-  // on macOS `CGFloat` is part of a `CoreGraphics` module,
+  // On macOS `CGFloat` is part of a `CoreGraphics` module,
   // but on Linux it could be found in `Foundation`.
   return (module->getName().is("CoreGraphics") ||
           module->getName().is("Foundation")) &&

lib/Sema/CSGen.cpp

@@ -565,9 +565,9 @@ namespace {
                        ->getWithoutParens()
                        ->getWithoutSpecifierType();
 
-      // There is no CGFloat overloads on some of the unary operators, so
-      // in order to preserve current behavior let's not favor overloads
-      // which would result in conversion from CGFloat to Double otherwise
+      // There are no CGFloat overloads on some of the unary operators, so
+      // in order to preserve current behavior, let's not favor overloads
+      // which would result in conversion from CGFloat to Double; otherwise
       // it would lead to ambiguities.
       if (argTy->isCGFloatType() && paramTy->isDoubleType())
         return false;

lib/Sema/CSSimplify.cpp

@@ -5120,7 +5120,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
 
         auto isCoercionOrCast = [](ASTNode anchor,
                                    ArrayRef<LocatorPathElt> path) {
-          // e.g. contextual conversion from coercion/cast
+          // E.g. contextual conversion from coercion/cast
           // to some other type.
           if (!path.empty())
             return false;
@@ -10576,12 +10576,12 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
     auto *memberLoc = getConstraintLocator(
         applicationLoc, ConstraintLocator::ConstructorMember);
 
-    // This conversion has been already attempted for and constructor
-    // choice has been recorded.
+    // Conversion has been already attempted for this direction
+    // and constructor choice has been recorded.
     if (findSelectedOverloadFor(memberLoc))
       return SolutionKind::Solved;
 
-    // Allocate a single argument info to conver all possible
+    // Allocate a single argument info to cover all possible
     // Double <-> CGFloat conversion locations.
     if (!ArgumentInfos.count(memberLoc)) {
       auto &ctx = getASTContext();

lib/Sema/CSStep.cpp

@@ -702,7 +702,7 @@ bool DisjunctionStep::shouldSkip(const DisjunctionChoice &choice) const {
     // Not all of the unary operators have `CGFloat` overloads,
     // so in order to preserve previous behavior (and overall
     // best solution) with implicit Double<->CGFloat conversion
-    // we need to allow  attempting generic operators for such cases.
+    // we need to allow attempting generic operators for such cases.
     if (score[SK_ImplicitValueConversion] > 0 && choice.isUnaryOperator())
       return false;