Fix issue with properties implemented across multiple static interfaces

src/Tests/TestComponentCSharp/TestComponentCSharp.idl

@@ -505,11 +505,13 @@ namespace TestComponentCSharp
  static void Method();
  static Int32 Property;
  static event Windows.Foundation.EventHandler<Int32> Event;
+ static Int32 ReadWriteProperty{ get; };
  [contract(Windows.Foundation.UniversalApiContract, 10)]
  {
  static void WarningMethod();
  static Int32 WarningProperty;
  static event Windows.Foundation.EventHandler<Int32> WarningEvent;
+ static Int32 ReadWriteProperty{ set; };
  }
  }
 

src/Tests/TestComponentCSharp/WarningStatic.cpp

@@ -38,4 +38,11 @@ namespace winrt::TestComponentCSharp::implementation
  void WarningStatic::WarningEvent(winrt::event_token const& token) noexcept
  {
  }
+ int32_t WarningStatic::ReadWriteProperty()
+ {
+ return 0;
+ }
+ void WarningStatic::ReadWriteProperty(int32_t value)
+ {
+ }
 }

src/Tests/TestComponentCSharp/WarningStatic.h

@@ -17,6 +17,8 @@ namespace winrt::TestComponentCSharp::implementation
  static void WarningProperty(int32_t value);
  static winrt::event_token WarningEvent(Windows::Foundation::EventHandler<int32_t> const& handler);
  static void WarningEvent(winrt::event_token const& token) noexcept;
+ static int32_t ReadWriteProperty();
+ static void ReadWriteProperty(int32_t value);
  };
 }
 namespace winrt::TestComponentCSharp::factory_implementation

src/Tests/UnitTest/TestComponentCSharp_Tests.cs

@@ -2660,6 +2660,14 @@ public void TestSetPropertyAcrossProjections()
  Assert.Equal(4, property.ReadWriteProperty);
  }
 
+ [Fact]
+ public void TestStaticPropertyImplementedAcrossInterfaces()
+ {
+ // Testing call doesn't fail.
+ WarningStatic.ReadWriteProperty = 4; // expected warning CA1416
+ _ = WarningStatic.ReadWriteProperty;
+ }
+
  // Test scenario where type reported by runtimeclass name is not a valid type (i.e. internal type).
  [Fact]
  public void TestNonProjectedRuntimeClass()

src/cswinrt/code_writers.h

@@ -2404,17 +2404,6 @@ Marshal.Release(inner);
  std::nullopt);
  }
 
- void write_static_property(writer& w, Property const& prop, std::string_view prop_target, std::string_view platform_attribute = ""sv)
- {
- auto [getter, setter] = get_property_methods(prop);
- auto getter_target = getter ? prop_target : "";
- auto setter_target = setter ? prop_target : "";
- write_property(w, prop.Name(), prop.Name(), write_prop_type(w, prop),
- getter_target, setter_target, "public "sv, "static "sv, platform_attribute, platform_attribute, 
- !getter ? std::nullopt : std::optional(std::pair(prop.Parent(), prop)), 
- !setter ? std::nullopt : std::optional(std::pair(prop.Parent(), prop)));
- }
-
  void write_static_factory_event(writer& w, Event const& event, std::string_view event_target, std::string_view platform_attribute = ""sv)
  {
  write_event(w, event.Name(), event, event_target, "public "sv, ""sv, platform_attribute, std::nullopt);
@@ -2425,18 +2414,72 @@ Marshal.Release(inner);
  write_event(w, event.Name(), event, event_target, "public "sv, "static "sv, platform_attribute, std::optional(std::tuple(event.Parent(), event, true)));
  }
 
