[Metadata reader] Form demangle trees for generic extension contexts.

DougGregor · DougGregor · commit 23886ba579e0 · 2019-01-26T23:25:51.000-08:00
Translate the metadata for the generic requirements of an extension context
into a demangle tree that is associated with the demangling of an extension.

Teach the ASTDemangler how to handle class layout constraints as well.

With this, RemoteAST can resolve types nested within most constrained
extensions.
diff --git a/include/swift/ABI/Metadata.h b/include/swift/ABI/Metadata.h
@@ -1547,10 +1547,10 @@ class TargetProtocolDescriptorRef {
   /// is clear).
   StoredPointer storage;
 
+public:
   constexpr TargetProtocolDescriptorRef(StoredPointer storage)
     : storage(storage) { }
 
-public:
   constexpr TargetProtocolDescriptorRef() : storage() { }
 
   TargetProtocolDescriptorRef(
@@ -2519,7 +2519,6 @@ class TargetGenericRequirementDescriptor {
   /// The type that's constrained, described as a mangled name.
   RelativeDirectPointer<const char, /*nullable*/ false> Param;
 
-private:
   union {
     /// A mangled representation of the same-type or base class the param is
     /// constrained to.
@@ -2544,7 +2543,6 @@ class TargetGenericRequirementDescriptor {
     GenericRequirementLayoutKind Layout;
   };
 
-public:
   constexpr GenericRequirementFlags getFlags() const {
     return Flags;
   }
diff --git a/include/swift/Remote/MetadataReader.h b/include/swift/Remote/MetadataReader.h
@@ -1655,6 +1655,48 @@ class MetadataReader {
     return nameChild;
   }
 
+  /// Resolve a relative target protocol descriptor pointer, which uses
+  /// the lowest bit to indicate an indirect vs. direct relative reference and
+  /// the second lowest bit to indicate whether it is an Objective-C protocol.
+  StoredPointer resolveRelativeIndirectProtocol(
+      ContextDescriptorRef descriptor,
+      const RelativeTargetProtocolDescriptorPointer<Runtime> &protocol) {
+    // Map the offset from within our local buffer to the remote address.
+    auto distance = (intptr_t)&protocol - (intptr_t)descriptor.getLocalBuffer();
+    StoredPointer targetAddress(descriptor.getAddress() + distance);
+
+    // Read the relative offset.
+    int32_t relative;
+    if (!Reader->readInteger(RemoteAddress(targetAddress), &relative))
+      return StoredPointer();
+
+    // Collect and mask off the 'indirect' and 'isObjC' bits.
+    bool indirect = relative & 1;
+    relative &= ~1u;
+    bool isObjC = relative & 2;
+    relative &= ~2u;
+
+    using SignedPointer = typename std::make_signed<StoredPointer>::type;
+    auto signext = (SignedPointer)(int32_t)relative;
+
+    StoredPointer resultAddress = targetAddress + signext;
+
+    // Low bit set in the offset indicates that the offset leads to the absolute
+    // address in memory.
+    if (indirect) {
+      if (!Reader->readBytes(RemoteAddress(resultAddress),
+                             (uint8_t *)&resultAddress,
+                             sizeof(StoredPointer)))
+        return StoredPointer();
+    }
+
+    // Add back the Objective-C bit.
+    if (isObjC)
+      resultAddress |= 0x1;
+
+    return resultAddress;
+  }
+
   Demangle::NodePointer
   buildContextDescriptorMangling(ContextDescriptorRef descriptor,
                                  Demangler &dem) {
@@ -1748,14 +1790,141 @@ class MetadataReader {
                         MangledNameKind::Type,
                         dem);
 
-      // FIXME: If there are generic requirements, turn them into a demangle
-      // tree.
       auto demangling = dem.createNode(Node::Kind::Extension);
       demangling->addChild(parentDemangling, dem);
       demangling->addChild(demangledExtendedContext, dem);
-      return demangling;
 
-      return nullptr;
+      /// Resolver to turn a protocol reference into a demangling.
+      struct ProtocolResolver {
+        using Result = Demangle::Node *;
+
+        Demangler &dem;
+
+        Result failure() const {
+          return nullptr;
+        }
+
+        Result swiftProtocol(Demangle::Node *node) {
+          return node;
+        }
+
+#if SWIFT_OBJC_INTEROP
+        Result objcProtocol(StringRef name) {
+          // FIXME: Unify this with the runtime's Demangle.cpp
+          auto module = dem.createNode(Node::Kind::Module,
+                                       MANGLING_MODULE_OBJC);
+          auto node = dem.createNode(Node::Kind::Protocol);
+          node->addChild(module, dem);
+          node->addChild(dem.createNode(Node::Kind::Identifier, name),
+                         dem);
+          return node;
+        }
+#endif
+      } protocolResolver{dem};
+
+      // If there are generic requirements, form the generic signature.
+      auto requirements = extensionBuffer->getGenericRequirements();
+      if (!requirements.empty()) {
+        auto signatureNode =
+          dem.createNode(Node::Kind::DependentGenericSignature);
+        bool failed = false;
+        for (const auto &req : requirements) {
+          if (failed)
+            break;
+
+          // Demangle the subject.
+          auto subjectAddress = resolveRelativeField(descriptor, req.Param);
+          NodePointer subject = readMangledName(RemoteAddress(subjectAddress),
+                                                MangledNameKind::Type,
+                                                dem);
+          if (!subject) {
+            failed = true;
+            break;
+          }
+
+          switch (req.Flags.getKind()) {
+          case GenericRequirementKind::Protocol: {
+            auto protocolAddress =
+              resolveRelativeIndirectProtocol(descriptor, req.Protocol);
+            auto protocol = readProtocol(protocolAddress, dem,
+                                         protocolResolver);
+            if (!protocol) {
+              failed = true;
+              break;
+            }
+
+            auto reqNode =
+              dem.createNode(
+                Node::Kind::DependentGenericConformanceRequirement);
+            reqNode->addChild(subject, dem);
+            reqNode->addChild(protocol, dem);
+            signatureNode->addChild(reqNode, dem);
+            break;
+          }
+
+          case GenericRequirementKind::SameType:
+          case GenericRequirementKind::BaseClass: {
+            // Demangle the right-hand type.
+            auto typeAddress = resolveRelativeField(descriptor, req.Type);
+            NodePointer type = readMangledName(RemoteAddress(typeAddress),
+                                               MangledNameKind::Type,
+                                               dem);
+            if (!type) {
+              failed = true;
+              break;
+            }
+
+            Node::Kind nodeKind;
+            if (req.Flags.getKind() == GenericRequirementKind::SameType)
+              nodeKind = Node::Kind::DependentGenericSameTypeRequirement;
+            else
+              nodeKind = Node::Kind::DependentGenericConformanceRequirement;
+
+            auto reqNode = dem.createNode(nodeKind);
+            reqNode->addChild(subject, dem);
+            reqNode->addChild(type, dem);
+            signatureNode->addChild(reqNode, dem);
+            break;
+          }
+
+          case GenericRequirementKind::SameConformance:
+            // Do nothing
+            break;
+
+          case GenericRequirementKind::Layout: {
+            // Map the offset from within our local buffer to the remote
+            // address.
+            auto distance =
+              (intptr_t)&req.Layout - (intptr_t)descriptor.getLocalBuffer();
+            StoredPointer targetAddress(descriptor.getAddress() + distance);
+
+            GenericRequirementLayoutKind kind;
+            if (!Reader->readBytes(RemoteAddress(targetAddress),
+                                   (uint8_t *)&kind, sizeof(kind))) {
+              failed = true;
+              break;
+            }
+
+            if (kind == GenericRequirementLayoutKind::Class) {
+              auto reqNode =
+                dem.createNode(Node::Kind::DependentGenericLayoutRequirement);
+              reqNode->addChild(subject, dem);
+              auto idNode = dem.createNode(Node::Kind::Identifier, "C");
+              reqNode->addChild(idNode, dem);
+              signatureNode->addChild(reqNode, dem);
+            } else {
+              failed = true;
+            }
+            break;
+          }
+          }
+        }
+
+        if (!failed) {
+          demangling->addChild(signatureNode, dem);
+        }
+      }
+      return demangling;
     }
 
     case ContextDescriptorKind::Anonymous: {
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -531,11 +531,20 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(
       return CanGenericSignature();
     auto subjectType = swift::Demangle::decodeMangledType(
         *this, child->getChild(0));
-    auto constraintType = swift::Demangle::decodeMangledType(
-        *this, child->getChild(1));
-    if (!subjectType || !constraintType)
+    if (!subjectType)
       return CanGenericSignature();
 
+    Type constraintType;
+    if (child->getKind() ==
+          Demangle::Node::Kind::DependentGenericConformanceRequirement ||
+        child->getKind() ==
+          Demangle::Node::Kind::DependentGenericSameTypeRequirement) {
+      constraintType = swift::Demangle::decodeMangledType(
+        *this, child->getChild(1));
+      if (!constraintType)
+        return CanGenericSignature();
+    }
+
     auto source =
       GenericSignatureBuilder::FloatingRequirementSource::forAbstract();
 
@@ -556,6 +565,24 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(
           source, nullptr);
       break;
     }
+    case Demangle::Node::Kind::DependentGenericLayoutRequirement: {
+      // FIXME: Other layout constraints
+      LayoutConstraint constraint;
+      auto kindChild = child->getChild(1);
+      if (kindChild->getKind() != Demangle::Node::Kind::Identifier)
+        return CanGenericSignature();
+
+      if (kindChild->getText() == "C") {
+        auto kind = LayoutConstraintKind::Class;
+        auto layout = LayoutConstraint::getLayoutConstraint(kind, Ctx);
+        builder.addRequirement(
+            Requirement(RequirementKind::Layout, subjectType, layout),
+            source, nullptr);
+        break;
+      }
+
+      return CanGenericSignature();
+    }
     default:
       return CanGenericSignature();
     }
@@ -570,6 +597,11 @@ ASTBuilder::findDeclContext(const Demangle::NodePointer &node) {
   switch (node->getKind()) {
   case Demangle::Node::Kind::DeclContext:
   case Demangle::Node::Kind::Type:
+  case Demangle::Node::Kind::BoundGenericClass:
+  case Demangle::Node::Kind::BoundGenericEnum:
+  case Demangle::Node::Kind::BoundGenericProtocol:
+  case Demangle::Node::Kind::BoundGenericStructure:
+  case Demangle::Node::Kind::BoundGenericTypeAlias:
     return findDeclContext(node->getFirstChild());
 
   case Demangle::Node::Kind::Module:
diff --git a/test/RemoteAST/extensions.swift b/test/RemoteAST/extensions.swift
@@ -18,3 +18,61 @@ extension Int.Inner {
 
 // CHECK: Int.Inner.MoreInner
 printType(Int.Inner.MoreInner.self)
+
+protocol P {
+  associatedtype Assoc
+}
+
+struct A<T: P, U: P> { }
+
+extension Int: P {
+  typealias Assoc = Double
+}
+
+extension String: P {
+  typealias Assoc = Double
+}
+
+extension A where T.Assoc == U.Assoc {
+  struct ViaSameType { }
+}
+
+// CHECK: A<Int, String>.ViaSameType
+printType(A<Int, String>.ViaSameType.self)
+
+protocol Q { }
+extension Int: Q { }
+
+extension A where T: Q {
+  struct ViaProtocolConformance { }
+}
+
+// CHECK: A<Int, String>.ViaProtocolConformance
+printType(A<Int, String>.ViaProtocolConformance.self)
+
+class B { }
+
+class C: B { }
+
+extension B: P {
+  typealias Assoc = Int
+}
+
+extension A where U: B {
+  struct ViaBaseClass { }
+}
+
+// CHECK: A<Int, B>.ViaBaseClass
+printType(A<Int, B>.ViaBaseClass.self)
+
+// CHECK: A<Int, C>.ViaBaseClass
+printType(A<Int, C>.ViaBaseClass.self)
+
+extension A where T: AnyObject {
+  struct ViaAnyObject {
+    func wobble() {}
+  }
+}
+
+// CHECK: A<C, Int>.ViaAnyObject
+printType(A<C, Int>.ViaAnyObject.self)
