Reflection: Eliminate NominalTypeTrait::setParent()

When creating a TypeRef from metadata, we have a parent pointer
handy, and construct the TypeRef directly, so there's no need
to mutate the TypeRef after the fact.

When demangling a TypeRef from a string, the mangling encodes
the parent module or type context, so we can set it when
constructing the TypeRef there too.

Author: slavapestov

include/swift/Reflection/ReflectionContext.h

@@ -116,13 +116,15 @@ class ReflectionContext {
       return BuiltinTypeRef::create(*this, mangledName);
     }
 
-    NominalTypeRef *createNominalType(const std::string &mangledName) {
-      return NominalTypeRef::create(*this, mangledName);
+    NominalTypeRef *createNominalType(const std::string &mangledName,
+                                      TypeRef *parent) {
+      return NominalTypeRef::create(*this, mangledName, parent);
     }
 
     BoundGenericTypeRef *createBoundGenericType(const std::string &mangledName,
-                                          const std::vector<TypeRef *> &args) {
-      return BoundGenericTypeRef::create(*this, mangledName, args);
+                                          const std::vector<TypeRef *> &args,
+                                          TypeRef *parent) {
+      return BoundGenericTypeRef::create(*this, mangledName, args, parent);
     }
 
     TupleTypeRef *createTupleType(const std::vector<TypeRef *> &elements,
@@ -270,6 +272,28 @@ class ReflectionContext {
     return *Reader;
   }
 
+  std::pair<std::string, Type>
+  decodeNominalType(const Demangle::NodePointer &Node) {
+    using NodeKind = Demangle::Node::Kind;
+    if (Node->getKind() == NodeKind::Type)
+      return decodeNominalType(Node->getChild(0));
+
+    assert(Node->getNumChildren() == 2);
+    auto moduleOrParentType = Node->getChild(0);
+
+    // Nested types are handled a bit funny here because a
+    // nominal typeref always stores its full mangled name,
+    // in addition to a reference to the parent type. The
+    // mangled name already includes the module and parent
+    // types, if any.
+    TypeRef *parent = nullptr;
+    if (moduleOrParentType->getKind() != NodeKind::Module)
+      parent = decodeMangledType(moduleOrParentType);
+
+    auto mangledName = Demangle::mangleNode(Node);
+    return std::make_pair(mangledName, parent);
+  }
+
   Type decodeMangledType(const Demangle::NodePointer &Node) {
     using NodeKind = Demangle::Node::Kind;
     switch (Node->getKind()) {
@@ -279,26 +303,38 @@ class ReflectionContext {
         return decodeMangledType(Node->getChild(0));
       case NodeKind::Type:
         return decodeMangledType(Node->getChild(0));
+      case NodeKind::Class:
+      case NodeKind::Enum:
+      case NodeKind::Structure: {
+        std::string mangledName;
+        Type parent;
+
+        std::tie(mangledName, parent) = decodeNominalType(Node);
+        return Builder.createNominalType(mangledName, parent);
+      }
       case NodeKind::BoundGenericClass:
       case NodeKind::BoundGenericEnum:
       case NodeKind::BoundGenericStructure: {
-        auto mangledName = Demangle::mangleNode(Node->getChild(0));
+        assert(Node->getNumChildren() == 2);
+
+        std::string mangledName;
+        Type parent;
+
+        std::tie(mangledName, parent) = decodeNominalType(Node->getChild(0));
+
+        std::vector<Type> args;
+
         auto genericArgs = Node->getChild(1);
-        std::vector<TypeRef *> args;
+        assert(genericArgs->getKind() == NodeKind::TypeList);
+
         for (auto genericArg : *genericArgs) {
-          auto paramTypeRef = decodeMangledType(genericArg);
-          if (!paramTypeRef)
+          auto paramType = decodeMangledType(genericArg);
+          if (!paramType)
             return Type();
-          args.push_back(paramTypeRef);
+          args.push_back(paramType);
         }
 
-        return Builder.createBoundGenericType(mangledName, args);
-      }
-      case NodeKind::Class:
-      case NodeKind::Enum:
-      case NodeKind::Structure: {
-        auto mangledName = Demangle::mangleNode(Node);
-        return Builder.createNominalType(mangledName);
+        return Builder.createBoundGenericType(mangledName, args, parent);
       }
       case NodeKind::BuiltinTypeName: {
         auto mangledName = Demangle::mangleNode(Node);
@@ -724,14 +760,9 @@ class ReflectionContext {
     Type Nominal;
     if (Descriptor->GenericParams.NumPrimaryParams) {
       auto Args = getGenericSubst(MetadataAddress);
-      auto BG = Builder.createBoundGenericType(MangledName, Args);
-      BG->setParent(Parent);
-      Nominal = BG;
+      Nominal = Builder.createBoundGenericType(MangledName, Args, Parent);
     } else {
-      auto TR = decodeMangledType(DemangleNode);
-      auto N = cast<NominalTypeRef>(TR);
-      N->setParent(Parent);
-      Nominal = TR;
+      Nominal = decodeMangledType(DemangleNode);
     }
     TypeCache.insert({MetadataAddress, Nominal});
     return Nominal;

include/swift/Reflection/TypeRef.h

@@ -117,10 +117,6 @@ class NominalTypeTrait {
     return Parent;
   }
 
-  void setParent(TypeRef *P) {
-    Parent = P;
-  }
-
   unsigned getDepth() const;
 };
 

test/Reflection/Inputs/ConcreteTypes.swift

@@ -37,6 +37,10 @@ public struct S {
   public let aTuple: (C, Box<S>, Box<E>, Int)
   public let aMetatype: C.Type
   public let aFunction: (C, S, E, Int) -> (Int)
+
+  public struct NestedS {
+    public let aField: Int
+  }
 }
 
 public enum E {
@@ -47,6 +51,7 @@ public enum E {
   case Tuple(C, S, Int)
   indirect case IndirectTuple(C, S, E, Int)
   case Metatype(E.Type)
+  case NestedStruct(S.NestedS)
 }
 
 public struct References {

test/Reflection/typeref_decoding.result.txt

@@ -48,6 +48,11 @@ aFunctionWithVarArgs: (TypesToReflect.C, Swift.Array<TypesToReflect.S>...) -> ()
     (struct TypesToReflect.S))
   (tuple))
 
+TypesToReflect.S.NestedS
+------------------------
+aField: Swift.Int
+(struct Swift.Int)
+
 TypesToReflect.S
 ----------------
 aClass: TypesToReflect.C
@@ -151,6 +156,15 @@ Metatype: (TypesToReflect.E.Type) -> (TypesToReflect.E.Type) -> TypesToReflect.E
       (enum TypesToReflect.E))
     (enum TypesToReflect.E)))
 
+NestedStruct: (TypesToReflect.E.Type) -> (TypesToReflect.S.NestedS) -> TypesToReflect.E
+(function
+  (metatype
+    (enum TypesToReflect.E))
+  (function
+    (struct TypesToReflect.S.NestedS
+      (struct TypesToReflect.S))
+    (enum TypesToReflect.E)))
+
 TypesToReflect.References
 -------------------------
 strongRef: TypesToReflect.C

test/Reflection/typeref_decoding_objc.result.txt

@@ -48,6 +48,11 @@ aFunctionWithVarArgs: (TypesToReflect.C, Swift.Array<TypesToReflect.S>...) -> ()
     (struct TypesToReflect.S))
   (tuple))
 
+TypesToReflect.S.NestedS
+------------------------
+aField: Swift.Int
+(struct Swift.Int)
+
 TypesToReflect.S
 ----------------
 aClass: TypesToReflect.C
@@ -151,6 +156,15 @@ Metatype: (TypesToReflect.E.Type) -> (TypesToReflect.E.Type) -> TypesToReflect.E
       (enum TypesToReflect.E))
     (enum TypesToReflect.E)))
 
+NestedStruct: (TypesToReflect.E.Type) -> (TypesToReflect.S.NestedS) -> TypesToReflect.E
+(function
+  (metatype
+    (enum TypesToReflect.E))
+  (function
+    (struct TypesToReflect.S.NestedS
+      (struct TypesToReflect.S))
+    (enum TypesToReflect.E)))
+
 TypesToReflect.References
 -------------------------
 strongRef: TypesToReflect.C