Make Type::join return Any by default.

For the moment, update the sole caller to not infer Any in cases where
neither argument was Any. This is in part because not all the cases are
handled here and the result of inferring Any will be to miss appropriate
bindings in certain cases. It is also in part because by inferring Any
we may end up deferring diagnostics until later in a function, which may
result in very hard to understand diagnostics for users.

This will be revisted once all the cases are properly handled here.

Author: rudkx

lib/AST/TypeJoinMeet.cpp

@@ -48,8 +48,7 @@ struct TypeJoin : TypeVisitor<TypeJoin, Type> {
   Type visitType(Type second) {
     // FIXME: Implement all the visitors.
     //    llvm_unreachable("Unimplemented type visitor!");
-    // return First->getASTContext().TheAnyType;
-    return nullptr;
+    return First->getASTContext().TheAnyType;
   }
 
 public:
@@ -90,9 +89,8 @@ Type TypeJoin::getSuperclassJoin(Type first, Type second) {
   if (!first || !second)
     return TypeJoin::join(first, second);
 
-  // FIXME: Return Any
   if (!first->mayHaveSuperclass() || !second->mayHaveSuperclass())
-    return nullptr;
+    return first->getASTContext().TheAnyType;
 
   /// Walk the superclasses of `first` looking for `second`. Record them
   /// for our second step.
@@ -102,7 +100,8 @@ Type TypeJoin::getSuperclassJoin(Type first, Type second) {
     CanType canSuper = super->getCanonicalType();
 
     // If we have found the second type, we're done.
-    if (canSuper == canSecond) return super;
+    if (canSuper == canSecond)
+      return super;
 
     superclassesOfFirst.insert(canSuper);
   }
@@ -113,12 +112,12 @@ Type TypeJoin::getSuperclassJoin(Type first, Type second) {
     CanType canSuper = super->getCanonicalType();
 
     // If we found the first type, we're done.
-    if (superclassesOfFirst.count(canSuper)) return super;
+    if (superclassesOfFirst.count(canSuper))
+      return super;
   }
 
-  // FIXME: Return Any
   // There is no common superclass; we're done.
-  return nullptr;
+  return first->getASTContext().TheAnyType;
 }
 
 Type TypeJoin::visitClassType(Type second) {
@@ -138,47 +137,38 @@ Type TypeJoin::visitDynamicSelfType(Type second) {
 }
 
 Type TypeJoin::visitMetatypeType(Type second) {
-  assert(!First->mayHaveSuperclass() && !second->mayHaveSuperclass());
-
-  // FIXME: Return Any
   if (First->getKind() != second->getKind())
-    return nullptr;
+    return First->getASTContext().TheAnyType;
 
   auto firstInstance = First->castTo<AnyMetatypeType>()->getInstanceType();
   auto secondInstance = second->castTo<AnyMetatypeType>()->getInstanceType();
 
   auto joinInstance = join(firstInstance, secondInstance);
 
-  // FIXME: Return Any
   if (!joinInstance)
-    return nullptr;
+    return First->getASTContext().TheAnyType;
 
   return MetatypeType::get(joinInstance);
 }
 
 Type TypeJoin::visitExistentialMetatypeType(Type second) {
-  assert(!First->mayHaveSuperclass() && !second->mayHaveSuperclass());
-
-  // FIXME: Return Any
   if (First->getKind() != second->getKind())
-    return nullptr;
+    return First->getASTContext().TheAnyType;
 
   auto firstInstance = First->castTo<AnyMetatypeType>()->getInstanceType();
   auto secondInstance = second->castTo<AnyMetatypeType>()->getInstanceType();
 
   auto joinInstance = join(firstInstance, secondInstance);
 
-  // FIXME: Return Any
   if (!joinInstance)
-    return nullptr;
+    return First->getASTContext().TheAnyType;
 
   return ExistentialMetatypeType::get(joinInstance);
 }
 
 Type TypeJoin::visitBoundGenericEnumType(Type second) {
-  // FIXME: Return Any
   if (First->getKind() != second->getKind())
-    return nullptr;
+    return First->getASTContext().TheAnyType;
 
   OptionalTypeKind otk1, otk2;
   Type objectType1 = First->getAnyOptionalObjectType(otk1);
@@ -188,15 +178,14 @@ Type TypeJoin::visitBoundGenericEnumType(Type second) {
     Type unwrappedJoin = join(objectType1 ? objectType1 : First,
                               objectType2 ? objectType2 : second);
     // FIXME: More general joins of enums need to be handled.
-    if (!unwrappedJoin) return nullptr;
+    if (!unwrappedJoin)
+      return First->getASTContext().TheAnyType;
 
     return OptionalType::get(unwrappedJoin);
   }
 
-  // FIXME: More general joins of enums need to be handled, and
-  //        then Any should be returned when there is no better
-  //        choice.
-  return nullptr;
+  // FIXME: More general joins of enums need to be handled.
+  return First->getASTContext().TheAnyType;
 }
 
 Type TypeJoin::visitOptionalType(Type second) {

lib/Sema/ConstraintSystem.h

@@ -2644,10 +2644,15 @@ class ConstraintSystem {
           auto &lastBinding = Bindings[*lastSupertypeIndex];
           auto lastType = lastBinding.BindingType->getWithoutSpecifierType();
           auto bindingType = binding.BindingType->getWithoutSpecifierType();
-          if (auto join = Type::join(lastType, bindingType)) {
-            // Replace the last supertype binding with the join. We're done.
-            lastBinding.BindingType = join;
-            return;
+          auto join = Type::join(lastType, bindingType);
+          if (join) {
+            auto anyType = join->getASTContext().TheAnyType;
+            if (!join->isEqual(anyType) || lastType->isEqual(anyType) ||
+                bindingType->isEqual(anyType)) {
+              // Replace the last supertype binding with the join. We're done.
+              lastBinding.BindingType = join;
+              return;
+            }
           }
         }
 

test/Constraints/array_literal.swift

@@ -304,8 +304,6 @@ struct Beef : Pear {}
 
 let routerFruit = Company(
   routes: [
-    // FIXME: implement join() for existentials
-    // expected-error@+1 {{cannot convert value of type '() -> Tomato.Type' to expected element type '() -> _'}}
     { () -> Tomato.Type in
       _ = ()
       return Chicken.self