[Constraint solver] More progress on the constraint solver type map.

Author: rudkx

lib/Sema/CSApply.cpp

@@ -1412,7 +1412,7 @@ namespace {
       // Wrap in covariant `Self` return if needed.
       if (selfTy->hasReferenceSemantics()) {
         auto covariantTy = resultTy
-          ->replaceCovariantResultType(base->getType()
+          ->replaceCovariantResultType(cs.getType(base)
                                            ->getLValueOrInOutObjectType(),
                                        ctor->getNumParameterLists());
         if (!covariantTy->isEqual(resultTy))
@@ -7300,9 +7300,11 @@ Expr *TypeChecker::callWitness(Expr *base, DeclContext *dc,
                             /*implicit=*/true, getType);
   }
 
+  cs.cacheSubExprTypes(call);
+
   // Add the conversion from the argument to the function parameter type.
   cs.addConstraint(ConstraintKind::ArgumentTupleConversion,
-                   call->getArg()->getType(),
+                   cs.getType(call->getArg()),
                    openedType->castTo<FunctionType>()->getInput(),
                    cs.getConstraintLocator(call,
                                            ConstraintLocator::ApplyArgument));

lib/Sema/CSGen.cpp

@@ -1820,7 +1820,7 @@ namespace {
         unsigned index = 0;
         for (auto element : expr->getElements()) {
           CS.addConstraint(ConstraintKind::Conversion,
-                           element->getType(),
+                           CS.getType(element),
                            contextualDictionaryElementType,
                            CS.getConstraintLocator(expr,
                                                    LocatorPathElt::
@@ -1862,8 +1862,8 @@ namespace {
             if (element1 == element2)
               continue;
 
-            auto tty1 = element1->getType()->getAs<TupleType>();
-            auto tty2 = element2->getType()->getAs<TupleType>();
+            auto tty1 = CS.getType(element1)->getAs<TupleType>();
+            auto tty2 = CS.getType(element2)->getAs<TupleType>();
 
             if (tty1 && tty2) {
               auto mergedKey = false;
@@ -1911,7 +1911,7 @@ namespace {
       for (auto element : expr->getElements()) {
         if (!mergedElements.count(element))
           CS.addConstraint(ConstraintKind::Conversion,
-                           element->getType(),
+                           CS.getType(element),
                            elementTy,
                            CS.getConstraintLocator(
                              expr,

lib/Sema/ConstraintSystem.h

@@ -1161,8 +1161,10 @@ class ConstraintSystem {
         : RootExpr(expr), CS(cs), ExcludeRoot(excludeRoot) {}
 
     Expr *walkToExprPost(Expr *expr) override {
-      if (ExcludeRoot && expr == RootExpr)
+      if (ExcludeRoot && expr == RootExpr) {
+        assert(!expr->getType() && "Unexpected type in root of expression!");
         return expr;
+      }
 
       if (expr->getType())
         CS.cacheType(expr);
@@ -1428,14 +1430,12 @@ class ConstraintSystem {
   void setType(Expr *E, Type T) {
     assert(T && "Expected non-null type!");
 
-    // FIXME: Ideally this would be enabled but there are currently at
-    // least a few places where we set types to different values. We
-    // should track down and fix those places.
-
+    // FIXME: We sometimes set the type and then later set it to a
+    //        value that is slightly different, e.g. not an lvalue.
     // assert((ExprTypes.find(E) == ExprTypes.end() ||
     //         ExprTypes.find(E)->second->isEqual(T) ||
     //         ExprTypes.find(E)->second->hasTypeVariable()) &&
-    //        "Expected type to be set exactly once!");
+    //        "Expected type to be invariant!");
 
     ExprTypes[E] = T.getPointer();
 
@@ -1452,9 +1452,10 @@ class ConstraintSystem {
   /// Get the type for an expression.
   Type getType(const Expr *E) const {
     assert(hasType(E) && "Expected type to have been set!");
-    assert((!E->getType() ||
-            E->getType()->isEqual(ExprTypes.find(E)->second)) &&
-           "Mismatched types!");
+    // FIXME: lvalue differences
+    //    assert((!E->getType() ||
+    //            E->getType()->isEqual(ExprTypes.find(E)->second)) &&
+    //           "Mismatched types!");
     return ExprTypes.find(E)->second;
   }