[Sema] handle inverses everywhere

Previously, inverses were only accounted-for in inheritance clauses.

This batch of changes handles inverses appearing in other places, like:

- Protocol compositions
- `some ~Copyable`
- where clauses

with proper attribution of default requirements in their absence.

Author: kavon

include/swift/AST/ExistentialLayout.h

@@ -36,6 +36,7 @@ struct ExistentialLayout {
   }
 
   ExistentialLayout(CanProtocolType type);
+  ExistentialLayout(CanInverseType type);
   ExistentialLayout(CanProtocolCompositionType type);
   ExistentialLayout(CanParameterizedProtocolType type);
 

include/swift/AST/KnownProtocols.def

@@ -41,6 +41,14 @@
     PROTOCOL_WITH_NAME(Id, Name)
 #endif
 
+/// \def INVERTIBLE_PROTOCOL_WITH_NAME(id, name)
+/// \param Name a string literal with the external name of this protocol
+/// \param Id the internal "enum name" of this protocol.
+#ifndef INVERTIBLE_PROTOCOL_WITH_NAME
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) \
+    PROTOCOL_WITH_NAME(Id, Name)
+#endif
+
 
 #define PROTOCOL(name) PROTOCOL_WITH_NAME(name, #name)
 #define PROTOCOL_(name) PROTOCOL_WITH_NAME(name, "_" #name)
@@ -127,7 +135,7 @@ PROTOCOL(AsyncIteratorProtocol)
 
 PROTOCOL(FloatingPoint)
 
-PROTOCOL(Copyable)
+INVERTIBLE_PROTOCOL_WITH_NAME(Copyable, "Copyable")
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByBooleanLiteral, "BooleanLiteralType", true)
@@ -156,6 +164,7 @@ BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_(ExpressibleByBuiltinUnicodeScalarLitera
 #undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
 #undef BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_
 #undef BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
+#undef INVERTIBLE_PROTOCOL_WITH_NAME
 #undef PROTOCOL
 #undef PROTOCOL_
 #undef PROTOCOL_WITH_NAME

include/swift/AST/KnownProtocols.h

@@ -42,15 +42,37 @@ enum : uint8_t {
 enum : unsigned { NumKnownProtocolKindBits =
   countBitsUsed(static_cast<unsigned>(NumKnownProtocols - 1)) };
 
-using KnownProtocolSet = FixedBitSet<NumKnownProtocols, KnownProtocolKind>;
-
-/// Produces a set of all protocols that have an inverse, i.e., for every
-/// known protocol KP in the set, ~KP exists.
-KnownProtocolSet getInvertibleProtocols();
-
 /// Retrieve the name of the given known protocol.
 llvm::StringRef getProtocolName(KnownProtocolKind kind);
 
+/// MARK: Invertible protocols
+///
+/// The invertible protocols are a subset of the known protocols.
+
+enum : uint8_t {
+  // Use preprocessor trick to count all the invertible protocols.
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) +1
+  /// The number of invertible protocols.
+  NumInvertibleProtocols =
+#include "swift/AST/KnownProtocols.def"
+};
+
+enum class InvertibleProtocolKind : uint8_t {
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) Id,
+#include "swift/AST/KnownProtocols.def"
+};
+
+using InvertibleProtocolSet = FixedBitSet<NumInvertibleProtocols,
+                                          InvertibleProtocolKind>;
+
+/// Maps a KnownProtocol to the set of InvertibleProtocols, if a mapping exists.
+/// \returns None if the known protocol is not invertible.
+llvm::Optional<InvertibleProtocolKind>
+    getInvertibleProtocolKind(KnownProtocolKind kp);
+
+/// Returns the KnownProtocolKind corresponding to an InvertibleProtocolKind.
+KnownProtocolKind getKnownProtocolKind(InvertibleProtocolKind ip);
+
 } // end namespace swift
 
 #endif

include/swift/AST/TypeMatcher.h

