Fixing formatting issues

Author: LucianoPAlmeida

lib/Sema/CSFix.cpp

@@ -867,22 +867,24 @@ bool RemoveUnnecessaryCoercion::diagnose(Expr *root, bool asNote) const {
 bool RemoveUnnecessaryCoercion::attempt(ConstraintSystem &cs, Type fromType,
                                         Type toType,
                                         ConstraintLocatorBuilder locator) {
-  if (auto last = locator.last()) {
-    if (last->is<LocatorPathElt::ExplicitTypeCoercion>()) {
-      auto expr = cast<CoerceExpr>(locator.getAnchor());
-      auto toTypeRepr = expr->getCastTypeLoc().getTypeRepr();
-
-      // only diagnosing for coercion where the left-side is a DeclRefExpr
-      // or a explicit/implicit coercion e.g. Double(1) as Double
-      if (!isa<ImplicitlyUnwrappedOptionalTypeRepr>(toTypeRepr) &&
-          (isa<DeclRefExpr>(expr->getSubExpr()) ||
-           isa<CoerceExpr>(expr->getSubExpr()))) {
-        auto *fix = new (cs.getAllocator()) RemoveUnnecessaryCoercion(
-            cs, fromType, toType, cs.getConstraintLocator(locator));
-
-        return cs.recordFix(fix);
-      }
-    }
+  auto last = locator.last();
+  bool isExplicitCoercion =
+      last && last->is<LocatorPathElt::ExplicitTypeCoercion>();
+  if (!isExplicitCoercion)
+    return false;
+
+  auto expr = cast<CoerceExpr>(locator.getAnchor());
+  auto toTypeRepr = expr->getCastTypeLoc().getTypeRepr();
+
+  // only diagnosing for coercion where the left-side is a DeclRefExpr
+  // or a explicit/implicit coercion e.g. Double(1) as Double
+  if (!isa<ImplicitlyUnwrappedOptionalTypeRepr>(toTypeRepr) &&
+      (isa<DeclRefExpr>(expr->getSubExpr()) ||
+       isa<CoerceExpr>(expr->getSubExpr()))) {
+    auto *fix = new (cs.getAllocator()) RemoveUnnecessaryCoercion(
+        cs, fromType, toType, cs.getConstraintLocator(locator));
+
+    return cs.recordFix(fix);
   }
   return false;
 }

lib/Sema/CSFix.h

@@ -197,7 +197,8 @@ enum class FixKind : uint8_t {
   /// by forming all of the given arguments into a single tuple.
   AllowTupleSplatForSingleParameter,
 
-  /// Remove an unnecessary coercion ('as') if the types are already equal. e.g. Double(1) as Double
+  /// Remove an unnecessary coercion ('as') if the types are already equal.
+  /// e.g. Double(1) as Double
   RemoveUnnecessaryCoercion,
 
   /// Allow a single argument type mismatch. This is the most generic
@@ -1345,19 +1346,19 @@ class IgnoreContextualType : public ContextualMismatch {
 
 class RemoveUnnecessaryCoercion : public ContextualMismatch {
 protected:
-  RemoveUnnecessaryCoercion(ConstraintSystem &cs,
-                            Type fromType, Type toType,
+  RemoveUnnecessaryCoercion(ConstraintSystem &cs, Type fromType, Type toType,
                             ConstraintLocator *locator)
-  : ContextualMismatch(cs, FixKind::RemoveUnnecessaryCoercion, fromType, toType,
-                       locator, /*isWarning*/ true) {}
-  
+      : ContextualMismatch(cs, FixKind::RemoveUnnecessaryCoercion, fromType,
+                           toType, locator, /*isWarning*/ true) {}
+
 public:
-  std::string getName() const override { return "remove unnecessary explicit type coercion"; }
-  
+  std::string getName() const override {
+    return "remove unnecessary explicit type coercion";
+  }
+
   bool diagnose(Expr *root, bool asNote = false) const override;
-  
-  static bool attempt(ConstraintSystem &cs,
-                      Type fromType, Type toType,
+
+  static bool attempt(ConstraintSystem &cs, Type fromType, Type toType,
                       ConstraintLocatorBuilder locator);
 };
 

lib/Sema/CSSimplify.cpp

@@ -2588,7 +2588,7 @@ bool ConstraintSystem::repairFailures(
   };
 
   if (path.empty() ||
-      path.back().getKind() == ConstraintLocator::ExplicitTypeCoercion) {
+      path.back().is<LocatorPathElt::ExplicitTypeCoercion>()) {
     if (!anchor)
       return false;