Merge pull request swiftlang#18664 from xedin/cs-improve-fix-interface

[ConstraintSystem] Replace `Fix` with richer `ConstraintFix` interface

Author: xedin

lib/Sema/CMakeLists.txt

@@ -11,6 +11,7 @@ add_swift_library(swiftSema STATIC
   CSRanking.cpp
   CSSimplify.cpp
   CSSolver.cpp
+  CSFix.cpp
   CSDiagnostics.cpp
   CalleeCandidateInfo.cpp
   CodeSynthesis.cpp

lib/Sema/CSApply.cpp

@@ -7762,21 +7762,20 @@ Expr *ConstraintSystem::coerceToRValue(Expr *expr) {
 /// Emit the fixes computed as part of the solution, returning true if we were
 /// able to emit an error message, or false if none of the fixits worked out.
 bool ConstraintSystem::applySolutionFixes(Expr *E, const Solution &solution) {
-  llvm::SmallDenseMap<Expr *,
-                      SmallVector<std::pair<Fix, ConstraintLocator *>, 4>>
+  llvm::SmallDenseMap<Expr *, SmallVector<const ConstraintFix *, 4>>
       fixesPerExpr;
 
-  for (const auto &fix : solution.Fixes)
-    fixesPerExpr[fix.second->getAnchor()].push_back(fix);
+  for (auto *fix : solution.Fixes)
+    fixesPerExpr[fix->getAnchor()].push_back(fix);
 
   auto diagnoseExprFailures = [&](Expr *expr) -> bool {
     auto fixes = fixesPerExpr.find(expr);
     if (fixes == fixesPerExpr.end())
       return false;
 
     bool diagnosed = false;
-    for (auto &fix : fixes->second)
-      diagnosed |= applySolutionFix(E, solution, fix);
+    for (const auto *fix : fixes->second)
+      diagnosed |= fix->diagnose(E, solution);
     return diagnosed;
   };
 
@@ -7793,86 +7792,6 @@ bool ConstraintSystem::applySolutionFixes(Expr *E, const Solution &solution) {
   return diagnosed;
 }
 
-/// \brief Apply the specified Fix to this solution, producing a fix-it hint
-/// diagnostic for it and returning true.  If the fix-it hint turned out to be
-/// bogus, this returns false and doesn't emit anything.
-bool ConstraintSystem::applySolutionFix(
-    Expr *expr, const Solution &solution,
-    std::pair<Fix, ConstraintLocator *> &fix) {
-  // Some fixes need more information from the locator.
-  ConstraintLocator *locator = fix.second;
-
-  // In the case of us having applied a type member constraint against a
-  // synthesized type variable during diagnostic generation, we may not have
-  // a valid locator.
-  if (!locator)
-    return false;
-
-  switch (fix.first.getKind()) {
-  case FixKind::ForceOptional: {
-    MissingOptionalUnwrapFailure failure(expr, solution, locator);
-    return failure.diagnose();
-  }
-          
-  case FixKind::UnwrapOptionalBase: {
-    auto memberName = fix.first.getDeclNameArgument(*this);
-    bool resultIsOptional =
-        fix.first.isUnwrapOptionalBaseByOptionalChaining(*this);
-    MemberAccessOnOptionalBaseFailure failure(expr, solution, locator,
-                                              memberName, resultIsOptional);
-    return failure.diagnose();
-  }
-
-  case FixKind::ForceDowncast: {
-    MissingExplicitConversionFailure failure(expr, solution, locator,
-                                             fix.first.getTypeArgument(*this));
-    return failure.diagnose();
-  }
-
-  case FixKind::AddressOf: {
-    MissingAddressOfFailure failure(expr, solution, locator);
-    return failure.diagnose();
-  }
-
-  case FixKind::CoerceToCheckedCast: {
-    MissingForcedDowncastFailure failure(expr, solution, locator);
-    return failure.diagnose();
-  }
-
-  case FixKind::ExplicitlyEscaping: {
-    NoEscapeFuncToTypeConversionFailure failure(expr, solution, locator);
-    return failure.diagnose();
-  }
-
-  case FixKind::ExplicitlyEscapingToAny: {
-    NoEscapeFuncToTypeConversionFailure failure(expr, solution, locator,
-                                                getASTContext().TheAnyType);
-    return failure.diagnose();
-  }
-
-  case FixKind::RelabelArguments: {
-    LabelingFailure failure(solution, fix.second,
-                            fix.first.getArgumentLabels(*this));
-    return failure.diagnose();
-  }
-
-  case FixKind::AddConformance: {
-    auto *anchor = locator->getAnchor();
-    auto &reqLoc = locator->getPath().back();
-    MissingConformanceFailure failure(
-        expr, solution, fix.second,
-        MissingConformances[{anchor, reqLoc.getValue()}]);
-    return failure.diagnose();
-  }
-  }
-
-  // FIXME: It would be really nice to emit a follow-up note showing where
-  // we got the other type information from, e.g., the parameter we're
-  // initializing.
-  return false;
-}
-
-
 /// \brief Apply a given solution to the expression, producing a fully
 /// type-checked expression.
 Expr *ConstraintSystem::applySolution(Solution &solution, Expr *expr,

lib/Sema/CSDiagnostics.h

@@ -155,7 +155,7 @@ class MissingConformanceFailure final : public RequirementFailure {
 public:
   MissingConformanceFailure(Expr *expr, const Solution &solution,
                             ConstraintLocator *locator,
-                            std::pair<TypeBase *, ProtocolDecl *> conformance)
+                            std::pair<Type, ProtocolDecl *> conformance)
       : RequirementFailure(expr, solution, locator),
         NonConformingType(conformance.first), Protocol(conformance.second) {}
 

lib/Sema/CSFix.cpp

@@ -0,0 +1,154 @@
+//===--- CSFix.cpp - Constraint Fixes -------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the \c ConstraintFix class and its related types,
+// which is used by constraint solver to attempt to fix constraints to be
+// able to produce a solution which is easily diagnosable.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CSFix.h"
+#include "CSDiagnostics.h"
+#include "ConstraintLocator.h"
+#include "ConstraintSystem.h"
+#include "swift/AST/Expr.h"
+#include "swift/AST/Type.h"
+#include "swift/Basic/SourceManager.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/raw_ostream.h"
+#include <string>
+
+using namespace swift;
+using namespace constraints;
+
+ConstraintFix::~ConstraintFix() {}
+
+Expr *ConstraintFix::getAnchor() const { return getLocator()->getAnchor(); }
+
+void ConstraintFix::print(llvm::raw_ostream &Out, SourceManager *sm) const {
+  Out << "[fix: ";
+  Out << getName();
+  Out << ']';
+  Out << " @ ";
+  getLocator()->dump(sm, Out);
+}
+
+void ConstraintFix::dump(SourceManager *sm) const { print(llvm::errs(), sm); }
+
+std::string ForceDowncast::getName() const {
+  llvm::SmallString<16> name;
+  name += "force downcast (as! ";
+  name += DowncastTo->getString();
+  name += ")";
+  return name.c_str();
+}
+
+bool ForceDowncast::diagnose(Expr *expr, const Solution &solution) const {
+  MissingExplicitConversionFailure failure(expr, solution, getLocator(),
+                                           DowncastTo);
+  return failure.diagnose();
+}
+
+ForceDowncast *ForceDowncast::create(ConstraintSystem &cs, Type toType,
+                                     ConstraintLocator *locator) {
+  return new (cs.getAllocator()) ForceDowncast(toType, locator);
+}
+
+bool ForceOptional::diagnose(Expr *root, const Solution &solution) const {
+  MissingOptionalUnwrapFailure failure(root, solution, getLocator());
+  return failure.diagnose();
+}
+
+ForceOptional *ForceOptional::create(ConstraintSystem &cs,
+                                     ConstraintLocator *locator) {
+  return new (cs.getAllocator()) ForceOptional(locator);
+}
+
+bool UnwrapOptionalBase::diagnose(Expr *root, const Solution &solution) const {
+  bool resultIsOptional =
+      getKind() == FixKind::UnwrapOptionalBaseWithOptionalResult;
+  MemberAccessOnOptionalBaseFailure failure(root, solution, getLocator(),
+                                            MemberName, resultIsOptional);
+  return failure.diagnose();
+}
+
+UnwrapOptionalBase *UnwrapOptionalBase::create(ConstraintSystem &cs,
+                                               DeclName member,
+                                               ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      UnwrapOptionalBase(FixKind::UnwrapOptionalBase, member, locator);
+}
+
+UnwrapOptionalBase *UnwrapOptionalBase::createWithOptionalResult(
+    ConstraintSystem &cs, DeclName member, ConstraintLocator *locator) {
+  return new (cs.getAllocator()) UnwrapOptionalBase(
+      FixKind::UnwrapOptionalBaseWithOptionalResult, member, locator);
+}
+
+bool AddAddressOf::diagnose(Expr *root, const Solution &solution) const {
+  MissingAddressOfFailure failure(root, solution, getLocator());
+  return failure.diagnose();
+}
+
+AddAddressOf *AddAddressOf::create(ConstraintSystem &cs,
+                                   ConstraintLocator *locator) {
+  return new (cs.getAllocator()) AddAddressOf(locator);
+}
+
+bool CoerceToCheckedCast::diagnose(Expr *root, const Solution &solution) const {
+  MissingForcedDowncastFailure failure(root, solution, getLocator());
+  return failure.diagnose();
+}
+
+CoerceToCheckedCast *CoerceToCheckedCast::create(ConstraintSystem &cs,
+                                                 ConstraintLocator *locator) {
+  return new (cs.getAllocator()) CoerceToCheckedCast(locator);
+}
+
+bool MarkExplicitlyEscaping::diagnose(Expr *root,
+                                      const Solution &solution) const {
+  NoEscapeFuncToTypeConversionFailure failure(root, solution, getLocator(),
+                                              ConvertTo);
+  return failure.diagnose();
+}
+
+MarkExplicitlyEscaping *
+MarkExplicitlyEscaping::create(ConstraintSystem &cs, ConstraintLocator *locator,
+                               Type convertingTo) {
+  return new (cs.getAllocator()) MarkExplicitlyEscaping(locator, convertingTo);
+}
+
+bool RelabelArguments::diagnose(Expr *root, const Solution &solution) const {
+  LabelingFailure failure(solution, getLocator(), getLabels());
+  return failure.diagnose();
+}
+
+RelabelArguments *
+RelabelArguments::create(ConstraintSystem &cs,
+                         llvm::ArrayRef<Identifier> correctLabels,
+                         ConstraintLocator *locator) {
+  unsigned size = totalSizeToAlloc<Identifier>(correctLabels.size());
+  void *mem = cs.getAllocator().Allocate(size, alignof(RelabelArguments));
+  return new (mem) RelabelArguments(correctLabels, locator);
+}
+
+bool MissingConformance::diagnose(Expr *root, const Solution &solution) const {
+  MissingConformanceFailure failure(root, solution, getLocator(),
+                                    {NonConformingType, Protocol});
+  return failure.diagnose();
+}
+
+MissingConformance *MissingConformance::create(ConstraintSystem &cs, Type type,
+                                               ProtocolDecl *protocol,
+                                               ConstraintLocator *locator) {
+  return new (cs.getAllocator()) MissingConformance(type, protocol, locator);
+}