[Constraint solver] Introduce a *trivial* 'meet' operation for types.

Stub out a simplistic 'meet' operation for types that currently only
handles finding the meet of two class types. Use it to optimize the
constraint solver ever so slightly: when we see a type variable whose
constraints state that it is a supertype of two different concrete
types, we attempt to compute their meet and, if we find it, only
produce one potential binding that is the meet itself.

Note that this is an extremely poor implementation of this concept
that is meant to address a specific regression being introduced by the
defaulting of collection literal element types. A real implementation
would, at the very least:

* Implement a proper 'meet' that covers all subtyping in the language.
* Distinguish between "I don't know if there is a meet" and "I am
  absolutely certain that there is no meet".
* Collapse the constraints themselves to reduce the number of
  constraints in the system, rather than just the number of type
  variable bindings we attempt.

Author: DougGregor

include/swift/AST/Type.h

@@ -183,7 +183,30 @@ class Type {
 
   /// Get the canonical type, or return null if the type is null.
   CanType getCanonicalTypeOrNull() const; // in Types.h
-  
+
+  /// Computes the meet between two types.
+  ///
+  /// The meet of two types is the most specific type that is a supertype of
+  /// both \c type1 and \c type2. For example, given a simple class hierarchy as
+  /// follows:
+  ///
+  /// \code
+  /// class A { }
+  /// class B : A { }
+  /// class C : A { }
+  /// class D { }
+  /// \endcode
+  ///
+  /// The meet of B and C is A, the meet of A and B is A. However, there is no
+  /// meet of D and A (or D and B, or D and C) because there is no common
+  /// superclass. One would have to jump to an existential (e.g., \c AnyObject)
+  /// to find a common type.
+  /// 
+  /// \returns the meet of the two types, if there is a concrete type that can
+  /// express the meet, or a null type if the only meet would be a more-general
+  /// existential type (e.g., \c Any).
+  static Type meet(Type type1, Type type2);
+
 private:
   // Direct comparison is disabled for types, because they may not be canonical.
   void operator==(Type T) const = delete;
@@ -432,6 +455,7 @@ class CanGenericSignature {
     return Signature;
   }
 };
