Support [Deprecated] in 3.0 projections and authored components

[Sergio0694]

Summary

Port [Windows.Foundation.Metadata.Deprecated] handling to the CsWinRT 3.0 projection writer and WinMD generator. Deprecated Windows Runtime APIs are now projected with [System.Obsolete], and APIs marked DeprecationType.Remove are omitted from the projected surface while their ABI vtable slot is preserved (stubbed to return E_NOTIMPL) for binary compatibility. The same attribute is supported when authoring Windows Runtime components.

Motivation

Honoring [Deprecated] was supported in CsWinRT 2.x (in cswinrt.exe) but had not yet been ported to the 3.0 C# generators. Without it, deprecated Windows Runtime APIs are projected as regular members (no [Obsolete] guidance for consumers), and APIs the platform has removed would either reappear on the projected surface or shift the ABI vtable layout, breaking binary compatibility with existing native callers.

The attribute carries a DeprecationType: Deprecate (0) means the API still works but should be replaced, and Remove (1) means it is gone from the projected surface but its vtable slot must remain. [Deprecated] is not exclusive to the Windows SDK: authored components can apply it to their own members too, so support has to span both the consuming projection and the authoring pipeline.

Changes

Projection writer (consuming side)

• Extensions/IHasCustomAttributeExtensions.cs: adds IsDeprecated, IsRemoved, IsDeprecatedNotRemoved, and DeprecatedMessage helpers that read the [Deprecated] attribute arguments (message and DeprecationType).
• Factories/CustomAttributeFactory.cs: emits [System.Obsolete(message)] for members and types that are deprecated but not removed.
• Generation/ProjectionGenerator.Namespace.cs and Generation/ProjectionGenerator.GeneratedIids.cs: skip removed types entirely so they never appear in the projection.
• Factories/InterfaceFactory.cs, Factories/ClassMembersFactory.WriteInterfaceMembers.cs, Factories/ClassMembersFactory.WriteClassMembers.cs, Factories/ClassFactory.cs, Factories/ConstructorFactory.AttributedTypes.cs, Factories/ConstructorFactory.Composable.cs, Factories/AbiInterfaceIDicFactory.cs, and Builders/ProjectionFileBuilder.cs (enum fields): skip removed members (and removed factory/static interfaces) and annotate deprecated ones with [Obsolete], following the MIDL convention that a property's marker lives on its getter and an event's on its add accessor.
• Models/PropertyAccessorState.cs and Models/StaticPropertyAccessorState.cs: track the accessor that carries the deprecation marker so the [Obsolete] attribute is emitted on the projected property.
• Factories/AbiInterfaceFactory.cs and Factories/ComponentFactory.cs: a removed member keeps its CCW vtable slot but the slot is stubbed to return E_NOTIMPL in both consuming and component (authoring) mode. Generated code cannot dispatch to a removed authored member, because the C# compiler treats a call to a [Deprecated(Remove)] member as an obsolete-as-error (CS0619) that cannot be suppressed; the activation/static factory likewise omits forwarders for removed members, and a type whose parameterless constructor is removed is treated as non-default-activatable (its ActivateInstance returns E_NOTIMPL instead of emitting new T()). The vtable slot is preserved so the layout stays stable for existing native callers.
• Factories/ConstructorFactory.AttributedTypes.cs, Factories/ClassFactory.cs, and Extensions/TypeDefinitionExtensions.cs: the two predicates that decide whether a reference projection needs a synthetic non-public parameterless constructor now agree with what WriteAttributedTypes actually emits, i.e. they skip removed factory interfaces and removed factory overloads. Without this, a class whose activation or composable factory was entirely removed emitted no constructor at all and the C# compiler synthesized an implicit public parameterless one in its place, putting a constructor on the reference surface that the implementation projection does not have (so a consumer's new T() would compile and then fail at run time). ClassFactory's inline hasRefModeCtors loop is replaced by a new ConstructorFactory.EmitsAnyConstructor next to the existing EmitsParameterlessConstructor, and the per-factory-interface part is exposed as HasActivatableFactoryMethod alongside HasActivatableDefaultConstructor.
• Extensions/ProjectionWriterExtensions.cs, Factories/MetadataAttributeFactory.cs, and Resources/Base/ComInteropExtensions.cs: generated projection files suppress CS0612/CS0618, alongside the diagnostics they already suppress. [Obsolete] is guidance for consumers of a projection, not for the projection itself, which has to name a deprecated type in order to project it at all — without this the Windows SDK projection does not build, because ComInteropExtensions.cs wraps IPlayToManagerInterop in terms of the deprecated Windows.Media.PlayTo.PlayToManager. The suppressions are per-file, so user code calling a deprecated API still gets the warning.

WinMD generator (authoring side)

• Writers/WinMDWriter.Members.cs and Writers/WinMDWriter.Attributes.cs: when generating a component .winmd, the [Deprecated] attribute for properties and events is emitted on the accessor (the getter for properties, the add accessor for events) rather than the property/event metadata row, matching the placement MIDL produces for the Windows SDK. This keeps authored components consistent with the SDK so both CsWinRT and other consumers (e.g. windows-rs) resolve member deprecation the same way. Methods and types continue to carry the attribute directly.

Constructors are deliberately not covered here: Windows.Foundation.Metadata.DeprecatedAttribute has no AttributeTargets.Constructor, so a C# component author cannot apply it to a constructor in the first place.

Tests

• Tests/AuthoringTest/Program.cs: extends DeprecatedMembersClass to cover Deprecate and Remove across instance methods, static methods, properties, and events. Building it exercises both the WinMD generator and the component projection.
• Tests/AuthoringConsumptionTest/test.cpp: exercises the deprecated and new members of each kind (method, property, event, static), and asserts that the removed instance, static, and event members throw E_NOTIMPL. The new members sit after the removed slots in vtable order and still dispatch correctly, proving the removed slots remain in place.
• Tests/TestComponentCSharp/: adds DeprecatedConstructorClass (a deprecated constructor, a removed one, and a live one declared after it), plus RemovedActivationClass (sealed/activatable) and RemovedComposableClass (unsealed/composable) whose only constructor is removed. Building Projections/Test generates a reference projection for them, and the unit test publish generates the implementation projection.
• Tests/UnitTest/TestComponentCSharp_Tests.cs: asserts both projections. The reference projection is checked at compile time via an overload pair whose new() constrained member is only a candidate when the type really exposes a public parameterless constructor, which is what catches a class that dropped every constructor without emitting a non-public one in its place. The implementation projection is checked at run time through reflection, and by constructing the types and calling their static factory methods (the surviving three-argument constructor sums its arguments, so it only produces the expected value if the removed constructor's factory slot is still in place).