[CSDiagnostics] Unwrap some packs types for diagnostics

If diagnostic references a `Pack{repeat ...}` unwrap it to underlying
pattern.

Author: xedin

lib/Sema/CSDiagnostics.h

@@ -99,37 +99,42 @@ class FailureDiagnostic {
   /// Resolve type variables present in the raw type, if any.
   Type resolveType(Type rawType, bool reconstituteSugar = false,
                    bool wantRValue = true) const {
-    if (rawType->hasTypeVariable() || rawType->hasPlaceholder()) {
-      rawType = rawType.transform([&](Type type) -> Type {
-        if (auto *typeVar = type->getAs<TypeVariableType>()) {
-          auto resolvedType = S.simplifyType(typeVar);
-
-          if (!resolvedType->hasUnresolvedType())
-            return resolvedType;
-
-          // If type variable was simplified to an unresolved pack expansion
-          // type, let's examine its original pattern type because it could
-          // contain type variables replaceable with their generic parameter
-          // types.
-          if (auto *expansion = resolvedType->getAs<PackExpansionType>()) {
-            auto *locator = typeVar->getImpl().getLocator();
-            auto *openedExpansionTy =
-                locator->castLastElementTo<LocatorPathElt::PackExpansionType>()
-                    .getOpenedType();
-            auto patternType = resolveType(openedExpansionTy->getPatternType());
-            return PackExpansionType::get(patternType,
-                                          expansion->getCountType());
-          }
-
-          Type GP = typeVar->getImpl().getGenericParameter();
-          return resolvedType->is<UnresolvedType>() && GP ? GP : resolvedType;
+    rawType = rawType.transform([&](Type type) -> Type {
+      if (auto *typeVar = type->getAs<TypeVariableType>()) {
+        auto resolvedType = S.simplifyType(typeVar);
+
+        if (!resolvedType->hasUnresolvedType())
+          return resolvedType;
+
+        // If type variable was simplified to an unresolved pack expansion
+        // type, let's examine its original pattern type because it could
+        // contain type variables replaceable with their generic parameter
+        // types.
+        if (auto *expansion = resolvedType->getAs<PackExpansionType>()) {
+          auto *locator = typeVar->getImpl().getLocator();
+          auto *openedExpansionTy =
+              locator->castLastElementTo<LocatorPathElt::PackExpansionType>()
+                  .getOpenedType();
+          auto patternType = resolveType(openedExpansionTy->getPatternType());
+          return PackExpansionType::get(patternType, expansion->getCountType());
         }
 
-        return type->isPlaceholder()
-                   ? Type(type->getASTContext().TheUnresolvedType)
-                   : type;
-      });
-    }
+        Type GP = typeVar->getImpl().getGenericParameter();
+        return resolvedType->is<UnresolvedType>() && GP ? GP : resolvedType;
+      }
+
+      if (auto *packType = type->getAs<PackType>()) {
+        if (packType->getNumElements() == 1) {
+          auto eltType = resolveType(packType->getElementType(0));
+          if (auto expansion = eltType->getAs<PackExpansionType>())
+            return expansion->getPatternType();
+        }
+      }
+
+      return type->isPlaceholder()
+                 ? Type(type->getASTContext().TheUnresolvedType)
+                 : type;
+    });
 
     if (reconstituteSugar)
       rawType = rawType->reconstituteSugar(/*recursive*/ true);