feat: unify CPPFLAGS and CXXFLAGS by default

CPPFLAGS and CXXFLAGS are merged into a single deduplicated value
after parsing, both in apptools and magicflags. Use
--separate-flags-CPP-CXX to opt out of unification.

Fixes #4

Author: DrGeoff

src/compiletools/apptools.py

@@ -170,6 +170,13 @@ def add_common_arguments(cap, argv=None, variant=None):
         action="append",
         default=[],
     )
+    compiletools.utils.add_flag_argument(
+        parser=cap,
+        name="separate-flags-CPP-CXX",
+        dest="separate_flags_CPP_CXX",
+        default=False,
+        help="Keep CPPFLAGS and CXXFLAGS separate instead of unified.",
+    )
     compiletools.git_utils.NameAdjuster.add_arguments(cap)
     _add_xxpend_arguments(cap, xxpendableargs=("include", "cppflags", "cflags", "cxxflags"))
     add_locking_arguments(cap)
@@ -944,6 +951,22 @@ def _do_xxpend(args, name):
             setattr(args, name, attr)
 
 
+def _unify_cpp_cxx_flags(args):
+    """Combine CPPFLAGS and CXXFLAGS into a single deduplicated value.
+
+    Skipped when --separate-flags-CPP-CXX is set.
+    """
+    if getattr(args, 'separate_flags_CPP_CXX', False):
+        return
+    unified = " ".join(
+        compiletools.utils.combine_and_deduplicate_compiler_flags(
+            args.CPPFLAGS, args.CXXFLAGS
+        )
+    )
+    args.CPPFLAGS = unified
+    args.CXXFLAGS = unified
+
+
 def _deduplicate_all_flags(args):
     """Deduplicate all compiler and linker flags after all processing is complete"""
     flaglist = ("CPPFLAGS", "CFLAGS", "CXXFLAGS", "LDFLAGS")
@@ -1071,6 +1094,7 @@ def _commonsubstitutions(args):
     _add_include_paths_to_flags(args)
     _add_flags_from_pkg_config(args)
     _set_project_version(args)
+    _unify_cpp_cxx_flags(args)
 
     try:
         # If the user didn't explicitly supply a bindir then modify the bindir to use the variant name

src/compiletools/magicflags.py

@@ -343,6 +343,15 @@ def _parse(self, filename):
             flagsforfilename[sz.Str("LDFLAGS")].extend(flagsforfilename[sz.Str("LINKFLAGS")])
             del flagsforfilename[sz.Str("LINKFLAGS")]
 
+        # Unify CPPFLAGS and CXXFLAGS in magic flags (unless opted out)
+        if not getattr(self._args, 'separate_flags_CPP_CXX', False):
+            cpp_key = sz.Str("CPPFLAGS")
+            cxx_key = sz.Str("CXXFLAGS")
+            if cpp_key in flagsforfilename or cxx_key in flagsforfilename:
+                combined = flagsforfilename[cpp_key] + flagsforfilename[cxx_key]
+                flagsforfilename[cpp_key] = list(combined)
+                flagsforfilename[cxx_key] = list(combined)
+
         # Deduplicate all flags while preserving order, with smart compiler flag handling
         for key in flagsforfilename:
             flagsforfilename[key] = compiletools.utils.deduplicate_compiler_flags(flagsforfilename[key])

src/compiletools/test_apptools.py

@@ -333,3 +333,63 @@ def test_user_config_append_cxxflags(self):
             # print(args)
             # Check that the append-CXXFLAGS argument made its way into the CXXFLAGS
             assert "-fdiagnostics-color=always" in args.CXXFLAGS