+
 } // end namespace swift
 
 namespace llvm {

lib/AST/CMakeLists.txt

@@ -38,6 +38,7 @@ add_swift_library(swiftAST STATIC
   SourceEntityWalker.cpp
   Substitution.cpp
   Type.cpp
+  TypeJoinMeet.cpp
   TypeRefinementContext.cpp
   TypeRepr.cpp
   TypeWalker.cpp

lib/AST/TypeJoinMeet.cpp

@@ -0,0 +1,70 @@
+//===--- TypeJoinMeet.cpp - Swift Type "Join" and "Meet"  -----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the "meet" operation for types (and, eventually,
+//  "join").
+//
+//===----------------------------------------------------------------------===//
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/Types.h"
+#include "llvm/ADT/SmallPtrSet.h"
+using namespace swift;
+
+Type Type::meet(Type type1, Type type2) {
+  assert(!type1->hasTypeVariable() && !type2->hasTypeVariable() &&
+         "Cannot compute meet of types involving type variables");
+
+  // FIXME: This algorithm is woefully incomplete, and is only currently used
+  // for optimizing away extra exploratory work in the constraint solver. It
+  // should eventually encompass all of the subtyping rules of the language.
+
+  // If the types are equivalent, the meet is obvious.
+  if (type1->isEqual(type2))
+    return type1;
+
+  // If both are class types or opaque types that potentially have superclasses,
+  // find the common superclass.
+  if (type1->mayHaveSuperclass() && type2->mayHaveSuperclass()) {
+    ASTContext &ctx = type1->getASTContext();
+    LazyResolver *resolver = ctx.getLazyResolver();
+
+    /// Walk the superclasses of type1 looking for type2. Record them for our
+    /// second step.
+    llvm::SmallPtrSet<CanType, 8> superclassesOfType1;
+    CanType canType2 = type2->getCanonicalType();
+    for (Type super1 = type1; super1; super1 = super1->getSuperclass(resolver)){
+      CanType canSuper1 = super1->getCanonicalType();
+
+      // If we have found the second type, we're done.
+      if (canSuper1 == canType2) return super1;
+
+      superclassesOfType1.insert(canSuper1);
+    }
+
+    // Look through the superclasses of type2 to determine if any were also
+    // superclasses of type1.
+    for (Type super2 = type2; super2; super2 = super2->getSuperclass(resolver)){
+      CanType canSuper2 = super2->getCanonicalType();
+
+      // If we found the first type, we're done.
+      if (superclassesOfType1.count(canSuper2)) return super2;
+    }
+
+    // There is no common superclass; we're done.
+    return nullptr;
+  }
+
+  // The meet can only be an existential.
+  return nullptr;
+}
+

lib/Sema/CSSolver.cpp

@@ -692,8 +692,38 @@ static PotentialBindings getPotentialBindings(ConstraintSystem &cs,
   llvm::SmallPtrSet<Constraint *, 4> visitedConstraints;
   cs.getConstraintGraph().gatherConstraints(typeVar, constraints);
 
-  // Consider each of the constraints related to this type variable.
   PotentialBindings result;
+  Optional<unsigned> lastSupertypeIndex;
+
+  // Local function to add a potential binding to the list of bindings,
+  // coalescing supertype bounds when we are able to compute the meet.
+  auto addPotentialBinding = [&](PotentialBinding binding) {
+    // If this is a non-defaulted supertype binding, check whether we can
+    // combine it with another supertype binding by computing the 'meet' of the
+    // types.
+    if (binding.Kind == AllowedBindingKind::Supertypes &&
+        !binding.BindingType->hasTypeVariable() &&
+        !binding.DefaultedProtocol &&
+        !binding.IsDefaultableBinding) {
+      if (lastSupertypeIndex) {
+        // Can we compute a meet?
+        auto &lastBinding = result.Bindings[*lastSupertypeIndex];
+        if (auto meet =
+                Type::meet(lastBinding.BindingType, binding.BindingType)) {
+          // Replace the last supertype binding with the meet. We're done.
+          lastBinding.BindingType = meet;
+          return;
+        }
+      }
+
+      // Record this as the most recent supertype index.
+      lastSupertypeIndex = result.Bindings.size();
+    }
+
+    result.Bindings.push_back(std::move(binding));
+  };
+
+  // Consider each of the constraints related to this type variable.
   llvm::SmallPtrSet<CanType, 4> exactTypes;
   llvm::SmallPtrSet<ProtocolDecl *, 4> literalProtocols;
   SmallVector<Constraint *, 2> defaultableConstraints;
@@ -767,8 +797,8 @@ static PotentialBindings getPotentialBindings(ConstraintSystem &cs,
           continue;
 
         result.foundLiteralBinding(constraint->getProtocol());
-        result.Bindings.push_back({defaultType, AllowedBindingKind::Subtypes,
-                                   constraint->getProtocol()});
+        addPotentialBinding({defaultType, AllowedBindingKind::Subtypes,
+                             constraint->getProtocol()});
         continue;
       }
 
@@ -794,8 +824,8 @@ static PotentialBindings getPotentialBindings(ConstraintSystem &cs,
       if (!matched) {
         result.foundLiteralBinding(constraint->getProtocol());
         exactTypes.insert(defaultType->getCanonicalType());
-        result.Bindings.push_back({defaultType, AllowedBindingKind::Subtypes,
-                                   constraint->getProtocol()});
+        addPotentialBinding({defaultType, AllowedBindingKind::Subtypes,
+                             constraint->getProtocol()});
       }
 
       continue;
@@ -935,10 +965,10 @@ static PotentialBindings getPotentialBindings(ConstraintSystem &cs,
     }
 
     if (exactTypes.insert(type->getCanonicalType()).second)
-      result.Bindings.push_back({type, kind, None});
+      addPotentialBinding({type, kind, None});
     if (alternateType &&
         exactTypes.insert(alternateType->getCanonicalType()).second)
-      result.Bindings.push_back({alternateType, kind, None});
+      addPotentialBinding({alternateType, kind, None});
   }
 
   // If we have any literal constraints, check whether there is already a
@@ -1016,7 +1046,7 @@ static PotentialBindings getPotentialBindings(ConstraintSystem &cs,
       continue;
 
     ++result.NumDefaultableBindings;
-    result.Bindings.push_back({type, AllowedBindingKind::Exact, None, true});
+    addPotentialBinding({type, AllowedBindingKind::Exact, None, true});
   }
 
   // Determine if the bindings only constrain the type variable from above with