[Constraint System] Recording SpecifyObjectLiteralTypeImport fix when attempting literal result type variable binding and handle object literal in MissingArgumentsFailure

LucianoPAlmeida · LucianoPAlmeida · commit 716e11f57560 · 2020-01-21T20:39:44.000-03:00
diff --git a/lib/Sema/CSBindings.cpp b/lib/Sema/CSBindings.cpp
@@ -1045,6 +1045,13 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
     cs.DefaultedConstraints.push_back(srcLocator);
 
     if (type->isHole()) {
+      if (auto * OLE = dyn_cast<ObjectLiteralExpr>(srcLocator->getAnchor())) {
+        auto *fix = SpecifyObjectLiteralTypeImport::create(
+            cs, TypeVar->getImpl().getLocator());
+        if (cs.recordFix(fix))
+          return true;
+      }
+      
       if (auto *GP = TypeVar->getImpl().getGenericParameter()) {
         auto path = dstLocator->getPath();
         // Drop `generic parameter` locator element so that all missing
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -3882,7 +3882,7 @@ bool MissingArgumentsFailure::diagnoseSingleMissingArgument() const {
 
   auto *anchor = getRawAnchor();
   if (!(isa<CallExpr>(anchor) || isa<SubscriptExpr>(anchor) ||
-        isa<UnresolvedMemberExpr>(anchor)))
+        isa<UnresolvedMemberExpr>(anchor) || isa<ObjectLiteralExpr>(anchor)))
     return false;
 
   if (SynthesizedArgs.size() != 1)
@@ -4219,6 +4219,9 @@ MissingArgumentsFailure::getCallInfo(Expr *anchor) const {
   } else if (auto *SE = dyn_cast<SubscriptExpr>(anchor)) {
     return std::make_tuple(SE, SE->getIndex(), SE->getNumArguments(),
                            SE->hasTrailingClosure());
+  } else if (auto *OLE = dyn_cast<ObjectLiteralExpr>(anchor)) {
+    return std::make_tuple(OLE, OLE->getArg(), OLE->getNumArguments(),
+                           OLE->hasTrailingClosure());
   }
 
   return std::make_tuple(nullptr, nullptr, 0, false);
@@ -6039,46 +6042,48 @@ bool UnableToInferClosureReturnType::diagnoseAsError() {
   return true;
 }
 
-static std::tuple<StringRef, StringRef>
-getImportModuleAndDefaultType(const ASTContext &ctx, ProtocolDecl *protocol) {
+static std::pair<StringRef, StringRef>
+getImportModuleAndDefaultType(const ASTContext &ctx, ObjectLiteralExpr *expr) {
   const auto &target = ctx.LangOpts.Target;
-  if (protocol ==
-      ctx.getProtocol(KnownProtocolKind::ExpressibleByColorLiteral)) {
-    if (target.isMacOSX()) {
-      return std::make_tuple("AppKit", "NSColor");
-    } else if (target.isiOS() || target.isTvOS()) {
-      return std::make_tuple("UIKit", "UIColor");
+  
+  switch (expr->getLiteralKind()) {
+    case ObjectLiteralExpr::colorLiteral: {
+      if (target.isMacOSX()) {
+        return std::make_pair("AppKit", "NSColor");
+      } else if (target.isiOS() || target.isTvOS()) {
+        return std::make_pair("UIKit", "UIColor");
+      }
+      break;
     }
-  } else if (protocol ==
-             ctx.getProtocol(KnownProtocolKind::ExpressibleByImageLiteral)) {
-    if (target.isMacOSX()) {
-      return std::make_tuple("AppKit", "NSImage");
-    } else if (target.isiOS() || target.isTvOS()) {
-      return std::make_tuple("UIKit", "UIImage");
+
+    case ObjectLiteralExpr::imageLiteral: {
+      if (target.isMacOSX()) {
+        return std::make_pair("AppKit", "NSImage");
+      } else if (target.isiOS() || target.isTvOS()) {
+        return std::make_pair("UIKit", "UIImage");
+      }
+      break;
+    }
+
+    case ObjectLiteralExpr::fileLiteral: {
+      return std::make_pair("Foundation", "URL");
     }
-  } else if (protocol ==
-             ctx.getProtocol(
-                 KnownProtocolKind::ExpressibleByFileReferenceLiteral)) {
-    return std::make_tuple("Foundation", "URL");
   }
-  return std::make_tuple("", "");
+
+  return std::make_pair("", "");
 }
 
 bool UnableToInferProtocolLiteralType::diagnoseAsError() {
-  auto *locator = getLocator();
   auto &cs = getConstraintSystem();
-  auto *expr = cast<ObjectLiteralExpr>(locator->getAnchor());
-
   auto &ctx = cs.getASTContext();
-  auto protocol = TypeChecker::getLiteralProtocol(ctx, expr);
-  assert(protocol);
-  auto plainName = expr->getLiteralKindPlainName();
+  auto *expr = cast<ObjectLiteralExpr>(getLocator()->getAnchor());
 
   StringRef importModule;
   StringRef importDefaultTypeName;
   std::tie(importModule, importDefaultTypeName) =
-      getImportModuleAndDefaultType(ctx, protocol);
+      getImportModuleAndDefaultType(ctx, expr);
 
+  auto plainName = expr->getLiteralKindPlainName();
   emitDiagnostic(expr->getLoc(), diag::object_literal_default_type_missing,
                  plainName);
   if (!importModule.empty()) {
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -1176,20 +1176,7 @@ bool SpecifyObjectLiteralTypeImport::diagnose(bool asNote) const {
 }
 
 SpecifyObjectLiteralTypeImport *
-SpecifyObjectLiteralTypeImport::attempt(ConstraintSystem &cs,
-                                        ConstraintLocator *locator) {
-  // FIXME: ArgumentMismatchFailure is currently used from CSDiag, meaning
-  // we could endup emiting this diagnostic duplicated.
-  if (cs.Options.contains(ConstraintSystemFlags::SubExpressionDiagnostics))
-    return nullptr;
-  
-  auto *anchor = locator->getAnchor();
-  if (!isa<ObjectLiteralExpr>(anchor))
-    return nullptr;
-
-  // * The object literal has no contextual type
-  if (cs.getContextualType())
-    return nullptr;
-  
+SpecifyObjectLiteralTypeImport::create(ConstraintSystem &cs,
+                                       ConstraintLocator *locator) {
   return new (cs.getAllocator()) SpecifyObjectLiteralTypeImport(cs, locator);
 }
diff --git a/lib/Sema/CSFix.h b/lib/Sema/CSFix.h
@@ -236,8 +236,9 @@ 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 infered because the module where it's
-  /// protocol type was not imported.
+  /// Object literal type coudn't be infered because the module where 
+  /// the default type that implements the associated literal protocol
+  /// is declared was not imported.
   SpecifyObjectLiteralTypeImport,
 
 };
@@ -1649,8 +1650,8 @@ class SpecifyObjectLiteralTypeImport final : public ConstraintFix {
 
   bool diagnose(bool asNote = false) const;
 
-  static SpecifyObjectLiteralTypeImport *attempt(ConstraintSystem &cs,
-                                                 ConstraintLocator *locator);
+  static SpecifyObjectLiteralTypeImport *create(ConstraintSystem &cs,
+                                                ConstraintLocator *locator);
 
 };
 
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -1277,7 +1277,8 @@ namespace {
 
       auto tv = CS.createTypeVariable(exprLoc,
                                       TVO_PrefersSubtypeBinding |
-                                      TVO_CanBindToNoEscape);
+                                      TVO_CanBindToNoEscape |
+                                      TVO_CanBindToHole);
       
       CS.addConstraint(ConstraintKind::LiteralConformsTo, tv,
                        protocol->getDeclaredType(),
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -1027,18 +1027,7 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
             argsWithLabels, params, paramInfo, argInfo->HasTrailingClosure,
             cs.shouldAttemptFixes(), listener, parameterBindings))
       return cs.getTypeMatchFailure(locator);
-    
-    if (!callee) {
-      // If we couldn't find a callee, diagnose and maybe suggest
-      // import a module.
-      if (cs.shouldAttemptFixes()) {
-        if (auto *fix = SpecifyObjectLiteralTypeImport::attempt(cs, loc)) {
-          if (cs.recordFix(fix))
-            return cs.getTypeMatchFailure(locator);
-        }
-      }
-    }
-    
+
     auto extraArguments = listener.getExtraneousArguments();
     if (!extraArguments.empty()) {
       if (RemoveExtraneousArguments::isMinMaxNameShadowing(cs, locator))
@@ -1058,7 +1047,6 @@ ConstraintSystem::TypeMatchResult constraints::matchCallArguments(
           return cs.getTypeMatchFailure(locator);
       }
     }
-    
   }
 
   // If this application is part of an operator, then we allow an implicit
diff --git a/lib/Sema/ConstraintLocatorPathElts.def b/lib/Sema/ConstraintLocatorPathElts.def
@@ -135,12 +135,11 @@ CUSTOM_LOCATOR_PATH_ELT(ProtocolRequirement)
 
 /// Type parameter requirements.
 ABSTRACT_LOCATOR_PATH_ELT(AnyRequirement)
+  /// The Nth conditional requirement in the parent locator's conformance.
+  CUSTOM_LOCATOR_PATH_ELT(ConditionalRequirement)
 
-/// The Nth conditional requirement in the parent locator's conformance.
-CUSTOM_LOCATOR_PATH_ELT(ConditionalRequirement)
-
-/// A single requirement placed on the type parameters.
-CUSTOM_LOCATOR_PATH_ELT(TypeParameterRequirement)
+  /// A single requirement placed on the type parameters.
+  CUSTOM_LOCATOR_PATH_ELT(TypeParameterRequirement)
 
 /// RValue adjustment.
 SIMPLE_LOCATOR_PATH_ELT(RValueAdjustment)
@@ -156,12 +155,11 @@ CUSTOM_LOCATOR_PATH_ELT(SynthesizedArgument)
 
 /// Tuple elements.
 ABSTRACT_LOCATOR_PATH_ELT(AnyTupleElement)
+  /// A tuple element referenced by position.
+  CUSTOM_LOCATOR_PATH_ELT(TupleElement)
 
-/// A tuple element referenced by position.
-CUSTOM_LOCATOR_PATH_ELT(TupleElement)
-
-/// A tuple element referenced by name.
-CUSTOM_LOCATOR_PATH_ELT(NamedTupleElement)
+  /// A tuple element referenced by name.
+  CUSTOM_LOCATOR_PATH_ELT(NamedTupleElement)
 
 /// An unresolved member.
 SIMPLE_LOCATOR_PATH_ELT(UnresolvedMember)
