[CSDiagnostics] Offer a fix-it to conform the decl context to the missing protocols during contextual failure

Author: theblixguy

include/swift/AST/DiagnosticsSema.def

@@ -459,6 +459,9 @@ ERROR(cannot_convert_coerce_nil,none,
 ERROR(cannot_convert_assign,none,
       "cannot assign value of type %0 to type %1",
       (Type,Type))
+NOTE(assign_protocol_conformance_fix_it,none,
+     "add missing conformance to %0 to %1 %2",
+     (Type, DescriptiveDeclKind, Type))
 ERROR(cannot_convert_assign_protocol,none,
       "value of type %0 does not conform to %1 in assignment",
       (Type, Type))

lib/Sema/CSDiagnostics.cpp

@@ -2006,6 +2006,9 @@ void ContextualFailure::tryFixIts(InFlightDiagnostic &diagnostic) const {
   if (tryIntegerCastFixIts(diagnostic))
     return;
 
+  if (tryProtocolConformanceFixIt(diagnostic))
+    return;
+
   if (tryTypeCoercionFixIt(diagnostic))
     return;
 }
@@ -2430,6 +2433,101 @@ bool ContextualFailure::tryTypeCoercionFixIt(
   return false;
 }
 
+bool ContextualFailure::tryProtocolConformanceFixIt(
+    InFlightDiagnostic &diagnostic) const {
+  auto innermostTyCtx = getDC()->getInnermostTypeContext();
+  if (!innermostTyCtx)
+    return false;
+
+  auto nominal = innermostTyCtx->getSelfNominalTypeDecl();
+  if (!nominal)
+    return false;
+
+  // We need to get rid of optionals and parens as it's not relevant when
+  // printing the diagnostic and the fix-it.
+  auto unwrappedToType =
+      ToType->lookThroughAllOptionalTypes()->getWithoutParens();
+
+  // If the protocol requires a class & we don't have one (maybe the context
+  // is a struct), then bail out instead of offering a broken fix-it later on.
+  auto requiresClass = false;
+  if (unwrappedToType->isExistentialType()) {
+    if (auto protocolTy = unwrappedToType->getAs<ProtocolType>()) {
+      requiresClass = protocolTy->requiresClass();
+    } else if (auto compositionTy =
+                   unwrappedToType->getAs<ProtocolCompositionType>()) {
+      requiresClass = compositionTy->requiresClass();
+    }
+  }
+  if (requiresClass && !FromType->is<ClassType>()) {
+    return false;
+  }
+
+  // We can only offer a fix-it if we're assigning to a protocol type and
+  // the type we're assigning is the same as the innermost type context.
+  bool shouldOfferFixIt = nominal->getSelfTypeInContext()->isEqual(FromType) &&
+                          unwrappedToType->isExistentialType();
+  if (!shouldOfferFixIt)
+    return false;
+
+  diagnostic.flush();
+
+  // Let's build a list of protocols that the contextual type does not
+  // conform to. We will start by first checking if we have a protocol
+  // composition type and add all the individual types that the context
+  // does not conform to.
+  SmallVector<std::string, 8> missingProtoTypeStrings;
+  if (auto compositionTy = unwrappedToType->getAs<ProtocolCompositionType>()) {
+    for (auto memberTy : compositionTy->getMembers()) {
+      auto protocol = memberTy->getAnyNominal()->getSelfProtocolDecl();
+      if (!getTypeChecker().conformsToProtocol(
+              FromType, protocol, getDC(),
+              ConformanceCheckFlags::InExpression)) {
+        missingProtoTypeStrings.push_back(memberTy->getString());
+      }
+    }
+
+    // If we don't conform to all of the protocols in the composition, then
+    // store the composition type only. This is because we need to append
+    // 'Foo & Bar' instead of 'Foo, Bar' in order to match the written type.
+    if (missingProtoTypeStrings.size() == compositionTy->getMembers().size()) {
+      missingProtoTypeStrings = {compositionTy->getString()};
+    }
+  }
+
+  // If we didn't have a protocol composition type, it means we only have a
+  // single protocol, so just use it directly. Otherwise, construct a comma
+  // separated list of missing types.
+  std::string protoString;
+  if (missingProtoTypeStrings.empty()) {
+    protoString = unwrappedToType->getString();
+  } else if (missingProtoTypeStrings.size() == 1) {
+    protoString = missingProtoTypeStrings.front();
+  } else {
+    protoString = llvm::join(missingProtoTypeStrings, ", ");
+  }
+
+  // Emit a diagnostic to inform the user that they need to conform to the
+  // missing protocols.
+  //
+  // TODO: Maybe also insert the requirement stubs?
+  auto conformanceDiag = emitDiagnostic(
+      getAnchor()->getLoc(), diag::assign_protocol_conformance_fix_it,
+      unwrappedToType, nominal->getDescriptiveKind(), FromType);
+  if (nominal->getInherited().size() > 0) {
+    auto lastInherited = nominal->getInherited().back().getLoc();
+    auto lastInheritedEndLoc =
+        Lexer::getLocForEndOfToken(getASTContext().SourceMgr, lastInherited);
+    conformanceDiag.fixItInsert(lastInheritedEndLoc, ", " + protoString);
+  } else {
+    auto nameEndLoc = Lexer::getLocForEndOfToken(getASTContext().SourceMgr,
+                                                 nominal->getNameLoc());
+    conformanceDiag.fixItInsert(nameEndLoc, ": " + protoString);
+  }
+
+  return true;
+}
+
 void ContextualFailure::tryComputedPropertyFixIts(Expr *expr) const {
   if (!isa<ClosureExpr>(expr))
     return;

lib/Sema/CSDiagnostics.h

@@ -681,6 +681,10 @@ class ContextualFailure : public FailureDiagnostic {
   /// conversion is possible.
   bool tryTypeCoercionFixIt(InFlightDiagnostic &diagnostic) const;
 
+  /// Try to add a fix-it to conform the decl context (if it's a type) to the
+  /// protocol
+  bool tryProtocolConformanceFixIt(InFlightDiagnostic &diagnostic) const;
+
   /// Check whether this contextual failure represents an invalid
   /// conversion from array literal to dictionary.
   static bool isInvalidDictionaryConversion(ConstraintSystem &cs, Expr *anchor,

test/decl/protocol/protocols.swift

@@ -511,3 +511,71 @@ extension LetThereBeCrash {
   init() { x = 1 }
   // expected-error@-1 {{'let' property 'x' may not be initialized directly; use "self.init(...)" or "self = ..." instead}}
 }
+
+// SR-11412
+// Offer fix-it to conform type of context to the missing protocols
+
+protocol SR_11412_P1 {}
+protocol SR_11412_P2 {}
+protocol SR_11412_P3 {}
+protocol SR_11412_P4: AnyObject {}
+
+class SR_11412_C0 {
+  var foo1: SR_11412_P1?
+  var foo2: (SR_11412_P1 & SR_11412_P2)?
+  weak var foo3: SR_11412_P4?
+}
+
+// Context has no inherited types and does not conform to protocol //
+
+class SR_11412_C1 {
+  let c0 = SR_11412_C0()
+
+  func conform() {
+    c0.foo1 = self // expected-error {{cannot assign value of type 'SR_11412_C1' to type 'SR_11412_P1?'}}
+    // expected-note@-1 {{add missing conformance to 'SR_11412_P1' to class 'SR_11412_C1'}}{{18-18=: SR_11412_P1}}
+  }
+}
+
+// Context has no inherited types and does not conform to protocol composition //
+
+class SR_11412_C2 {
+  let c0 = SR_11412_C0()
+
+  func conform() {
+    c0.foo2 = self // expected-error {{cannot assign value of type 'SR_11412_C2' to type '(SR_11412_P1 & SR_11412_P2)?'}}
+    // expected-note@-1 {{add missing conformance to 'SR_11412_P1 & SR_11412_P2' to class 'SR_11412_C2'}}{{18-18=: SR_11412_P1 & SR_11412_P2}}
+  }
+}
+
+// Context already has an inherited type, but does not conform to protocol //
+
+class SR_11412_C3: SR_11412_P3 {
+  let c0 = SR_11412_C0()
+
+  func conform() {
+    c0.foo1 = self // expected-error {{cannot assign value of type 'SR_11412_C3' to type 'SR_11412_P1?'}}
+    // expected-note@-1 {{add missing conformance to 'SR_11412_P1' to class 'SR_11412_C3'}}{{31-31=, SR_11412_P1}}
+  }
+}
+
+// Context conforms to only one protocol in the protocol composition //
+
+class SR_11412_C4: SR_11412_P1 {
+  let c0 = SR_11412_C0()
+
+  func conform() {
+    c0.foo2 = self // expected-error {{cannot assign value of type 'SR_11412_C4' to type '(SR_11412_P1 & SR_11412_P2)?'}}
+    // expected-note@-1 {{add missing conformance to 'SR_11412_P1 & SR_11412_P2' to class 'SR_11412_C4'}}{{31-31=, SR_11412_P2}}
+  }
+}
+
+// Context is a value type, but protocol requires class //
+
+struct SR_11412_S0 {
+  let c0 = SR_11412_C0()
+
+  func conform() {
+    c0.foo3 = self // expected-error {{cannot assign value of type 'SR_11412_S0' to type 'SR_11412_P4?'}}
+  }
+}