implement feedback changes

Author: OnyekachiSamuel

lib/Sema/CSDiagnostics.cpp

@@ -474,7 +474,9 @@ bool MissingConformanceFailure::diagnoseTypeCannotConform(
   }
 
   emitDiagnostic(diag::type_cannot_conform,
-                 nonConformingType->isExistentialType(), nonConformingType, nonConformingType->isEqual(protocolType),
+                 nonConformingType->isExistentialType(), 
+                 nonConformingType, 
+                 nonConformingType->isEqual(protocolType),
                  protocolType);
 
   if (auto *OTD = dyn_cast<OpaqueTypeDecl>(AffectedDecl)) {
@@ -2061,7 +2063,8 @@ bool ContextualFailure::diagnoseAsError() {
     if (CTP == CTP_ForEachStmt) {
       if (fromType->isAnyExistentialType()) {
         emitDiagnostic(diag::type_cannot_conform,
-                       /*isExistentialType=*/true, fromType, fromType->isEqual(toType), toType);
+                       /*isExistentialType=*/true, fromType, 
+                       fromType->isEqual(toType), toType);
         return true;
       }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -4256,7 +4256,8 @@ void swift::diagnoseConformanceFailure(Type T,
 
     if (!T->isObjCExistentialType()) {
       diags.diagnose(ComplainLoc, diag::type_cannot_conform, true,
-                     T, T->isEqual(Proto->getDeclaredType()), Proto->getDeclaredType());
+                     T, T->isEqual(Proto->getDeclaredType()), 
+                     Proto->getDeclaredType());
       return;
     }
 

userdocs/diagnostics/protocol-type-non-conformance.md

@@ -11,7 +11,8 @@ var s: P = S() // This creates existential type because the protocol P is used a
 ```
 
 However, a protocol type does not conform to protocols - not even the protocol itself. 
-Allowing existential types to conform to protocols is unsound because some protocol with static methods, initializers, or associated types requirements cannot be accessed from the protocol type itself - these kinds of requirements require a concrete type.
+Allowing existential types to conform to protocols is unsound. For protocols with static method, initializer, or associated type requirements, the implementation of these requirements cannot be accessed from the protocol type - accessing these kinds of requirements must be done using a concrete type.
+
 Let's walk through the example below:
 
 ```swift
@@ -33,13 +34,13 @@ let pluralWord = Plural(word: "mangoes")
 let wordPairDict: [Word: Word] = [singularWord: pluralWord] // Error
 ```
 
-One workaround to fix this problem is to write a type erasure for the protocol `Word`. Think of type erasure as a way to hide an object's type. Since `Word` is of type `Hashable`, we already have `AnyHashable` type erasure available in the standard library which we can easily use here.
+One workaround to fix this problem is to use type erasure for the protocol `Word`. Think of type erasure as a way to hide an object's type. Since `Word` is of type `Hashable`, we already have `AnyHashable` type erasure available in the standard library which we can easily use here.
 
 ```swift 
 // The fix
 let wordPairDict: [AnyHashable: AnyHashable] = [singularWord: pluralWord]
 ```
 
 # Exceptions
-`@objc` protocol type with no static requirements however do conform to its own protocol. One example is the `Error` protocol.
+`@objc` protocol type with no static requirements however do conform to its own protocol. Another exception is the `Error` Swift protocol.