ASTDemangler: Split off resolveOpaqueTypeDecl() from resolveOpaqueType()

Author: slavapestov

include/swift/AST/ASTDemangler.h

@@ -158,6 +158,8 @@ class ASTBuilder {
 
   Type createBoundGenericType(GenericTypeDecl *decl, ArrayRef<Type> args);
 
+  OpaqueTypeDecl *resolveOpaqueTypeDecl(NodePointer opaqueDescriptor);
+
   Type resolveOpaqueType(NodePointer opaqueDescriptor,
                          ArrayRef<ArrayRef<Type>> args,
                          unsigned ordinal);

lib/AST/ASTDemangler.cpp

@@ -332,24 +332,15 @@ Type ASTBuilder::createTypeAliasType(GenericTypeDecl *decl, Type parent) {
 
 static SubstitutionMap
 createSubstitutionMapFromGenericArgs(GenericSignature genericSig,
-                                     ArrayRef<Type> args,
-                                     LookupConformanceFn lookupConformance) {
+                                     ArrayRef<Type> args) {
   if (!genericSig)
     return SubstitutionMap();
 
   if (genericSig.getGenericParams().size() != args.size())
     return SubstitutionMap();
 
   return SubstitutionMap::get(
-      genericSig,
-      [&](SubstitutableType *t) -> Type {
-        auto *gp = cast<GenericTypeParamType>(t);
-        unsigned ordinal = genericSig->getGenericParamOrdinal(gp);
-        if (ordinal < args.size())
-          return args[ordinal];
-        return Type();
-      },
-      lookupConformance);
+      genericSig, args, LookUpConformanceInModule());
 }
 
 Type ASTBuilder::createBoundGenericType(GenericTypeDecl *decl,
@@ -364,8 +355,7 @@ Type ASTBuilder::createBoundGenericType(GenericTypeDecl *decl,
 
   // Build a SubstitutionMap.
   auto genericSig = nominalDecl->getGenericSignature();
-  auto subs = createSubstitutionMapFromGenericArgs(
-      genericSig, args, LookUpConformanceInModule());
+  auto subs = createSubstitutionMapFromGenericArgs(genericSig, args);
   if (!subs)
     return Type();
   auto origType = nominalDecl->getDeclaredInterfaceType();
@@ -375,48 +365,53 @@ Type ASTBuilder::createBoundGenericType(GenericTypeDecl *decl,
   return origType.subst(subs);
 }
 
-Type ASTBuilder::resolveOpaqueType(NodePointer opaqueDescriptor,
-                                   ArrayRef<ArrayRef<Type>> args,
-                                   unsigned ordinal) {
-  if (opaqueDescriptor->getKind() == Node::Kind::OpaqueReturnTypeOf) {
-    auto definingDecl = opaqueDescriptor->getChild(0);
-    auto definingGlobal = Factory.createNode(Node::Kind::Global);
-    definingGlobal->addChild(definingDecl, Factory);
-    auto mangling = mangleNode(definingGlobal, ManglingFlavor);
-    if (!mangling.isSuccess())
-      return Type();
-    auto mangledName = mangling.result();
+OpaqueTypeDecl *ASTBuilder::resolveOpaqueTypeDecl(NodePointer opaqueDescriptor) {
+  if (opaqueDescriptor->getKind() != Node::Kind::OpaqueReturnTypeOf)
+    return nullptr;
 
-    auto moduleNode = findModuleNode(definingDecl);
-    if (!moduleNode)
-      return Type();
+  auto definingDecl = opaqueDescriptor->getChild(0);
+  auto definingGlobal = Factory.createNode(Node::Kind::Global);
+  definingGlobal->addChild(definingDecl, Factory);
+  auto mangling = mangleNode(definingGlobal, ManglingFlavor);
+  if (!mangling.isSuccess())
+    return nullptr;
+  auto mangledName = mangling.result();
 
-    ModuleDecl *scratch;
-    auto potentialParentModules = findPotentialModules(moduleNode, scratch);
-    if (potentialParentModules.empty())
-      return Type();
+  auto moduleNode = findModuleNode(definingDecl);
+  if (!moduleNode)
+    return nullptr;
 
-    OpaqueTypeDecl *opaqueDecl = nullptr;
-    for (auto module : potentialParentModules)
-      if (auto decl = module->lookupOpaqueResultType(mangledName))
-        opaqueDecl = decl;
+  ModuleDecl *scratch;
+  auto potentialParentModules = findPotentialModules(moduleNode, scratch);
+  if (potentialParentModules.empty())
+    return nullptr;
 
-    if (!opaqueDecl)
-      return Type();
-    SmallVector<Type, 8> allArgs;
-    for (auto argSet : args) {
-      allArgs.append(argSet.begin(), argSet.end());
-    }
+  for (auto module : potentialParentModules)
+    if (auto decl = module->lookupOpaqueResultType(mangledName))
+      return decl;
+
+  return nullptr;
+}
+
+Type ASTBuilder::resolveOpaqueType(NodePointer opaqueDescriptor,
+                                   ArrayRef<ArrayRef<Type>> args,
+                                   unsigned ordinal) {
+  OpaqueTypeDecl *opaqueDecl = resolveOpaqueTypeDecl(opaqueDescriptor);
+  if (!opaqueDecl)
+    return Type();
 
-    SubstitutionMap subs = createSubstitutionMapFromGenericArgs(
-        opaqueDecl->getGenericSignature(), allArgs,
-        LookUpConformanceInModule());
-    Type interfaceType = opaqueDecl->getOpaqueGenericParams()[ordinal];
-    return OpaqueTypeArchetypeType::get(opaqueDecl, interfaceType, subs);
+  SmallVector<Type, 8> allArgs;
+  for (auto argSet : args) {
+    allArgs.append(argSet.begin(), argSet.end());
   }
-  
-  // TODO: named opaque types
-  return Type();
+
+  if (ordinal >= opaqueDecl->getOpaqueGenericParams().size())
+    return Type();
+
+  SubstitutionMap subs = createSubstitutionMapFromGenericArgs(
+      opaqueDecl->getGenericSignature(), allArgs);
+  Type interfaceType = opaqueDecl->getOpaqueGenericParams()[ordinal];
+  return OpaqueTypeArchetypeType::get(opaqueDecl, interfaceType, subs);
 }
 
 Type ASTBuilder::createBoundGenericType(GenericTypeDecl *decl,
@@ -1143,8 +1138,7 @@ Type ASTBuilder::createSILBoxTypeWithLayout(
   SubstitutionMap substs;
   if (signature)
     substs = createSubstitutionMapFromGenericArgs(
-        signature, replacements,
-        LookUpConformanceInModule());
+        signature, replacements);
   return SILBoxType::get(Ctx, layout, substs);
 }