--- a/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp	Sat Feb 17 09:57:20 2018 +0900
+++ b/unittests/ExecutionEngine/Orc/LegacyAPIInteropTest.cpp	Wed Aug 14 16:55:33 2019 +0900
@@ -1,9 +1,8 @@
 //===----------- CoreAPIsTest.cpp - Unit tests for Core ORC APIs ----------===//
 //
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
@@ -14,70 +13,66 @@
 using namespace llvm;
 using namespace llvm::orc;
 
+class LegacyAPIsStandardTest : public CoreAPIsBasedStandardTest {};
+
 namespace {
 
-TEST(LegacyAPIInteropTest, QueryAgainstVSO) {
+TEST_F(LegacyAPIsStandardTest, TestLambdaSymbolResolver) {
+  BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
 
-  SymbolStringPool SP;
-  ExecutionSession ES(SP);
-  auto Foo = SP.intern("foo");
+  cantFail(JD.define(absoluteSymbols({{Foo, FooSym}, {Bar, BarSym}})));
 
-  VSO V;
-  SymbolMap Defs;
-  JITEvaluatedSymbol FooSym(0xdeadbeef, JITSymbolFlags::Exported);
-  Defs[Foo] = FooSym;
-  cantFail(V.define(std::move(Defs)));
+  auto Resolver = createSymbolResolver(
+      [&](const SymbolNameSet &Symbols) {
+        auto FlagsMap = cantFail(JD.lookupFlags(Symbols));
+        SymbolNameSet Result;
+        for (auto &KV : FlagsMap)
+          if (!KV.second.isStrong())
+            Result.insert(KV.first);
+        return Result;
+      },
+      [&](std::shared_ptr<AsynchronousSymbolQuery> Q, SymbolNameSet Symbols) {
+        return cantFail(JD.legacyLookup(std::move(Q), Symbols));
+      });
 
-  auto LookupFlags = [&](SymbolFlagsMap &SymbolFlags,
-                         const SymbolNameSet &Names) {
-    return V.lookupFlags(SymbolFlags, Names);
-  };
+  auto RS = Resolver->getResponsibilitySet(SymbolNameSet({Bar, Baz}));
+
+  EXPECT_EQ(RS.size(), 1U)
+      << "getResponsibilitySet returned the wrong number of results";
+  EXPECT_EQ(RS.count(Bar), 1U)
+      << "getResponsibilitySet result incorrect. Should be {'bar'}";
+
+  bool OnCompletionRun = false;
 
-  auto Lookup = [&](std::shared_ptr<AsynchronousSymbolQuery> Query,
-                    SymbolNameSet Symbols) {
-    auto R = V.lookup(std::move(Query), Symbols);
-    EXPECT_TRUE(R.MaterializationWork.empty())
-        << "Query resulted in unexpected materialization work";
-    return std::move(R.UnresolvedSymbols);
+  auto OnCompletion = [&](Expected<SymbolMap> Result) {
+    OnCompletionRun = true;
+    EXPECT_TRUE(!!Result) << "Unexpected error";
+    EXPECT_EQ(Result->size(), 2U) << "Unexpected number of resolved symbols";
+    EXPECT_EQ(Result->count(Foo), 1U) << "Missing lookup result for foo";
+    EXPECT_EQ(Result->count(Bar), 1U) << "Missing lookup result for bar";
+    EXPECT_EQ((*Result)[Foo].getAddress(), FooSym.getAddress())
+        << "Incorrect address for foo";
+    EXPECT_EQ((*Result)[Bar].getAddress(), BarSym.getAddress())
+        << "Incorrect address for bar";
   };
 
-  auto UnderlyingResolver =
-      createSymbolResolver(std::move(LookupFlags), std::move(Lookup));
-  JITSymbolResolverAdapter Resolver(ES, *UnderlyingResolver);
-
-  JITSymbolResolver::LookupSet Names{StringRef("foo")};
+  auto Q = std::make_shared<AsynchronousSymbolQuery>(
+      SymbolNameSet({Foo, Bar}), SymbolState::Resolved, OnCompletion);
+  auto Unresolved =
+      Resolver->lookup(std::move(Q), SymbolNameSet({Foo, Bar, Baz}));
 
-  auto LFR = Resolver.lookupFlags(Names);
-  EXPECT_TRUE(!!LFR) << "lookupFlags failed";
-  EXPECT_EQ(LFR->size(), 1U)
-      << "lookupFlags returned the wrong number of results";
-  EXPECT_EQ(LFR->count(*Foo), 1U)
-      << "lookupFlags did not contain a result for 'foo'";
-  EXPECT_EQ((*LFR)[*Foo], FooSym.getFlags())
-      << "lookupFlags contained the wrong result for 'foo'";
-
-  auto LR = Resolver.lookup(Names);
-  EXPECT_TRUE(!!LR) << "lookup failed";
-  EXPECT_EQ(LR->size(), 1U) << "lookup returned the wrong number of results";
-  EXPECT_EQ(LR->count(*Foo), 1U) << "lookup did not contain a result for 'foo'";
-  EXPECT_EQ((*LR)[*Foo].getFlags(), FooSym.getFlags())
-      << "lookup returned the wrong result for flags of 'foo'";
-  EXPECT_EQ((*LR)[*Foo].getAddress(), FooSym.getAddress())
-      << "lookup returned the wrong result for address of 'foo'";
+  EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
+  EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to not be resolved";
+  EXPECT_TRUE(OnCompletionRun) << "OnCompletion was never run";
 }
 
-TEST(LegacyAPIInteropTset, LegacyLookupHelpersFn) {
-  constexpr JITTargetAddress FooAddr = 0xdeadbeef;
-  JITSymbolFlags FooFlags = JITSymbolFlags::Exported;
-
+TEST_F(LegacyAPIsStandardTest, LegacyLookupHelpersFn) {
   bool BarMaterialized = false;
-  constexpr JITTargetAddress BarAddr = 0xcafef00d;
-  JITSymbolFlags BarFlags = static_cast<JITSymbolFlags::FlagNames>(
-      JITSymbolFlags::Exported | JITSymbolFlags::Weak);
+  BarSym.setFlags(BarSym.getFlags() | JITSymbolFlags::Weak);
 
   auto LegacyLookup = [&](const std::string &Name) -> JITSymbol {
     if (Name == "foo")
-      return {FooAddr, FooFlags};
+      return FooSym;
 
     if (Name == "bar") {
       auto BarMaterializer = [&]() -> Expected<JITTargetAddress> {
@@ -85,58 +80,42 @@
         return BarAddr;
       };
 
-      return {BarMaterializer, BarFlags};
+      return {BarMaterializer, BarSym.getFlags()};
     }
 
     return nullptr;
   };
 
-  SymbolStringPool SP;
-  auto Foo = SP.intern("foo");
-  auto Bar = SP.intern("bar");
-  auto Baz = SP.intern("baz");
-
-  SymbolNameSet Symbols({Foo, Bar, Baz});
+  auto RS =
+      getResponsibilitySetWithLegacyFn(SymbolNameSet({Bar, Baz}), LegacyLookup);
 
-  SymbolFlagsMap SymbolFlags;
-  auto SymbolsNotFound =
-      lookupFlagsWithLegacyFn(SymbolFlags, Symbols, LegacyLookup);
-
-  EXPECT_TRUE(!!SymbolsNotFound) << "lookupFlagsWithLegacy failed unexpectedly";
-  EXPECT_EQ(SymbolFlags.size(), 2U) << "Wrong number of flags returned";
-  EXPECT_EQ(SymbolFlags.count(Foo), 1U) << "Flags for foo missing";
-  EXPECT_EQ(SymbolFlags.count(Bar), 1U) << "Flags for foo missing";
-  EXPECT_EQ(SymbolFlags[Foo], FooFlags) << "Wrong flags for foo";
-  EXPECT_EQ(SymbolFlags[Bar], BarFlags) << "Wrong flags for foo";
-  EXPECT_EQ(SymbolsNotFound->size(), 1U) << "Expected one symbol not found";
-  EXPECT_EQ(SymbolsNotFound->count(Baz), 1U)
-      << "Expected symbol baz to be not found";
+  EXPECT_TRUE(!!RS) << "Expected getResponsibilitySetWithLegacyFn to succeed";
+  EXPECT_EQ(RS->size(), 1U) << "Wrong number of symbols returned";
+  EXPECT_EQ(RS->count(Bar), 1U) << "Incorrect responsibility set returned";
   EXPECT_FALSE(BarMaterialized)
       << "lookupFlags should not have materialized bar";
 
-  bool OnResolvedRun = false;
-  bool OnReadyRun = false;
-  auto OnResolved = [&](Expected<SymbolMap> Result) {
-    OnResolvedRun = true;
+  bool OnCompletionRun = false;
+  auto OnCompletion = [&](Expected<SymbolMap> Result) {
+    OnCompletionRun = true;
     EXPECT_TRUE(!!Result) << "lookuWithLegacy failed to resolve";
+
     EXPECT_EQ(Result->size(), 2U) << "Wrong number of symbols resolved";
     EXPECT_EQ(Result->count(Foo), 1U) << "Result for foo missing";
     EXPECT_EQ(Result->count(Bar), 1U) << "Result for bar missing";
     EXPECT_EQ((*Result)[Foo].getAddress(), FooAddr) << "Wrong address for foo";
-    EXPECT_EQ((*Result)[Foo].getFlags(), FooFlags) << "Wrong flags for foo";
+    EXPECT_EQ((*Result)[Foo].getFlags(), FooSym.getFlags())
+        << "Wrong flags for foo";
     EXPECT_EQ((*Result)[Bar].getAddress(), BarAddr) << "Wrong address for bar";
-    EXPECT_EQ((*Result)[Bar].getFlags(), BarFlags) << "Wrong flags for bar";
-  };
-  auto OnReady = [&](Error Err) {
-    EXPECT_FALSE(!!Err) << "Finalization unexpectedly failed";
-    OnReadyRun = true;
+    EXPECT_EQ((*Result)[Bar].getFlags(), BarSym.getFlags())
+        << "Wrong flags for bar";
   };
 
-  AsynchronousSymbolQuery Q({Foo, Bar}, OnResolved, OnReady);
-  auto Unresolved = lookupWithLegacyFn(Q, Symbols, LegacyLookup);
+  AsynchronousSymbolQuery Q({Foo, Bar}, SymbolState::Resolved, OnCompletion);
+  auto Unresolved =
+      lookupWithLegacyFn(ES, Q, SymbolNameSet({Foo, Bar, Baz}), LegacyLookup);
 
-  EXPECT_TRUE(OnResolvedRun) << "OnResolved was not run";
-  EXPECT_TRUE(OnReadyRun) << "OnReady was not run";
+  EXPECT_TRUE(OnCompletionRun) << "OnCompletion was not run";
   EXPECT_EQ(Unresolved.size(), 1U) << "Expected one unresolved symbol";
   EXPECT_EQ(Unresolved.count(Baz), 1U) << "Expected baz to be unresolved";
 }