[Sema] introduce InverseType

This type will become the corresponding type that is resolved for an
`InverseTypeRepr`. This kind of type is not expected to appear past type
 checking (currently, not even past requirement lowering!).

Author: kavon

include/swift/AST/TypeMatcher.h

@@ -497,6 +497,13 @@ class TypeMatcher {
                       sugaredFirstType);
     }
 
+    bool visitInverseType(CanInverseType firstInverse,
+                          Type secondType,
+                          Type sugaredFirstType) {
+      // FIXME: If this visitor is reached, determine whether it should've been.
+      llvm_unreachable("Yahaha! You found me!");
+    }
+
     bool visitLValueType(CanLValueType firstLValue, Type secondType,
                          Type sugaredFirstType) {
       if (auto secondLValue = secondType->getAs<LValueType>()) {

include/swift/AST/TypeNodes.def

@@ -180,6 +180,7 @@ ARTIFICIAL_TYPE(SILMoveOnlyWrapped, Type)
 ALWAYS_CANONICAL_ARTIFICIAL_TYPE(SILPack, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
+UNCHECKED_TYPE(Inverse, Type)
 TYPE(ParameterizedProtocol, Type)
 TYPE(Existential, Type)
 TYPE(LValue, Type)

include/swift/AST/Types.h

@@ -1528,6 +1528,39 @@ class NominalOrBoundGenericNominalType : public AnyGenericType {
 };
 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.
+class InverseType final : public TypeBase {
+  Type protocol;
+
+  // The Error type is always canonical.
+  InverseType(Type type,
+              const ASTContext *canonicalContext,
+              RecursiveTypeProperties properties)
+      : TypeBase(TypeKind::Inverse, canonicalContext, properties),
+        protocol(type) {
+    assert(protocol->is<ProtocolType>());
+  }
+
+public:
+  /// Produce an inverse constraint type for the given protocol type.
+  static Type get(Type protocolType);
+
+
+  Type getInvertedProtocol() const {
+    return protocol;
+  }
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::Inverse;
+  }
+};
+BEGIN_CAN_TYPE_WRAPPER(InverseType, Type)
+  PROXY_CAN_TYPE_SIMPLE_GETTER(getInvertedProtocol)
+END_CAN_TYPE_WRAPPER(InverseType, Type)
+
 /// ErrorType - Represents the type of an erroneously constructed declaration,
 /// expression, or type. When creating ErrorTypes, an associated error
 /// diagnostic should always be emitted. That way when later stages of
@@ -7217,7 +7250,8 @@ inline bool TypeBase::isConstraintType() const {
 inline bool CanType::isConstraintTypeImpl(CanType type) {
   return (isa<ProtocolType>(type) ||
           isa<ProtocolCompositionType>(type) ||
-          isa<ParameterizedProtocolType>(type));
+          isa<ParameterizedProtocolType>(type) ||
+          isa<InverseType>(type));
 }
 
 inline bool TypeBase::isExistentialType() {

lib/AST/ASTContext.cpp

@@ -3821,6 +3821,30 @@ 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);
+}
+
 ModuleType *ModuleType::get(ModuleDecl *M) {
   ASTContext &C = M->getASTContext();
 

lib/AST/ASTDumper.cpp

@@ -4318,6 +4318,12 @@ namespace {
       printFoot();
     }
 
+    void visitInverseType(InverseType *T, StringRef label) {
+      printCommon("inverse_type", label);
+      printRec(T->getInvertedProtocol());
+      printFoot();
+    }
+
     void visitLValueType(LValueType *T, StringRef label) {
       printCommon("lvalue_type", label);
       printRec(T->getObjectType());

lib/AST/ASTMangler.cpp

@@ -1401,6 +1401,9 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     case TypeKind::LValue:
       llvm_unreachable("@lvalue types should not occur in function interfaces");
 
+    case TypeKind::Inverse:
+      llvm_unreachable("inverse types should not appear in interfaces");
+
     case TypeKind::InOut:
       appendType(cast<InOutType>(tybase)->getObjectType(), sig, forDecl);
       return appendOperator("z");

lib/AST/ASTPrinter.cpp

@@ -6201,6 +6201,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer << "_";
   }
 
+  void visitInverseType(InverseType *T) {
+    Printer << "~";
+    visit(T->getInvertedProtocol());
+  }
+
   void visitPlaceholderType(PlaceholderType *T) {
     if (Options.PrintTypesForDebugging) {
       Printer << "<<placeholder for ";

lib/AST/ExistentialGeneralization.cpp

@@ -110,6 +110,10 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
                                         origType->hasExplicitAnyObject());
   }
 
+  Type visitInverseType(CanInverseType type) {
+    llvm_unreachable("todo: determine how to handle inverses for Generalizer");
+  }
+
   // Generalize the type arguments of nominal types.
   Type visitBoundGenericType(CanBoundGenericType origType) {
     return generalizeGenericArguments(origType->getDecl(), origType);

lib/AST/Type.cpp

@@ -299,6 +299,7 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::Module:
   case TypeKind::LValue:
   case TypeKind::InOut:
+  case TypeKind::Inverse:
   case TypeKind::TypeVariable:
   case TypeKind::Placeholder:
   case TypeKind::BoundGenericEnum:
@@ -1852,6 +1853,12 @@ CanType TypeBase::computeCanonicalType() {
     Result = ParameterizedProtocolType::get(C, Base, CanArgs);
     break;
   }
+  case TypeKind::Inverse: {
+    auto *inverse = cast<InverseType>(this);
+    auto protocol = inverse->getInvertedProtocol()->getCanonicalType();
+    Result = InverseType::get(protocol).getPointer();
+    break;
+  }
   case TypeKind::Existential: {
     auto *existential = cast<ExistentialType>(this);
     auto constraint = existential->getConstraintType()->getCanonicalType();
@@ -5107,6 +5114,20 @@ case TypeKind::Id:
     return ExistentialType::get(constraint);
   }
 
+  case TypeKind::Inverse: {
+    auto *inverse = cast<InverseType>(base);
+    auto protocol =
+        inverse->getInvertedProtocol().transformWithPosition(pos, fn);
+    if (!protocol || protocol->hasError())
+      return protocol;
+
+    if (protocol.getPointer() ==
+        inverse->getInvertedProtocol().getPointer())
+      return *this;
+
+    return InverseType::get(protocol);
+  }
+
   case TypeKind::ProtocolComposition: {
     auto pc = cast<ProtocolCompositionType>(base);
     SmallVector<Type, 4> substMembers;
@@ -5367,6 +5388,7 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::Module:
   case TypeKind::LValue:
   case TypeKind::InOut:
+  case TypeKind::Inverse:
   case TypeKind::TypeVariable:
   case TypeKind::Placeholder:
   case TypeKind::BoundGenericEnum:

lib/AST/TypeWalker.cpp

@@ -209,6 +209,10 @@ class Traversal : public TypeVisitor<Traversal, bool>
     return doIt(ty->getConstraintType());
   }
 
+  bool visitInverseType(InverseType *ty) {
+    return doIt(ty->getInvertedProtocol());
+  }
+
   bool visitLValueType(LValueType *ty) {
     return doIt(ty->getObjectType());
   }