+
+
+class TestUnifyCppCxxFlags:
+    """Tests for CPPFLAGS/CXXFLAGS unification (default behavior)."""
+
+    def setup_method(self):
+        uth.reset()
+
+    def _parse(self, extra_argv=None):
+        """Parse args with a temp config and optional extra argv."""
+        with uth.TempDirContext():
+            uth.create_temp_ct_conf(os.getcwd())
+            cfgfile = "foo.dbg.conf"
+            uth.create_temp_config(os.getcwd(), cfgfile)
+            argv = ["--config=" + cfgfile, "-v"]
+            if extra_argv:
+                argv.extend(extra_argv)
+            cap = configargparse.getArgumentParser(
+                description="Test unify CPP/CXX flags",
+                formatter_class=configargparse.ArgumentDefaultsHelpFormatter,
+                auto_env_var_prefix="",
+                default_config_files=["ct.conf"],
+                args_for_setting_config_path=["-c", "--config"],
+                ignore_unknown_config_file_keys=True,
+            )
+            compiletools.apptools.add_common_arguments(cap)
+            compiletools.apptools.add_link_arguments(cap)
+            return compiletools.apptools.parseargs(cap, argv)
+
+    def test_unified_by_default(self):
+        """After parseargs, CPPFLAGS and CXXFLAGS are identical."""
+        args = self._parse()
+        assert args.CPPFLAGS == args.CXXFLAGS
+
+    def test_unified_with_both_specified(self):
+        """When both flags are given, both end up containing both values."""
+        args = self._parse(["--CPPFLAGS=-DFOO", "--CXXFLAGS=-DBAR"])
+        assert "-DFOO" in args.CPPFLAGS
+        assert "-DBAR" in args.CPPFLAGS
+        assert "-DFOO" in args.CXXFLAGS
+        assert "-DBAR" in args.CXXFLAGS
+        assert args.CPPFLAGS == args.CXXFLAGS
+
+    def test_separate_mode_allows_divergence(self):
+        """--separate-flags-CPP-CXX keeps them independent."""
+        args = self._parse([
+            "--CPPFLAGS=-DFOO",
+            "--CXXFLAGS=-DBAR",
+            "--separate-flags-CPP-CXX",
+        ])
+        assert "-DFOO" in args.CPPFLAGS
+        assert "-DBAR" not in args.CPPFLAGS
+        assert "-DBAR" in args.CXXFLAGS
+        assert "-DFOO" not in args.CXXFLAGS
+
+    def test_append_cppflags_appears_in_both(self):
+        """--append-cppflags value appears in both CPPFLAGS and CXXFLAGS."""
+        args = self._parse(["--append-CPPFLAGS=-DAPPENDED"])
+        assert "-DAPPENDED" in args.CPPFLAGS
+        assert "-DAPPENDED" in args.CXXFLAGS

src/compiletools/test_magicflags.py

@@ -809,3 +809,50 @@ def test_magic_flags_macro_state_equivalence(self, pkgconfig_env):
                 + "\n".join(f"  {name}: Direct={dv}, Cpp={cv}" for name, dv, cv in mismatches[:10])
             )
 
+    def test_magic_cppflags_unified_with_cxxflags(self):
+        """Magic CPPFLAGS appear in CXXFLAGS (and vice versa) when unified."""
+        files = uth.write_sources({
+            "test_unified.cpp": '//#CPPFLAGS=-DFROMCPP\nint main() { return 0; }\n',
+        })
+        source_file = str(files["test_unified.cpp"])
+
+        mf = tb.create_magic_parser(["--magic=direct"], tempdir=self._tmpdir)
+        result = mf.parse(source_file)
+
+        cpp_flags = [str(f) for f in result.get(sz.Str("CPPFLAGS"), [])]
+        cxx_flags = [str(f) for f in result.get(sz.Str("CXXFLAGS"), [])]
+        assert "-DFROMCPP" in cpp_flags, f"Expected -DFROMCPP in CPPFLAGS, got {cpp_flags}"
+        assert "-DFROMCPP" in cxx_flags, f"Expected -DFROMCPP in CXXFLAGS, got {cxx_flags}"
+
+    def test_magic_cxxflags_unified_with_cppflags(self):
+        """Magic CXXFLAGS appear in CPPFLAGS when unified."""
+        files = uth.write_sources({
+            "test_unified2.cpp": '//#CXXFLAGS=-DFROMCXX\nint main() { return 0; }\n',
+        })
+        source_file = str(files["test_unified2.cpp"])
+
+        mf = tb.create_magic_parser(["--magic=direct"], tempdir=self._tmpdir)
+        result = mf.parse(source_file)
+
+        cpp_flags = [str(f) for f in result.get(sz.Str("CPPFLAGS"), [])]
+        cxx_flags = [str(f) for f in result.get(sz.Str("CXXFLAGS"), [])]
+        assert "-DFROMCXX" in cpp_flags, f"Expected -DFROMCXX in CPPFLAGS, got {cpp_flags}"
+        assert "-DFROMCXX" in cxx_flags, f"Expected -DFROMCXX in CXXFLAGS, got {cxx_flags}"
+
+    def test_magic_flags_separate_mode(self):
+        """Magic CPPFLAGS stay separate from CXXFLAGS with --separate-flags-CPP-CXX."""
+        files = uth.write_sources({
+            "test_separate.cpp": '//#CPPFLAGS=-DFROMCPP\n//#CXXFLAGS=-DFROMCXX\nint main() { return 0; }\n',
+        })
+        source_file = str(files["test_separate.cpp"])
+
+        mf = tb.create_magic_parser(["--magic=direct", "--separate-flags-CPP-CXX"], tempdir=self._tmpdir)
+        result = mf.parse(source_file)
+
+        cpp_flags = [str(f) for f in result.get(sz.Str("CPPFLAGS"), [])]
+        cxx_flags = [str(f) for f in result.get(sz.Str("CXXFLAGS"), [])]
+        assert "-DFROMCPP" in cpp_flags
+        assert "-DFROMCXX" not in cpp_flags, f"CPPFLAGS should not contain -DFROMCXX in separate mode, got {cpp_flags}"
+        assert "-DFROMCXX" in cxx_flags
+        assert "-DFROMCPP" not in cxx_flags, f"CXXFLAGS should not contain -DFROMCPP in separate mode, got {cxx_flags}"
+