Add an Abstraction For Full Qualification to DiagnosticEngine

Teach the diagnostic engine about a new wrapper type `FullyQualified<T>`. The intent is to clarify which parameters will be printed with additional qualification in diagnostic text. For now, this is only useful for types, so there's a bit of SFINAE guarding against misuse of the abstraction.

 rdar://63199963

Author: CodaFi

include/swift/AST/DiagnosticEngine.h

@@ -74,7 +74,24 @@ namespace swift {
       typedef T type;
     };
   }
-    
+
+  /// A family of wrapper types for compiler data types that forces its
+  /// underlying data to be formatted with full qualification.
+  ///
+  /// So far, this is only useful for \c Type, hence the SFINAE'ing.
+  template <typename T, typename = void> struct FullyQualified {};
+
+  template <typename T>
+  struct FullyQualified<
+      T, typename std::enable_if<std::is_convertible<T, Type>::value>::type> {
+    Type t;
+
+  public:
+    FullyQualified(T t) : t(t){};
+
+    Type getType() const { return t; }
+  };
+
   /// Describes the kind of diagnostic argument we're storing.
   ///
   enum class DiagnosticArgumentKind {
@@ -86,6 +103,7 @@ namespace swift {
     ValueDecl,
     Type,
     TypeRepr,
+    FullyQualifiedType,
     PatternKind,
     SelfAccessKind,
     ReferenceOwnership,
@@ -116,6 +134,7 @@ namespace swift {
       ValueDecl *TheValueDecl;
       Type TypeVal;
       TypeRepr *TyR;
+      FullyQualified<Type> FullyQualifiedTypeVal;
       PatternKind PatternKindVal;
       SelfAccessKind SelfAccessKindVal;
       ReferenceOwnership ReferenceOwnershipVal;
@@ -172,6 +191,10 @@ namespace swift {
       : Kind(DiagnosticArgumentKind::TypeRepr), TyR(T) {
     }
 
+    DiagnosticArgument(FullyQualified<Type> FQT)
+        : Kind(DiagnosticArgumentKind::FullyQualifiedType),
+          FullyQualifiedTypeVal(FQT) {}
+
     DiagnosticArgument(const TypeLoc &TL) {
       if (TypeRepr *tyR = TL.getTypeRepr()) {
         Kind = DiagnosticArgumentKind::TypeRepr;
@@ -268,7 +291,12 @@ namespace swift {
       assert(Kind == DiagnosticArgumentKind::TypeRepr);
       return TyR;
     }
-    
+
+    FullyQualified<Type> getAsFullyQualifiedType() const {
+      assert(Kind == DiagnosticArgumentKind::FullyQualifiedType);
+      return FullyQualifiedTypeVal;
+    }
+
     PatternKind getAsPatternKind() const {
       assert(Kind == DiagnosticArgumentKind::PatternKind);
       return PatternKindVal;

lib/AST/DiagnosticEngine.cpp

@@ -526,21 +526,30 @@ static void formatDiagnosticArgument(StringRef Modifier,
     Out << FormatOpts.ClosingQuotationMark;
     break;
 
+  case DiagnosticArgumentKind::FullyQualifiedType:
   case DiagnosticArgumentKind::Type: {
     assert(Modifier.empty() && "Improper modifier for Type argument");
 
     // Strip extraneous parentheses; they add no value.
-    auto type = Arg.getAsType()->getWithoutParens();
+    Type type;
+    bool needsQualification = false;
+
+    if (Arg.getKind() == DiagnosticArgumentKind::Type) {
+      type = Arg.getAsType()->getWithoutParens();
+      needsQualification = typeSpellingIsAmbiguous(type, Args);
+    } else {
+      assert(Arg.getKind() == DiagnosticArgumentKind::FullyQualifiedType);
+      type = Arg.getAsFullyQualifiedType().getType()->getWithoutParens();
+      needsQualification = true;
+    }
 
     // If a type has an unresolved type, print it with syntax sugar removed for
     // clarity. For example, print `Array<_>` instead of `[_]`.
     if (type->hasUnresolvedType()) {
       type = type->getWithoutSyntaxSugar();
     }
 
-    bool isAmbiguous = typeSpellingIsAmbiguous(type, Args);
-
-    if (isAmbiguous && isa<OpaqueTypeArchetypeType>(type.getPointer())) {
+    if (needsQualification && isa<OpaqueTypeArchetypeType>(type.getPointer())) {
       auto opaqueTypeDecl = type->castTo<OpaqueTypeArchetypeType>()->getDecl();
 
       llvm::SmallString<256> NamingDeclText;
@@ -562,7 +571,7 @@ static void formatDiagnosticArgument(StringRef Modifier,
 
     } else {
       auto printOptions = PrintOptions();
-      printOptions.FullyQualifiedTypes = isAmbiguous;
+      printOptions.FullyQualifiedTypes = needsQualification;
       std::string typeName = type->getString(printOptions);
 
       if (shouldShowAKA(type, typeName)) {