Explicitly generate list of module namespaces and use that for header exclusion.

Author: DefaultRyan

cppwinrt/code_writers.h

@@ -41,10 +41,17 @@ namespace cppwinrt
         // consuming the module (WINRT_MODULE, project-wide), base.h types are
         // already available. Macros don't cross module boundaries, so include
         // base_macros.h for the version check and other macros.
-        // WINRT_IMPL_SKIP_INCLUDES also triggers this (used locally in .g.h files).
-        auto format_guard = R"(#if defined(WINRT_BUILD_MODULE) || defined(WINRT_MODULE) || defined(WINRT_IMPL_SKIP_INCLUDES)
+        // When WINRT_MODULE is defined, also include winrt_module_namespaces.h
+        // which declares per-namespace macros (WINRT_MODULE_NS_*) so that
+        // cross-namespace #include guards can precisely skip only the namespaces
+        // that are in the module.
+        auto format_guard = R"(#if defined(WINRT_BUILD_MODULE) || defined(WINRT_MODULE)
 #include "winrt/base_macros.h"
-#else
+#endif
+#if defined(WINRT_MODULE) && !defined(WINRT_BUILD_MODULE)
+#include "winrt/winrt_module_namespaces.h"
+#endif
+#if !defined(WINRT_BUILD_MODULE) && !defined(WINRT_MODULE)
 )";
         auto format_end = R"(#endif
 )";

cppwinrt/file_writers.h

@@ -285,15 +285,16 @@ import std;
 
         // In module mode (WINRT_MODULE defined), SDK types and exported impl
         // templates come from 'import winrt;'. Component-specific types come
-        // from the component's own projection headers, included with
-        // WINRT_IMPL_SKIP_INCLUDES to skip SDK dependencies already in the module.
-        // WINRT_IMPL_SKIP_INCLUDES may already be defined project-wide by the
-        // NuGet targets, so use #ifndef to avoid redefinition warnings.
+        // from the component's own projection headers. The version assert in
+        // each header includes winrt_module_namespaces.h (when WINRT_MODULE is
+        // defined), which provides per-namespace WINRT_MODULE_NS_* macros.
+        // Cross-namespace deps use these per-namespace guards: platform deps
+        // (in the module) are skipped, component deps (not in the module) are
+        // included normally.
         w.write("#ifdef WINRT_MODULE\n");
         w.write("#include \"winrt/base_macros.h\"\n");
         w.write("#ifdef WINRT_IMPORT_STD\nimport std;\n#endif\n");
         w.write("import winrt;\n");
-        w.write("#ifndef WINRT_IMPL_SKIP_INCLUDES\n#define WINRT_IMPL_SKIP_INCLUDES\n#endif\n");
         w.write("#endif\n");
         for (auto&& depends : w.depends)
         {

cppwinrt/main.cpp

@@ -344,7 +344,7 @@ R"(  local               Local ^%WinDir^%\System32\WinMetadata folder
             group.synchronous(args.exists("synchronous"));
             writer ixx;
             write_preamble(ixx);
-            ixx.write("module;\n#define WINRT_BUILD_MODULE\n#undef WINRT_IMPL_SKIP_INCLUDES\n");
+            ixx.write("module;\n#define WINRT_BUILD_MODULE\n");
             ixx.write(strings::base_includes);
             ixx.write(strings::base_std_includes);
             ixx.write("\nexport module winrt;\n#define WINRT_EXPORT export\n#define WINRT_IMPL_INCLUDES_HANDLED\n\n");
@@ -373,6 +373,31 @@ R"(  local               Local ^%WinDir^%\System32\WinMetadata folder
                 write_base_h();
                 write_base_macros_h();
                 ixx.flush_to_file(settings.output_folder + "winrt/winrt.ixx");
+
+                // Generate a companion header that declares which namespaces are
+                // in the module. Consumer projects include this (via WINRT_MODULE)
+                // so that cross-namespace #include guards can precisely skip only
+                // namespaces available from the module, while still including
+                // component and other non-module namespace deps.
+                // Only generated alongside the ixx (not for component projections
+                // which may also set -base but shouldn't produce module metadata).
+                if (!settings.component)
+                {
+                    writer module_ns;
+                    write_preamble(module_ns);
+                    module_ns.write("#pragma once\n");
+                    for (auto&&[ns, members] : c.namespaces())
+                    {
+                        if (!has_projected_types(members) || !settings.projection_filter.includes(members))
+                        {
+                            continue;
+                        }
+                        std::string ns_macro{ ns };
+                        std::replace(ns_macro.begin(), ns_macro.end(), '.', '_');
+                        module_ns.write("#define WINRT_MODULE_NS_%\n", ns_macro);
+                    }
+                    module_ns.flush_to_file(settings.output_folder + "winrt/winrt_module_namespaces.h");
+                }
             }
 
             if (settings.component)

cppwinrt/type_writers.h

