Fix clang-cl: move [[deprecated]] to forward declarations

clang-cl rejects [[deprecated]] on redeclarations after a type is
already defined (-Werror,-Wignored-attributes). Fix by placing the
attribute on forward declarations in .0.h headers instead.

Move #pragma warning(push/disable: 4996) to the preamble of main
namespace headers so it covers both included impl headers and
internal implementation code. The pop comes after internal code,
ensuring user code still sees deprecation warnings.

Also add escape_cpp_string_literal() for deprecation messages to
handle quotes/backslashes/newlines in metadata strings, and remove
the now-unused wrap_suppress_deprecation_warnings and
write_deprecated_redeclaration functions.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Chris Wall (WIN SDE)

cppwinrt/code_writers.h

@@ -123,17 +123,6 @@ namespace cppwinrt
         return { w, write_endif };
     }
 
-    static void write_pragma_warning_pop(writer& w)
-    {
-        w.write("#pragma warning(pop)\n");
-    }
-
-    [[nodiscard]] static finish_with wrap_suppress_deprecation_warnings(writer& w)
-    {
-        w.write("#pragma warning(push)\n#pragma warning(disable: 4996)\n");
-        return { w, write_pragma_warning_pop };
-    }
-
     static void write_parent_depends(writer& w, cache const& c, std::string_view const& type_namespace)
     {
         auto pos = type_namespace.rfind('.');
@@ -209,10 +198,9 @@ namespace cppwinrt
     template <typename T>
     static void write_deprecated_impl(writer& w, T const& row)
     {
-        if (auto attr = get_attribute(row, "Windows.Foundation.Metadata", "DeprecatedAttribute"))
+        if (is_deprecated(row))
         {
-            auto message = get_attribute_value<std::string_view>(attr, 0);
-            w.write("[[deprecated(\"%\")]] ", message);
+            w.write("[[deprecated(\"%\")]] ", get_deprecated_message(row));
         }
     }
 
@@ -226,20 +214,6 @@ namespace cppwinrt
         write_deprecated_impl(w, field);
     }
 
