Lazily populate BuiltInTypeDescriptorCache, and fix compile error

Author: bentroller

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -433,6 +433,9 @@ class TypeRefBuilder {
                      RemoteRef<BuiltinTypeDescriptor>>
       BuiltInTypeDescriptorCache;
 
+  /// The index of the last ReflectionInfo cached by BuiltInTypeDescriptorCache.
+  uint32_t NormalizedReflectionNameCacheLastReflectionInfoCache = 0;
+
   std::vector<std::unique_ptr<const GenericSignatureRef>> SignatureRefPool;
 
   TypeConverter TC;
@@ -1052,30 +1055,6 @@ class TypeRefBuilder {
     ReflectionInfos.push_back(I);
     auto InfoID = ReflectionInfos.size() - 1;
     assert(InfoID <= UINT32_MAX && "ReflectionInfo ID overflow");
-
-    for (auto BuiltinTypeDescriptor : I.Builtin) {
-      if (BuiltinTypeDescriptor->Stride <= 0)
-        continue;
-      if (!BuiltinTypeDescriptor->hasMangledTypeName())
-        continue;
-
-      auto Alignment = BuiltinTypeDescriptor->getAlignment();
-      if (Alignment <= 0)
-        continue;
-      // Reject any alignment that's not a power of two.
-      if (Alignment & (Alignment - 1))
-        continue;
-
-      const auto CandidateMangledName =
-          readTypeRef(BuiltinTypeDescriptor, BuiltinTypeDescriptor->TypeName);
-      const auto CandidateNormalizedName =
-          normalizeReflectionName(CandidateMangledName);
-      if (CandidateNormalizedName) {
-        BuiltInTypeDescriptorCache.insert(
-            std::make_pair(*CandidateNormalizedName, BuiltinTypeDescriptor));
-      }
-    }
-
     return InfoID;
   }
 

stdlib/public/RemoteInspection/TypeRefBuilder.cpp

@@ -111,13 +111,13 @@ TypeRefBuilder::normalizeReflectionName(RemoteRef<char> reflectionName) {
     case Node::Kind::OpaqueTypeDescriptorSymbolicReference:
       // Symbolic references cannot be mangled, return a failure.
       NormalizedReflectionNameCache.insert(std::make_pair(
-          reflectionNameRemoteAddress, (llvm::Optional<std::string>){}));
+          reflectionNameRemoteAddress, llvm::Optional<std::string>()));
       return {};
     default:
       auto mangling = mangleNode(node);
       if (!mangling.isSuccess()) {
         NormalizedReflectionNameCache.insert(std::make_pair(
-            reflectionNameRemoteAddress, (llvm::Optional<std::string>){}));
+            reflectionNameRemoteAddress, llvm::Optional<std::string>()));
         return {};
       }
       NormalizedReflectionNameCache.insert(
@@ -415,6 +415,35 @@ TypeRefBuilder::getBuiltinTypeInfo(const TypeRef *TR) {
   else
     return nullptr;
 
+  for (; NormalizedReflectionNameCacheLastReflectionInfoCache <
+         ReflectionInfos.size();
+       NormalizedReflectionNameCacheLastReflectionInfoCache++) {
+    for (auto BuiltinTypeDescriptor :
+         ReflectionInfos[NormalizedReflectionNameCacheLastReflectionInfoCache]
+             .Builtin) {
+      if (BuiltinTypeDescriptor->Stride <= 0)
+        continue;
+      if (!BuiltinTypeDescriptor->hasMangledTypeName())
+        continue;
+
+      auto Alignment = BuiltinTypeDescriptor->getAlignment();
+      if (Alignment <= 0)
+        continue;
+      // Reject any alignment that's not a power of two.
+      if (Alignment & (Alignment - 1))
+        continue;
+
+      auto CandidateMangledName =
+          readTypeRef(BuiltinTypeDescriptor, BuiltinTypeDescriptor->TypeName);
+      auto CandidateNormalizedName =
+          normalizeReflectionName(CandidateMangledName);
+      if (CandidateNormalizedName) {
+        BuiltInTypeDescriptorCache.insert(
+            std::make_pair(*CandidateNormalizedName, BuiltinTypeDescriptor));
+      }
+    }
+  }
+
   if (const auto found = BuiltInTypeDescriptorCache.find(MangledName);
       found != BuiltInTypeDescriptorCache.end()) {
     return found->second;