@@ -566,12 +566,30 @@ namespace cppwinrt
 
         void write_root_include_guarded(std::string_view const& include)
         {
-            auto format = R"(#ifndef WINRT_IMPL_SKIP_INCLUDES
+            // Extract the namespace from the include path. The include is either
+            // "NS" (for main headers) or "impl/NS.N" (for impl headers).
+            // The per-namespace guard macro is WINRT_MODULE_NS_<ns_with_underscores>.
+            std::string ns_part;
+            if (include.size() > 5 && include.substr(0, 5) == "impl/")
+            {
+                auto remainder = include.substr(5); // skip "impl/"
+                auto dot = remainder.rfind('.');
+                ns_part = std::string(remainder.substr(0, dot));
+            }
+            else
+            {
+                ns_part = std::string(include);
+            }
+            std::string ns_macro = ns_part;
+            std::replace(ns_macro.begin(), ns_macro.end(), '.', '_');
+
+            auto format = R"(#ifndef WINRT_MODULE_NS_%
 #include %winrt/%.h%
 #endif
 )";
 
             write(format,
+                ns_macro,
                 settings.brackets ? '<' : '\"',
                 include,
                 settings.brackets ? '>' : '\"');

nuget/Microsoft.Windows.CppWinRT.targets

@@ -897,11 +897,12 @@ $(XamlMetaDataProviderPch)
             </ClCompile>
         </ItemGroup>
         <!-- Define WINRT_MODULE so generated component files (.g.h, .g.cpp) use
-             import winrt; instead of #include, and so reference projection headers
-             skip base.h (types come from the module). Cross-namespace component deps
-             are NOT suppressed — only WINRT_IMPL_SKIP_INCLUDES (set locally in .g.h)
-             does that. winrt.ixx defines WINRT_BUILD_MODULE in its global module
-             fragment for its own needs. -->
+             import winrt;. When WINRT_MODULE is defined, namespace headers include
+             winrt_module_namespaces.h which declares per-namespace WINRT_MODULE_NS_*
+             macros. Cross-namespace deps are guarded by these per-namespace macros,
+             precisely skipping only namespaces in the module while including
+             component and other non-module deps normally.
+             winrt.ixx defines WINRT_BUILD_MODULE in its global module fragment. -->
         <ItemGroup>
             <ClCompile>
                 <PreprocessorDefinitions>WINRT_MODULE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@@ -972,7 +973,7 @@ $(XamlMetaDataProviderPch)
         </ItemGroup>
 
         <!-- Define WINRT_MODULE so generated component files (.g.h, .g.cpp) use
-             import winrt;, and so reference projection headers skip base.h. -->
+             import winrt;, and so namespace headers use per-namespace guards. -->
         <ItemGroup>
             <ClCompile>
                 <PreprocessorDefinitions>WINRT_MODULE;%(PreprocessorDefinitions)</PreprocessorDefinitions>

test/nuget/TestModuleComponent/TestModuleComponentClass.cpp

@@ -13,4 +13,15 @@ namespace winrt::TestModuleComponent::implementation
     {
         return winrt::make<winrt::TestModuleComponent::Widgets::implementation::Widget>(L"FromComponent");
     }
+
+    winrt::TestModuleComponent::WidgetInfo TestModuleComponentClass::GetWidgetInfo()
+    {
+        auto widget = CreateWidget();
+        return { widget.Size(), L"A test widget" };
+    }
+
+    winrt::Windows::Foundation::Uri TestModuleComponentClass::GetUri()
+    {
+        return winrt::Windows::Foundation::Uri(L"http://aka.ms/cppwinrt");
+    }
 }

test/nuget/TestModuleComponent/TestModuleComponentClass.h

@@ -8,6 +8,8 @@ namespace winrt::TestModuleComponent::implementation
         TestModuleComponentClass() = default;
         void Test();
         winrt::TestModuleComponent::Widgets::Widget CreateWidget();
+        winrt::TestModuleComponent::WidgetInfo GetWidgetInfo();
+        winrt::Windows::Foundation::Uri GetUri();
     };
 }
 namespace winrt::TestModuleComponent::factory_implementation

test/nuget/TestModuleComponent/TestModuleComponentClass.idl

@@ -2,11 +2,19 @@ import "TestModuleComponentWidget.idl";
 
 namespace TestModuleComponent
 {
+    struct WidgetInfo
+    {
+        TestModuleComponent.Widgets.WidgetSize Size;
+        String Description;
+    };
+
     [default_interface]
     runtimeclass TestModuleComponentClass
     {
         TestModuleComponentClass();
         void Test();
         TestModuleComponent.Widgets.Widget CreateWidget();
+        WidgetInfo GetWidgetInfo();
+        Windows.Foundation.Uri GetUri();
     }
 }

test/nuget/TestModuleComponent/TestModuleComponentWidget.h

@@ -8,6 +8,7 @@ namespace winrt::TestModuleComponent::Widgets::implementation
         Widget() = default;
         Widget(hstring const& name) : m_name(name) {}
         hstring Name() const { return m_name; }
+        winrt::TestModuleComponent::Widgets::WidgetSize Size() const { return { 100.0f, 50.0f }; }
 
     private:
         hstring m_name{ L"DefaultWidget" };

test/nuget/TestModuleComponent/TestModuleComponentWidget.idl

@@ -1,10 +1,17 @@
 namespace TestModuleComponent.Widgets
 {
+    struct WidgetSize
+    {
+        Single Width;
+        Single Height;
+    };
+
     [default_interface]
     runtimeclass Widget
     {
         Widget();
         Widget(String name);
         String Name{ get; };
+        WidgetSize Size{ get; };
     }
 }