@@ -500,7 +500,8 @@ class TypeMatcher {
     bool visitInverseType(CanInverseType firstInverse,
                           Type secondType,
                           Type sugaredFirstType) {
-      // FIXME: If this visitor is reached, determine whether it should've been.
+      // NOTE: If this visitor is reached, determine whether it should've been
+      // before implementing this.
       llvm_unreachable("Yahaha! You found me!");
     }
 

include/swift/AST/Types.h

@@ -24,6 +24,7 @@
 #include "swift/AST/ExtInfo.h"
 #include "swift/AST/GenericParamKey.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/KnownProtocols.h"
 #include "swift/AST/Ownership.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Requirement.h"
@@ -100,7 +101,6 @@ class ProtocolConformance;
 enum PointerTypeKind : unsigned;
 struct ValueOwnershipKind;
 class ErrorExpr;
-enum class KnownProtocolKind : uint8_t;
 
 typedef CanTypeWrapper<SILFunctionType> CanSILFunctionType;
 
@@ -1530,11 +1530,16 @@ DEFINE_EMPTY_CAN_TYPE_WRAPPER(NominalOrBoundGenericNominalType, AnyGenericType)
 
 /// InverseType represents the "inverse" of a ProtocolType as a constraint.
 /// An inverse represents the _absence_ of an implicit constraint to the given
-/// protocol. It is not a real type.
+/// protocol.
+///
+/// Otherwise, an inverse is not a real type! It's an annotation for other types
+/// to signal whether an implicit requirement on that type should be omitted.
+/// Because that annotation is expressed in the surface language as if it _were_
+/// a type (that is, as a type constraint) we still model it as a Type through
+/// typechecking.
 class InverseType final : public TypeBase {
   Type protocol;
 
-  // The Error type is always canonical.
   InverseType(Type type,
               const ASTContext *canonicalContext,
               RecursiveTypeProperties properties)
@@ -1548,10 +1553,14 @@ class InverseType final : public TypeBase {
   static Type get(Type protocolType);
 
 
+  /// Obtain the underlying \c ProtocolType that was inverted.
   Type getInvertedProtocol() const {
     return protocol;
   }
 
+  /// Get known kind of inverse this type represents.
+  InvertibleProtocolKind getInverseKind() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::Inverse;
@@ -5766,13 +5775,37 @@ class ProtocolCompositionType final : public TypeBase,
     public llvm::FoldingSetNode,
     private llvm::TrailingObjects<ProtocolCompositionType, Type> {
   friend TrailingObjects;
+
+  // TODO: this could probably be folded into the existing Bits field
+  // or we could just store the InverseType's in the Members array.
+  InvertibleProtocolSet Inverses;
 
 public:
   /// Retrieve an instance of a protocol composition type with the
-  /// given set of members.
+  /// given set of members. A "hidden member" is an implicit constraint that
+  /// is present for all protocol compositions.
+  ///
+  /// \param Members the regular members of this composition.
+  /// \param Inverses the set of inverses that are a member of the composition,
+  ///                 i.e., if \c IP is in this set, then \c ~IP is a member of
+  ///                 this composition.
+  /// \param HasExplicitAnyObject indicates whether this composition should be
+  /// treated as if \c AnyObject was a member.
+  static Type get(const ASTContext &C, ArrayRef<Type> Members,
+                  InvertibleProtocolSet Inverses,
+                  bool HasExplicitAnyObject);
+
+  /// Retrieve an instance of a protocol composition type with the
+  /// given set of members. Assumes no inverses are present in \c Members.
   static Type get(const ASTContext &C, ArrayRef<Type> Members,
                   bool HasExplicitAnyObject);
 
+  /// Constructs a protocol composition corresponding to the `Any` type.
+  static Type theAnyType(const ASTContext &C);
+
+  /// Constructs a protocol composition corresponding to the `AnyObject` type.
+  static Type theAnyObjectType(const ASTContext &C);
+
   /// Canonical protocol composition types are minimized only to a certain
   /// degree to preserve ABI compatibility. This routine enables performing
   /// slower, but stricter minimization at need (e.g. redeclaration checking).
@@ -5795,11 +5828,14 @@ class ProtocolCompositionType final : public TypeBase,
     return {getTrailingObjects<Type>(), Bits.ProtocolCompositionType.Count};
   }
 
+  InvertibleProtocolSet getInverses() const { return Inverses; }
+
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, getMembers(), hasExplicitAnyObject());
+    Profile(ID, getMembers(), getInverses(), hasExplicitAnyObject());
   }
   static void Profile(llvm::FoldingSetNodeID &ID,
                       ArrayRef<Type> Members,
+                      InvertibleProtocolSet Inverses,
                       bool HasExplicitAnyObject);
 
   /// True if the composition requires the concrete conforming type to
@@ -5820,12 +5856,15 @@ class ProtocolCompositionType final : public TypeBase,
 private:
   static ProtocolCompositionType *build(const ASTContext &C,
                                         ArrayRef<Type> Members,
+                                        InvertibleProtocolSet Inverses,
                                         bool HasExplicitAnyObject);
 
   ProtocolCompositionType(const ASTContext *ctx, ArrayRef<Type> members,
+                          InvertibleProtocolSet inverses,
                           bool hasExplicitAnyObject,
                           RecursiveTypeProperties properties)
-    : TypeBase(TypeKind::ProtocolComposition, /*Context=*/ctx, properties) {
+    : TypeBase(TypeKind::ProtocolComposition, /*Context=*/ctx, properties),
+      Inverses(inverses) {
     Bits.ProtocolCompositionType.HasExplicitAnyObject = hasExplicitAnyObject;
     Bits.ProtocolCompositionType.Count = members.size();
     std::uninitialized_copy(members.begin(), members.end(),
@@ -7267,6 +7306,7 @@ inline bool CanType::isExistentialTypeImpl(CanType type) {
          isa<ProtocolCompositionType>(type) ||
          isa<ExistentialType>(type) ||
          isa<ParameterizedProtocolType>(type);
+  // TODO(kavon): treat InverseType as an existential, etc?
 }
 
 inline bool CanType::isAnyExistentialTypeImpl(CanType type) {

include/swift/Basic/FixedBitSet.h

@@ -84,14 +84,21 @@ class FixedBitSet {
 
 public:
   /// Build an empty set.
-  FixedBitSet() {}
+  constexpr FixedBitSet() {}
 
   /// Build a set containing the given elements.
   FixedBitSet(std::initializer_list<ValueType> elements) {
     for (const auto &elt : elements)
       insert(elt);
   }
 
+  /// Build a set filled with all possible elements, i.e., a "full" set.
+  static FixedBitSet full() {
+    FixedBitSet set;
+    set.insertAll();
+    return set;
+  }
+
   /// Return true if the set is empty.
   bool empty() const {
     for (auto chunk : chunks)

lib/AST/ASTContext.cpp

@@ -102,8 +102,24 @@ llvm::StringRef swift::getProtocolName(KnownProtocolKind kind) {
   llvm_unreachable("bad KnownProtocolKind");
 }
 
-KnownProtocolSet swift::getInvertibleProtocols() {
-  return { KnownProtocolKind::Copyable };
+/// Maps a KnownProtocol to the set of InvertibleProtocols, if a mapping exists.
+llvm::Optional<InvertibleProtocolKind>
+    swift::getInvertibleProtocolKind(KnownProtocolKind kp) {
+  switch (kp) {
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) \
+    case KnownProtocolKind::Id: return InvertibleProtocolKind::Id;
+#include "swift/AST/KnownProtocols.def"
+  default: return llvm::None;
+  }
+}
+
+/// Returns the KnownProtocolKind corresponding to an InvertibleProtocolKind.
+KnownProtocolKind swift::getKnownProtocolKind(InvertibleProtocolKind ip) {
+  switch (ip) {
+#define INVERTIBLE_PROTOCOL_WITH_NAME(Id, Name) \
+    case InvertibleProtocolKind::Id: return KnownProtocolKind::Id;
+#include "swift/AST/KnownProtocols.def"
+  }
 }
 
 namespace {
@@ -444,6 +460,7 @@ struct ASTContext::Implementation {
     llvm::DenseMap<std::pair<ClassDecl*, Type>, ClassType*> ClassTypes;
     llvm::DenseMap<std::pair<ProtocolDecl*, Type>, ProtocolType*> ProtocolTypes;
     llvm::DenseMap<Type, ExistentialType *> ExistentialTypes;
+    llvm::DenseMap<Type, InverseType *> InverseTypes;
     llvm::FoldingSet<UnboundGenericType> UnboundGenericTypes;
     llvm::FoldingSet<BoundGenericType> BoundGenericTypes;
     llvm::FoldingSet<ProtocolCompositionType> ProtocolCompositionTypes;
@@ -669,8 +686,7 @@ ASTContext::ASTContext(
                             UnresolvedType(*this)),
       TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
       TheEmptyPackType(PackType::get(*this, {})),
-      TheAnyType(ProtocolCompositionType::get(*this, ArrayRef<Type>(),
-                                              /*HasExplicitAnyObject=*/false)),
+      TheAnyType(ProtocolCompositionType::theAnyType(*this)),
 #define SINGLETON_TYPE(SHORT_ID, ID) \
     The##SHORT_ID##Type(new (*this, AllocationArena::Permanent) \
                           ID##Type(*this)),
@@ -1056,8 +1072,7 @@ CanType ASTContext::getAnyObjectConstraint() const {
   }
 
   getImpl().AnyObjectType = CanType(
-    ProtocolCompositionType::get(
-      *this, {}, /*HasExplicitAnyObject=*/true));
+    ProtocolCompositionType::theAnyObjectType(*this));
   return getImpl().AnyObjectType;
 }
 
@@ -3632,13 +3647,14 @@ ClassType *ClassType::get(ClassDecl *D, Type Parent, const ASTContext &C) {
 
 ProtocolCompositionType *
 ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Members,
+                               InvertibleProtocolSet Inverses,
                                bool HasExplicitAnyObject) {
-  assert(Members.size() != 1 || HasExplicitAnyObject);
+  assert(Members.size() != 1 || HasExplicitAnyObject || !Inverses.empty());
 
   // Check to see if we've already seen this protocol composition before.
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;
-  ProtocolCompositionType::Profile(ID, Members, HasExplicitAnyObject);
+  ProtocolCompositionType::Profile(ID, Members, Inverses, HasExplicitAnyObject);
 
   bool isCanonical = true;
   RecursiveTypeProperties properties;
@@ -3661,6 +3677,7 @@ ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Members,
   auto mem = C.Allocate(size, alignof(ProtocolCompositionType), arena);
   auto compTy = new (mem) ProtocolCompositionType(isCanonical ? &C : nullptr,
                                                   Members,
+                                                  Inverses,
                                                   HasExplicitAnyObject,
                                                   properties);
   C.getImpl().getArena(arena).ProtocolCompositionTypes.InsertNode(
@@ -3821,28 +3838,26 @@ Type ExistentialMetatypeType::getExistentialInstanceType() {
   return ExistentialType::get(getInstanceType());
 }
 
-Type InverseType::get(Type protocol) {
-  auto &C = protocol->getASTContext();
-  llvm_unreachable("TODO");
-//  // ExistentialMetatypeType is already an existential type.
-//  if (constraint->is<ExistentialMetatypeType>())
-//    return constraint;
-//
-//  bool printWithAny = true;
-//  if (constraint->isEqual(C.TheAnyType) || constraint->isAnyObject())
-//    printWithAny = false;
-//
-//  auto properties = constraint->getRecursiveProperties();
-//  auto arena = getArena(properties);
-//
-//  auto &entry = C.getImpl().getArena(arena).ExistentialTypes[constraint];
-//  if (entry)
-//    return entry;
-//
-//  const ASTContext *canonicalContext = constraint->isCanonical() ? &C : nullptr;
-//  return entry = new (C, arena) ExistentialType(constraint, printWithAny,
-//                                                canonicalContext,
-//                                                properties);
+InvertibleProtocolKind InverseType::getInverseKind() const {
+  return *getInvertibleProtocolKind(*protocol->getKnownProtocol());
+}
+
+Type InverseType::get(Type invertedProto) {
+  auto &C = invertedProto->getASTContext();
+
+  auto properties = invertedProto->getRecursiveProperties();
+  auto arena = getArena(properties);
+
+  auto &entry = C.getImpl().getArena(arena).InverseTypes[invertedProto];
+  if (entry)
+    return entry;
+
+  const ASTContext *canonicalContext =
+      invertedProto->isCanonical() ? &C : nullptr;
+
+  return entry = new (C, arena) InverseType(invertedProto,
+                                            canonicalContext,
+                                            properties);
 }
 
 ModuleType *ModuleType::get(ModuleDecl *M) {

lib/AST/Builtins.cpp

@@ -132,8 +132,7 @@ Type swift::getBuiltinType(ASTContext &Context, StringRef Name) {
   // AnyObject is the empty class-constrained existential.
   if (Name == "AnyObject")
     return CanType(
-      ProtocolCompositionType::get(Context, {},
-                                   /*HasExplicitAnyObject=*/true));
+      ProtocolCompositionType::theAnyObjectType(Context));
 
   return Type();
 }

lib/AST/ExistentialGeneralization.cpp

@@ -111,7 +111,8 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
   }
 
   Type visitInverseType(CanInverseType type) {
-    llvm_unreachable("todo: determine how to handle inverses for Generalizer");
+    // TODO(kavon): determine how to handle inverses for ExistentialGeneralization
+    llvm_unreachable("unimplemented");
   }
 
   // Generalize the type arguments of nominal types.