added special tag to parameter list to make sure not to break existing TryLookup impls, added test to verify this.

Author: antmor

cppwinrt/code_writers.h

@@ -1877,7 +1877,7 @@ namespace cppwinrt
     {
         auto name = method_signature.return_param_name();
 
-        w.write("auto out_param_val = %(%);",
+        w.write("auto out_param_val = %(%, trylookup_from_abi);",
             upcall,
             bind<write_produce_args>(method_signature));
         w.write(R"(
@@ -1942,7 +1942,7 @@ namespace cppwinrt
             format = R"(        int32_t __stdcall %(%) noexcept final try
         {
 %            typename D::abi_guard guard(this->shim());
-            if constexpr (has_try_lookup_v<D, K>)
+            if constexpr (has_TryLookup_v<D, K>)
             {
                 %
             }

strings/base_collections_base.h

@@ -507,7 +507,7 @@ WINRT_EXPORT namespace winrt
     struct map_view_base : iterable_base<D, Windows::Foundation::Collections::IKeyValuePair<K, V>, Version>
     {
         // specialization of Lookup that avoids throwing the hresult
-        std::optional<V> TryLookup(K const& key) const
+        std::optional<V> TryLookup(K const& key, trylookup_from_abi_t) const
         {
             [[maybe_unused]] auto guard = static_cast<D const&>(*this).acquire_shared();
             auto pair = static_cast<D const&>(*this).get_container().find(static_cast<D const&>(*this).wrap_value(key));

strings/base_meta.h

@@ -10,6 +10,10 @@ WINRT_EXPORT namespace winrt
     struct take_ownership_from_abi_t {};
     inline constexpr take_ownership_from_abi_t take_ownership_from_abi{};
 
+    // Map implementations can implement TryLookup with trylookup_from_abi_t as an optimization
+    struct trylookup_from_abi_t {};
+    inline constexpr trylookup_from_abi_t trylookup_from_abi{};
+
     template <typename T>
     struct com_ptr;
 
@@ -300,9 +304,9 @@ namespace winrt::impl
     };
 
     template <typename D, typename K>
-    struct has_try_lookup
+    struct has_TryLookup
     {
-        template <typename U, typename = decltype(std::declval<U>().TryLookup(std::declval<K>()))> static constexpr bool get_value(int) { return true; }
+        template <typename U, typename = decltype(std::declval<U>().TryLookup(std::declval<K>(), trylookup_from_abi))> static constexpr bool get_value(int) { return true; }
         template <typename> static constexpr bool get_value(...) { return false; }
 
     public:
@@ -311,5 +315,5 @@ namespace winrt::impl
     };
 
     template <typename D, typename K>
-    inline constexpr bool has_try_lookup_v = has_try_lookup<D, K>::value;
+    inline constexpr bool has_TryLookup_v = has_TryLookup<D, K>::value;
 }

test/old_tests/UnitTests/TryLookup.cpp

@@ -143,4 +143,50 @@ TEST_CASE("TryLookup TryRemove error")
     REQUIRE(!map.TryLookup(123));
     REQUIRE(!map.TryRemove(123));
 
-}
+}
+
+TEST_CASE("trylookup_from_abi specialization")
+{
+    // A map that throws a specific error, used to verify various edge cases.
+    // and implements tryLookup, to take advantage of an optimization to avoid a throw. 
+    struct map_with_try_lookup : implements<map_with_try_lookup, IMapView<int, int>>
+    {
+        hresult codeToThrow{ S_OK };
+        bool shouldThrowOnTryLookup{ false };
+        std::optional<int> TryLookup(int, trylookup_from_abi_t)
+        {
+            if (shouldThrowOnTryLookup)
+            { 
+                throw_hresult(codeToThrow); 
+            }
+            else
+            {
+                return { std::nullopt };
+            }
+        }
+        int Lookup(int) { throw_hresult(E_UNEXPECTED); } // shouldn't be called by the test
+        int32_t Size() { throw_hresult(E_UNEXPECTED); } // shouldn't be called by the test
+        bool HasKey(int) { throw_hresult(E_UNEXPECTED); } // shouldn't be called by the test
+        void Split(IMapView<int, int>&, IMapView<int, int>&) { throw_hresult(E_UNEXPECTED); } // shouldn't be called by the test
+    };
+
+    auto self = make_self<map_with_try_lookup>();
+    IMapView<int, int> map = *self;
+
+    // Make sure that we use the TryLookup specialization, and don't throw an unexpected exception.
+    self->shouldThrowOnTryLookup = false;
+    REQUIRE(!map.TryLookup(123));
+    // make sure regular lookup stll throws bounds
+    REQUIRE_THROWS_AS(map.Lookup(123), hresult_out_of_bounds);
+    
+    // Simulate a non-agile map that is being accessed from the wrong thread.
+    // "Try" operations should throw rather than erroneously report "not found".
+    // Because they didn't even try. The operation never got off the ground.
+    self->shouldThrowOnTryLookup = true;
+    self->codeToThrow = RPC_E_WRONG_THREAD;
+    REQUIRE_THROWS_AS(map.TryLookup(123), hresult_wrong_thread);
+    // regular lookup should throw the same error
+    REQUIRE_THROWS_AS(map.Lookup(123), hresult_wrong_thread);
+
+
+}