Merge pull request swiftlang#9273 from slavapestov/small-reflection-fixes

Small reflection fixes

Author: slavapestov

include/swift/Reflection/ReflectionContext.h

@@ -376,6 +376,11 @@ class ReflectionContext
     // solve the problem.
     while (!CaptureTypes.empty()) {
       const TypeRef *OrigCaptureTR = CaptureTypes[0];
+
+      // If we failed to demangle the capture type, we cannot proceed.
+      if (OrigCaptureTR == nullptr)
+        return nullptr;
+
       const TypeRef *SubstCaptureTR = nullptr;
 
       // If we have enough substitutions to make this captured value's

include/swift/Reflection/TypeRefBuilder.h

@@ -210,6 +210,7 @@ class TypeRefBuilder {
 
   const ProtocolTypeRef *createProtocolType(const std::string &mangledName,
                                             const std::string &moduleName,
+                                            const std::string &privateDiscriminator,
                                             const std::string &name) {
     return ProtocolTypeRef::create(*this, mangledName);
   }

include/swift/Remote/MetadataReader.h

@@ -172,7 +172,16 @@ class TypeDecoder {
     }
     case NodeKind::Protocol: {
       auto moduleName = Node->getChild(0)->getText();
-      auto name = Node->getChild(1)->getText();
+      auto nameNode = Node->getChild(1);
+      std::string privateDiscriminator, name;
+      if (nameNode->getKind() == NodeKind::PrivateDeclName) {
+        privateDiscriminator = nameNode->getChild(0)->getText();
+        name = nameNode->getChild(1)->getText();
+      } else if (nameNode->getKind() == NodeKind::Identifier) {
+        name = Node->getChild(1)->getText();
+      } else {
+        return BuiltType();
+      }
 
       // Consistent handling of protocols and protocol compositions
       Demangle::Demangler Dem;
@@ -184,7 +193,8 @@ class TypeDecoder {
       protocolList->addChild(typeList, Dem);
 
       auto mangledName = Demangle::mangleNode(protocolList);
-      return Builder.createProtocolType(mangledName, moduleName, name);
+      return Builder.createProtocolType(mangledName, moduleName,
+                                        privateDiscriminator, name);
     }
     case NodeKind::DependentGenericParamType: {
       auto depth = Node->getChild(0)->getIndex();

lib/RemoteAST/RemoteAST.cpp

@@ -305,12 +305,16 @@ class RemoteASTTypeBuilder {
 
   Type createProtocolType(StringRef mangledName,
                           StringRef moduleName,
-                          StringRef protocolName) {
+                          StringRef privateDiscriminator,
+                          StringRef name) {
     auto module = Ctx.getModuleByName(moduleName);
     if (!module) return Type();
 
-    Identifier name = Ctx.getIdentifier(protocolName);
-    auto decl = findNominalTypeDecl(module, name, Identifier(),
+    auto decl = findNominalTypeDecl(module,
+                                    Ctx.getIdentifier(name),
+                                    (privateDiscriminator.empty()
+                                     ? Identifier()
+                                     : Ctx.getIdentifier(privateDiscriminator)),
                                     Demangle::Node::Kind::Protocol);
     if (!decl) return Type();
 

stdlib/public/Reflection/TypeRef.cpp

@@ -255,7 +255,6 @@ struct TypeRefIsConcrete
   }
 
   bool visitFunctionTypeRef(const FunctionTypeRef *F) {
-    std::vector<TypeRef *> SubstitutedArguments;
     for (auto Argument : F->getArguments())
       if (!visit(Argument))
         return false;

test/Reflection/Inputs/Protocols.swift

@@ -19,3 +19,9 @@ public protocol P4 {
 public protocol ClassBoundP: class {
   associatedtype Inner
 }
+
+fileprivate protocol FileprivateProtocol {}
+
+public struct HasFileprivateProtocol {
+  fileprivate let x: FileprivateProtocol
+}

test/Reflection/typeref_decoding.swift

@@ -579,6 +579,14 @@
 // CHECK: TypesToReflect.ClassBoundP
 // CHECK: --------------------------
 
+// CHECK: TypesToReflect.(FileprivateProtocol in _{{[0-9A-F]+}})
+// CHECK: -------------------------------------------------------------------------
+
+// CHECK: TypesToReflect.HasFileprivateProtocol
+// CHECK: -------------------------------------
+// CHECK: x: TypesToReflect.(FileprivateProtocol in _{{[0-9A-F]+}})
+// CHECK: (protocol TypesToReflect.(FileprivateProtocol in _{{[0-9A-F]+}}))
+
 // CHECK: ASSOCIATED TYPES:
 // CHECK: =================
 // CHECK: - TypesToReflect.C1 : TypesToReflect.ClassBoundP

unittests/Reflection/TypeRef.cpp

@@ -156,10 +156,10 @@ TEST(TypeRefTest, UniqueFunctionTypeRef) {
 TEST(TypeRefTest, UniqueProtocolTypeRef) {
   TypeRefBuilder Builder;
 
-  auto P1 = Builder.createProtocolType(ABC, Module, Protocol);
-  auto P2 = Builder.createProtocolType(ABC, Module, Protocol);
-  auto P3 = Builder.createProtocolType(ABCD, Module, Shmrotocol);
-  auto P4 = Builder.createProtocolType(XYZ, Shmodule, Protocol);
+  auto P1 = Builder.createProtocolType(ABC, Module, "", Protocol);
+  auto P2 = Builder.createProtocolType(ABC, Module, "", Protocol);
+  auto P3 = Builder.createProtocolType(ABCD, Module, "", Shmrotocol);
+  auto P4 = Builder.createProtocolType(XYZ, Shmodule, "", Protocol);
 
   EXPECT_EQ(P1, P2);
   EXPECT_NE(P2, P3);
@@ -220,8 +220,8 @@ TEST(TypeRefTest, UniqueDependentMemberTypeRef) {
 
   auto N1 = Builder.createNominalType(ABC, nullptr);
   auto N2 = Builder.createNominalType(XYZ, nullptr);
-  auto P1 = Builder.createProtocolType(ABC, Module, Protocol);
-  auto P2 = Builder.createProtocolType(ABCD, Shmodule, Protocol);
+  auto P1 = Builder.createProtocolType(ABC, Module, "", Protocol);
+  auto P2 = Builder.createProtocolType(ABCD, Shmodule, "", Protocol);
 
   auto DM1 = Builder.createDependentMemberType("Index", N1, P1);
   auto DM2 = Builder.createDependentMemberType("Index", N1, P1);