Sema: Restore old behavior in ConstraintSystem::openType()

My change to preserve type sugar in type transforms introduced a
performance regression here, because openType() is called for
every disjunction choice.

My hope is to optimize the TypeAliasType representation and remove
this at some point, but for now, let's just restore the old
desugaring behavior in this case.

Author: slavapestov

include/swift/AST/TypeTransform.h

@@ -472,9 +472,27 @@ case TypeKind::Id:
         return newUnderlyingTy;
 
       auto oldSubMap = alias->getSubstitutionMap();
-      auto newSubMap = asDerived().transformSubMap(oldSubMap);
-      if (oldSubMap && !newSubMap)
-        return Type();
+      SubstitutionMap newSubMap;
+
+      // We leave the old behavior behind for ConstraintSystem::openType(), where
+      // preserving sugar introduces a performance penalty.
+      if (asDerived().shouldDesugarTypeAliases()) {
+        for (auto oldReplacementType : oldSubMap.getReplacementTypes()) {
+          Type newReplacementType = doIt(oldReplacementType, TypePosition::Invariant);
+          if (!newReplacementType)
+            return Type();
+
+          // If anything changed with the replacement type, we lose the sugar.
+          if (newReplacementType.getPointer() != oldReplacementType.getPointer())
+            return newUnderlyingTy;
+        }
+
+        newSubMap = oldSubMap;
+      } else {
+        newSubMap = asDerived().transformSubMap(oldSubMap);
+        if (oldSubMap && !newSubMap)
+          return Type();
+      }
 
       if (oldParentType.getPointer() == newParentType.getPointer() &&
           oldUnderlyingTy.getPointer() == newUnderlyingTy.getPointer() &&
@@ -1011,6 +1029,8 @@ case TypeKind::Id:
 
   bool shouldUnwrapVanishingTuples() const { return true; }
 
+  bool shouldDesugarTypeAliases() const { return false; }
+
   CanType transformSILField(CanType fieldTy, TypePosition pos) {
     return doIt(fieldTy, pos)->getCanonicalType();
   }

lib/Sema/ConstraintSystem.cpp

@@ -1240,6 +1240,10 @@ struct TypeOpener : public TypeTransform<TypeOpener> {
   bool shouldUnwrapVanishingTuples() const {
     return false;
   }
+
+  bool shouldDesugarTypeAliases() const {
+    return true;
+  }
 };
 
 }

test/IDE/complete_call_arg.swift

@@ -1119,7 +1119,7 @@ func testLValueBaseTyOfSubscript() {
   var cache: [String: Codable] = [:]
   if let cached = cache[#^LVALUEBASETY^#
 
-  // LVALUEBASETY-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(position): Dictionary<String, any Codable>.Index#}[']'][#Dictionary<String, any Codable>.Element#];
+  // LVALUEBASETY-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(position): Dictionary<String, any Codable>.Index#}[']'][#(key: String, value: any Codable)#];
   // LVALUEBASETY-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(key): String#}[']'][#@lvalue (any Codable)?#];
 }
 

test/Macros/macro_default_argument_diagnostics.swift

@@ -55,5 +55,5 @@ func testIdentifier(notOkay: Stringified<String> = #stringify(myString)) {}
 // expected-error@+1{{only literals are permitted}}
 func testString(interpolated: Stringified<String> = #stringify("Hello \(0b10001)")) {}
 
-// expected-error@+1{{default argument value of type 'Stringified<Int>' (aka '(Int, String)') cannot be converted to type 'Int'}}
+// expected-error@+1{{default argument value of type '(Int, String)' cannot be converted to type 'Int'}}
 func testReturn(wrongType: Int = #stringify(0)) {}