-    static void write_deprecated_redeclaration(writer& w, TypeDef const& type)
-    {
-        if (is_removed(type))
-        {
-            return;
-        }
-
-        if (auto attr = get_attribute(type, "Windows.Foundation.Metadata", "DeprecatedAttribute"))
-        {
-            auto message = get_attribute_value<std::string_view>(attr, 0);
-            w.write("    struct [[deprecated(\"%\")]] %;\n", message, type.TypeName());
-        }
-    }
-
     static void write_enum_field(writer& w, Field const& field, bool parent_deprecated, std::string_view parent_deprecated_message)
     {
         if (is_removed(field))
@@ -422,6 +396,12 @@ namespace cppwinrt
 
         if (empty(generics))
         {
+            if (!is_removed(type) && is_deprecated(type))
+            {
+                w.write("    struct [[deprecated(\"%\")]] %;\n", get_deprecated_message(type), type_name.name);
+                return;
+            }
+
             auto format = R"(    struct %;
 )";
 

cppwinrt/file_writers.h

@@ -181,51 +181,45 @@ namespace cppwinrt
         writer w;
         w.type_namespace = ns;
 
-        // Suppress C4996 (deprecated) in internal projection implementation code.
-        // The deprecated redeclarations below (outside the suppression) trigger warnings in user code.
+        // Internal projection implementation code.
+        // Deprecation warnings (C4996) are suppressed via #pragma warning(push/disable)
+        // written in the preamble, covering both the included headers and this section.
+        // The [[deprecated]] attributes on forward declarations in .0.h headers trigger
+        // warnings only in user code (after the #pragma warning(pop) below).
         {
-            auto wrap_deprecation = wrap_suppress_deprecation_warnings(w);
+            auto wrap_impl = wrap_impl_namespace(w);
+            w.write_each<write_consume_definitions>(members.interfaces);
+            w.param_names = true;
+            w.write_each<write_delegate_implementation>(members.delegates);
+            w.write_each<write_produce>(members.interfaces, c);
+            w.write_each<write_dispatch_overridable>(members.classes);
+        }
+        {
+            auto wrap_type = wrap_type_namespace(w, ns);
+            w.write_each<write_enum_operators>(members.enums);
+            w.write_each<write_class_definitions>(members.classes);
+            w.write_each<write_fast_class_base_definitions>(members.classes);
+            w.write_each<write_delegate_definition>(members.delegates);
+            w.write_each<write_interface_override_methods>(members.classes);
+            w.write_each<write_class_override>(members.classes);
+        }
+        {
+            auto wrap_std = wrap_std_namespace(w);
 
             {
-                auto wrap_impl = wrap_impl_namespace(w);
-                w.write_each<write_consume_definitions>(members.interfaces);
-                w.param_names = true;
-                w.write_each<write_delegate_implementation>(members.delegates);
-                w.write_each<write_produce>(members.interfaces, c);
-                w.write_each<write_dispatch_overridable>(members.classes);
+                auto wrap_lean = wrap_lean_and_mean(w);
+                w.write_each<write_std_hash>(members.interfaces);
+                w.write_each<write_std_hash>(members.classes);
             }
             {
-                auto wrap_type = wrap_type_namespace(w, ns);
-                w.write_each<write_enum_operators>(members.enums);
-                w.write_each<write_class_definitions>(members.classes);
-                w.write_each<write_fast_class_base_definitions>(members.classes);
-                w.write_each<write_delegate_definition>(members.delegates);
-                w.write_each<write_interface_override_methods>(members.classes);
-                w.write_each<write_class_override>(members.classes);
-            }
-            {
-                auto wrap_std = wrap_std_namespace(w);
-
-                {
-                    auto wrap_lean = wrap_lean_and_mean(w);
-                    w.write_each<write_std_hash>(members.interfaces);
-                    w.write_each<write_std_hash>(members.classes);
-                }
-                {
-                    auto wrap_format = wrap_ifdef(w, "__cpp_lib_format");
-                    w.write_each<write_std_formatter>(members.interfaces);
-                    w.write_each<write_std_formatter>(members.classes);   
-                }
+                auto wrap_format = wrap_ifdef(w, "__cpp_lib_format");
+                w.write_each<write_std_formatter>(members.interfaces);
+                w.write_each<write_std_formatter>(members.classes);   
             }
         }
 
-        {
-            auto wrap_type = wrap_type_namespace(w, ns);
-            w.write_each<write_deprecated_redeclaration>(members.interfaces);
-            w.write_each<write_deprecated_redeclaration>(members.classes);
-            w.write_each<write_deprecated_redeclaration>(members.delegates);
-            w.write_each<write_deprecated_redeclaration>(members.structs);
-        }
+        // End deprecation suppression - user code after this gets deprecation warnings.
+        w.write("#pragma warning(pop)\n");
 
         write_namespace_special(w, ns);
 
@@ -234,6 +228,11 @@ namespace cppwinrt
         write_preamble(w);
         write_open_file_guard(w, ns);
         write_version_assert(w);
+
+        // Suppress C4996 (deprecated) for included headers and internal implementation code.
+        // The pop is written in the body section above.
+        w.write("#pragma warning(push)\n#pragma warning(disable: 4996)\n");
+
         write_parent_depends(w, c, ns);
 
         for (auto&& depends : w.depends)

cppwinrt/helpers.h

@@ -248,11 +248,30 @@ namespace cppwinrt
         return has_attribute(row, "Windows.Foundation.Metadata", "DeprecatedAttribute");
     }
 
+    inline std::string escape_cpp_string_literal(std::string_view input)
+    {
+        std::string result;
+        result.reserve(input.size());
+        for (char c : input)
+        {
+            switch (c)
+            {
+            case '\\': result += "\\\\"; break;
+            case '"': result += "\\\""; break;
+            case '\n': result += "\\n"; break;
+            case '\r': result += "\\r"; break;
+            case '\t': result += "\\t"; break;
+            default: result += c; break;
+            }
+        }
+        return result;
+    }
+
     template <typename T>
     auto get_deprecated_message(T const& row)
     {
         auto attr = get_attribute(row, "Windows.Foundation.Metadata", "DeprecatedAttribute");
-        return get_attribute_value<std::string_view>(attr, 0);
+        return escape_cpp_string_literal(get_attribute_value<std::string_view>(attr, 0));
     }
 
     template <typename T>