Store the conforming type within an abstract ProtocolConformanceRef

An "abstract" ProtocolConformanceRef is a conformance of a type
parameter or archetype to a given protocol. Previously, we would only
store the protocol requirement itself---but not track the actual
conforming type, requiring clients of ProtocolConformanceRef to keep
track of this information separately.

Record the conforming type as part of an abstract ProtocolConformanceRef,
so that clients will be able to recover it later. This is handled by a uniqued
AbstractConformance structure, so that ProtocolConformanceRef itself stays one
pointer.

There remain a small number of places where we create an abstract
ProtocolConformanceRef with a null type. We'll want to chip away at
those and establish some stronger invariants on the abstract conformance
in the future.

Author: DougGregor

include/swift/AST/ProtocolConformanceRef.h

@@ -26,8 +26,24 @@
 #include "llvm/ADT/STLExtras.h"
 #include <optional>
 
+namespace swift {
+class AbstractConformance;
+}
+
 namespace llvm {
-  class raw_ostream;
+class raw_ostream;
+
+template <>
+struct PointerLikeTypeTraits<swift::AbstractConformance *> {
+public:
+  static inline void *getAsVoidPointer(swift::AbstractConformance *ptr) {
+    return ptr;
+  }
+  static inline swift::AbstractConformance *getFromVoidPointer(void *ptr) {
+    return (swift::AbstractConformance *)ptr;
+  }
+  enum { NumLowBitsAvailable = swift::TypeAlignInBits };
+};
 }
 
 namespace swift {
@@ -53,22 +69,27 @@ enum class EffectKind : uint8_t;
 /// ProtocolConformanceRef allows the efficient recovery of the protocol
 /// even when the conformance is abstract.
 class ProtocolConformanceRef {
-  using UnionType = llvm::PointerUnion<ProtocolDecl *,
+public:
+  using UnionType = llvm::PointerUnion<AbstractConformance *,
                                        ProtocolConformance *,
                                        PackConformance *>;
+
+private:
   UnionType Union;
 
   explicit ProtocolConformanceRef(UnionType value) : Union(value) {}
 
+public:
+  ProtocolConformanceRef() : Union() {}
+  ProtocolConformanceRef(std::nullptr_t) : Union() {}
+
   /// Create an abstract protocol conformance reference.
-  explicit ProtocolConformanceRef(ProtocolDecl *proto) : Union(proto) {
-    assert(proto != nullptr &&
+  explicit ProtocolConformanceRef(AbstractConformance *abstract)
+      : Union(abstract) {
+    assert(abstract != nullptr &&
            "cannot construct ProtocolConformanceRef with null");
   }
 
-public:
-  ProtocolConformanceRef() : Union() {}
-
   /// Create a concrete protocol conformance reference.
   explicit ProtocolConformanceRef(ProtocolConformance *conf) : Union(conf) {
     assert(conf != nullptr &&
@@ -95,7 +116,7 @@ class ProtocolConformanceRef {
   explicit operator bool() const { return !isInvalid(); }
 
   /// Create an abstract conformance for a type parameter or archetype.
-  static ProtocolConformanceRef forAbstract(Type subjectType,
+  static ProtocolConformanceRef forAbstract(Type conformingType,
                                             ProtocolDecl *protocol);
 
   bool isConcrete() const {
@@ -115,12 +136,11 @@ class ProtocolConformanceRef {
   }
 
   bool isAbstract() const {
-    return !isInvalid() && Union.is<ProtocolDecl*>();
+    return !isInvalid() && Union.is<AbstractConformance*>();
   }
 
-  ProtocolDecl *getAbstract() const {
-    ASSERT(isAbstract());
-    return Union.get<ProtocolDecl*>();
+  AbstractConformance *getAbstract() const {
+    return Union.get<AbstractConformance *>();
   }
 
   /// Determine whether this conformance (or a conformance it depends on)
@@ -149,7 +169,7 @@ class ProtocolConformanceRef {
   /// The given `body` will be called on each isolated conformance. If it ever
   /// returns `true`, this function will abort the search and return `true`.
   bool forEachIsolatedConformance(
-      llvm::function_ref<bool(ProtocolConformance*)> body
+      llvm::function_ref<bool(ProtocolConformanceRef)> body
   ) const;
 
   using OpaqueValue = void*;
@@ -158,6 +178,9 @@ class ProtocolConformanceRef {
     return ProtocolConformanceRef(UnionType::getFromOpaqueValue(value));
   }
 
+  /// Retrieve the conforming type.
+  Type getConformingType() const;
+
   /// Return the protocol requirement.
   ProtocolDecl *getRequirement() const;
 
@@ -240,4 +263,22 @@ SourceLoc extractNearestSourceLoc(const ProtocolConformanceRef conformanceRef);
 
 } // end namespace swift
 
+namespace llvm {
+class raw_ostream;
+
+template <>
+struct PointerLikeTypeTraits<swift::ProtocolConformanceRef>
+  : PointerLikeTypeTraits<swift::ProtocolConformanceRef::UnionType>
+{
+public:
+  static inline void *getAsVoidPointer(swift::ProtocolConformanceRef ref) {
+    return ref.getOpaqueValue();
+  }
+  static inline swift::ProtocolConformanceRef getFromVoidPointer(void *ptr) {
+    return swift::ProtocolConformanceRef::getFromOpaqueValue(ptr);
+  }
+};
+
+}
+
 #endif // LLVM_SWIFT_AST_PROTOCOLCONFORMANCEREF_H

include/swift/AST/Requirement.h

@@ -192,7 +192,7 @@ class Requirement {
   CheckRequirementResult checkRequirement(
       SmallVectorImpl<Requirement> &subReqs,
       bool allowMissing = false,
-      SmallVectorImpl<ProtocolConformance *> *isolatedConformances = nullptr
+      SmallVectorImpl<ProtocolConformanceRef> *isolatedConformances = nullptr
   ) const;
 
   /// Determines if this substituted requirement can ever be satisfied,

lib/AST/ASTContext.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/ASTContext.h"
+#include "AbstractConformance.h"
 #include "ClangTypeConverter.h"
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
@@ -595,6 +596,9 @@ struct ASTContext::Implementation {
     /// The set of substitution maps (uniqued by their storage).
     llvm::FoldingSet<SubstitutionMap::Storage> SubstitutionMaps;
 
+    /// The set of abstract conformances (uniqued by their storage).
+    llvm::FoldingSet<AbstractConformance> AbstractConformances;
+
     ~Arena() {
       for (auto &conformance : SpecializedConformances)
         conformance.~SpecializedProtocolConformance();
@@ -3378,6 +3382,7 @@ void ASTContext::Implementation::Arena::dump(llvm::raw_ostream &os) const {
     SIZE_AND_BYTES(BuiltinConformances);
     SIZE(PackConformances);
     SIZE(SubstitutionMaps);
+    SIZE(AbstractConformances);
 
 #undef SIZE
 #undef SIZE_AND_BYTES
@@ -5723,6 +5728,35 @@ SubstitutionMap::Storage *SubstitutionMap::Storage::get(
   return result;
 }
 
+ProtocolConformanceRef ProtocolConformanceRef::forAbstract(
+    Type conformingType, ProtocolDecl *proto) {
+  ASTContext &ctx = proto->getASTContext();
+
+  // Figure out which arena this should go in.
+  RecursiveTypeProperties properties;
+  if (conformingType)
+    properties |= conformingType->getRecursiveProperties();
+  auto arena = getArena(properties);
+
+  // Profile the substitution map.
+  llvm::FoldingSetNodeID id;
+  AbstractConformance::Profile(id, conformingType, proto);
+
+  // Did we already record this abstract conformance?
+  void *insertPos;
+  auto &abstractConformances =
+      ctx.getImpl().getArena(arena).AbstractConformances;
+  if (auto result = abstractConformances.FindNodeOrInsertPos(id, insertPos))
+    return ProtocolConformanceRef(result);
+
+  // Allocate and record this abstract conformance.
+  auto mem = ctx.Allocate(sizeof(AbstractConformance),
+                          alignof(AbstractConformance), arena);
+  auto result = new (mem) AbstractConformance(conformingType, proto);
+  abstractConformances.InsertNode(result, insertPos);
+  return ProtocolConformanceRef(result);
+}
+
 const AvailabilityContext::Storage *AvailabilityContext::Storage::get(
     const AvailabilityRange &platformRange, bool isDeprecated,
     llvm::ArrayRef<DomainInfo> domainInfos, const ASTContext &ctx) {

lib/AST/ASTDumper.cpp

@@ -5512,7 +5512,7 @@ class PrintConformance : public PrintBase {
       assert(conformance.isAbstract());
 
       printHead("abstract_conformance", ASTNodeColor, label);
-      printReferencedDeclField(conformance.getAbstract(),
+      printReferencedDeclField(conformance.getRequirement(),
                                Label::always("protocol"));
       printFoot();
     }

lib/AST/ASTMangler.cpp

@@ -4533,7 +4533,7 @@ void ASTMangler::appendAnyProtocolConformance(
       return;
 
     auto path = genericSig->getConformancePath(conformingType,
-                                               conformance.getAbstract());
+                                               conformance.getRequirement());
     appendDependentProtocolConformance(path, genericSig);
   } else if (auto opaqueType = conformingType->getAs<OpaqueTypeArchetypeType>()) {
     if (forInvertible)
@@ -4544,7 +4544,7 @@ void ASTMangler::appendAnyProtocolConformance(
     ConformancePath conformancePath =
         opaqueSignature->getConformancePath(
           opaqueType->getInterfaceType(),
-          conformance.getAbstract());
+          conformance.getRequirement());
 
     // Append the conformance path with the signature of the opaque type.
     appendDependentProtocolConformance(conformancePath, opaqueSignature);

lib/AST/AbstractConformance.h

@@ -0,0 +1,51 @@
+//===--- AbstractConformance.h - Abstract conformance storage ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AbstractConformance class, which stores an
+// abstract conformance that is stashed in a ProtocolConformanceRef.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SWIFT_AST_ABSTRACT_CONFORMANCE_H
+#define SWIFT_AST_ABSTRACT_CONFORMANCE_H
+
+#include "swift/AST/Type.h"
+#include "llvm/ADT/FoldingSet.h"
+
+namespace swift {
+class AbstractConformance final : public llvm::FoldingSetNode {
+  Type conformingType;
+  ProtocolDecl *requirement;
+
+public:
+  AbstractConformance(Type conformingType, ProtocolDecl *requirement)
+    : conformingType(conformingType), requirement(requirement) { }
+
+  Type getConformingType() const { return conformingType; }
+  ProtocolDecl *getRequirement() const { return requirement; }
+
+  void Profile(llvm::FoldingSetNodeID &id) const {
+    Profile(id, getConformingType(), getRequirement());
+  }
+
+  /// Profile the substitution map storage, for use with LLVM's FoldingSet.
+  static void Profile(llvm::FoldingSetNodeID &id,
+                      Type conformingType,
+                      ProtocolDecl *requirement) {
+    id.AddPointer(conformingType.getPointer());
+    id.AddPointer(requirement);
+  }
+};
+
+}
+
+#endif // SWIFT_AST_ABSTRACT_CONFORMANCE_H
+