- void write_static_members(writer& w, TypeDef const& static_type, TypeDef const& class_type)
+ void write_static_members(writer& w, TypeDef const& class_type)
  {
- auto vftblType = settings.netstandard_compat ?
- w.write_temp("%.Vftbl", bind<write_type_name>(static_type, typedef_name_type::ABI, true)) :
- "IUnknownVftbl";
- write_static_objref_definition(w, vftblType, static_type, class_type);
- auto cache_object = w.write_temp("%", bind<write_objref_type_name>(static_type));
+ std::map<std::string, std::tuple<std::string, std::string, std::string, std::string, std::string, std::optional<std::pair<TypeDef, Property>>, std::optional<std::pair<TypeDef, Property>>>> properties;
+
+ for (auto&& [interface_name, factory] : get_attributed_types(w, class_type))
+ {
+ if (factory.statics)
+ {
+ auto vftblType = settings.netstandard_compat ?
+ w.write_temp("%.Vftbl", bind<write_type_name>(factory.type, typedef_name_type::ABI, true)) :
+ "IUnknownVftbl";
+ write_static_objref_definition(w, vftblType, factory.type, class_type);
+ auto cache_object = w.write_temp("%", bind<write_objref_type_name>(factory.type));
+
+ auto platform_attribute = write_platform_attribute_temp(w, factory.type);
+ w.write_each<write_static_method>(factory.type.MethodList(), cache_object, platform_attribute);
+ w.write_each<write_static_event>(factory.type.EventList(), cache_object, platform_attribute);
+
+ // Merge property getters/setters, since such may be defined across interfaces
+ for (auto&& prop : factory.type.PropertyList())
+ {
+ auto [getter, setter] = get_property_methods(prop);
+ auto prop_type = write_prop_type(w, prop);
+
+ auto [prop_targets, inserted] = properties.try_emplace(std::string(prop.Name()),
+ prop_type,
+ getter ? cache_object : "",
+ getter ? platform_attribute : "",
+ setter ? cache_object : "",
+ setter ? platform_attribute : "",
+ !getter ? std::nullopt : std::optional(std::pair(prop.Parent(), prop)),
+ !setter ? std::nullopt : std::optional(std::pair(prop.Parent(), prop))
+ );
+ if (!inserted)
+ {
+ auto& [property_type, getter_target, getter_platform, setter_target, setter_platform, getter_prop, setter_prop] = prop_targets->second;
+ XLANG_ASSERT(property_type == prop_type);
+ if (getter)
+ {
+ XLANG_ASSERT(getter_target.empty());
+ getter_target = cache_object;
+ getter_platform = platform_attribute;
+ getter_prop = std::optional(std::pair(prop.Parent(), prop));
+ }
+ if (setter)
+ {
+ XLANG_ASSERT(setter_target.empty());
+ setter_target = cache_object;
+ setter_platform = platform_attribute;
+ setter_prop = std::optional(std::pair(prop.Parent(), prop));
+ }
+ XLANG_ASSERT(!getter_target.empty() || !setter_target.empty());
+ }
+ }
+ }
+ }
 
- auto platform_attribute = write_platform_attribute_temp(w, static_type);
- w.write_each<write_static_method>(static_type.MethodList(), cache_object, platform_attribute);
- w.write_each<write_static_property>(static_type.PropertyList(), cache_object, platform_attribute);
- w.write_each<write_static_event>(static_type.EventList(), cache_object, platform_attribute);
+ // Write properties with merged accessors
+ for (auto& [prop_name, prop_data] : properties)
+ {
+ auto& [prop_type, getter_target, getter_platform, setter_target, setter_platform, getter_prop, setter_prop] = prop_data;
+ write_property(w, prop_name, prop_name, prop_type,
+ getter_target, setter_target, "public "sv, "static "sv, getter_platform, setter_platform,
+ getter_prop,
+ setter_prop);
+ }
  }
 
  void write_attributed_types(writer& w, TypeDef const& type)
@@ -2489,10 +2532,10 @@ public static %I As<I>() => ActivationFactory.Get("%.%").AsInterface<I>();
  type.TypeNamespace(),
  type.TypeName());
  }
-
- write_static_members(w, factory.type, type);
  }
  }
+
+ write_static_members(w, type);
  }
 
  void write_nongeneric_enumerable_members(writer& w, std::string_view target)
@@ -3098,6 +3141,20 @@ remove => %.ErrorsChanged -= value;
  return false;
  };
 
+ std::function<bool(TypeDef const&)> search_interfaces_from_attributes = [&](TypeDef const& type)
+ {
+ for (auto&& [interface_name, factory] : get_attributed_types(w, type))
+ {
+ if (factory.statics && factory.type && (search_interface(factory.type) || search_interfaces(factory.type)))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ };
+
+
  // first search base interfaces for property getter
  if (search_interfaces(setter_iface))
  {
@@ -3116,6 +3173,11 @@ remove => %.ErrorsChanged -= value;
  {
  return { getter_iface, false };
  }
+
+ if (search_interfaces_from_attributes(exclusive_to_type))
+ {
+ return { getter_iface, false };
+ }
  }
 
  throw_invalid("Could not find property getter interface");