Raise the ATen-mode C++ standard where both builds see it

The C++20 flag for ATen-mode targets was set in the interface layer that exists
only for the open source build, whose own docstring says as much. So the internal
build never got it, and the shared wrapper was passing that layer an argument its
internal counterpart does not accept, which would fail there rather than being
merely ineffective.

Move the decision into the shared wrapper, which both builds go through, and leave
the interface layer exactly as it was. The flag goes on the target's own compile
flags, because the build config applies C++17 to everything and only a flag on the
target overrides it.

Test Plan:
Read the two files' own descriptions of themselves to place this: the interface
layer is for changes specific to one build, the wrapper is for logic shared with
the internal one.

Confirmed the internal counterpart takes only the arguments it always took, so the
previous version would have broken it rather than skipped it.

Ran the new helper over the target from the failure and over targets that must not
move. The generated kernel library and the ATen bridge come away with C++20; a
plain library and the portable kernels come away with no flag added, so they keep
the C++17 the build config gives them, which is what the embedded builds rely on.

I cannot run either Buck build here, so CI has to confirm the generated libraries
compile.

Author: pytorchbot

shim_et/xplat/executorch/build/env_interface.bzl

@@ -160,28 +160,14 @@ def _patch_headers(kwargs):
 def _patch_pp_flags(kwargs):
     return kwargs
 
-def _patch_cxx_compiler_flags(kwargs, aten_mode = False):
-    """Pins the C++ standard a target compiles with.
-
-    C++17 by default, which is what the runtime this project ships requires.
-    ATen-mode targets are raised to C++20, because PyTorch's headers require it as
-    of 2.14: c10/util/intrusive_ptr.h defines operator<=> and returns
-    std::strong_ordering with no feature guard.
-    """
-    std = "-std=c++20" if aten_mode else "-std=c++17"
+def _patch_cxx_compiler_flags(kwargs):
+    """CXX Compiler flags to enable C++17 features."""
     if "lang_compiler_flags" not in kwargs:
-        kwargs["lang_compiler_flags"] = {"cxx_cpp_output": [std]}
+        kwargs["lang_compiler_flags"] = {"cxx_cpp_output": ["-std=c++17"]}
     elif "cxx_cpp_output" not in kwargs["lang_compiler_flags"]:
-        kwargs["lang_compiler_flags"]["cxx_cpp_output"] = [std]
+        kwargs["lang_compiler_flags"]["cxx_cpp_output"] = ["-std=c++17"]
     else:
-        kwargs["lang_compiler_flags"]["cxx_cpp_output"].append(std)
-
-    # Also put it on the target's own flags. The build config sets C++17 for
-    # everything, and for an ATen-mode target that has to be overridden on the
-    # compile itself, not only on the preprocessor pass above, or generated
-    # sources still see C++17 and fail on ATen's concepts.
-    if aten_mode:
-        kwargs["compiler_flags"] = kwargs.get("compiler_flags", []) + [std]
+        kwargs["lang_compiler_flags"]["cxx_cpp_output"].append("-std=c++17")
     return kwargs
 
 # buildifier: disable=unused-variable

shim_et/xplat/executorch/build/runtime_wrapper.bzl

@@ -278,14 +278,26 @@ def _patch_kwargs_cxx(kwargs):
     env.remove_platform_specific_args(kwargs)
     return _patch_kwargs_common(kwargs)
 
+def _patch_aten_mode_std(kwargs):
+    """Raises an ATen-mode target to C++20, which PyTorch's headers require.
+
+    Set here rather than in the OSS-only interface layer, so the internal build
+    gets it too, and as a plain compiler flag so it overrides the C++17 the build
+    config applies to everything.
+    """
+    if _is_aten_target(kwargs):
+        kwargs["compiler_flags"] = kwargs.get("compiler_flags", []) + ["-std=c++20"]
+    return kwargs
+
 def _cxx_library_common(*args, **kwargs):
     _patch_kwargs_cxx(kwargs)
     _patch_build_mode_flags(kwargs)
+    _patch_aten_mode_std(kwargs)
 
     env.patch_platform_build_mode_flags(kwargs)
     env.patch_headers(kwargs)
     env.patch_pp_flags(kwargs)
-    env.patch_cxx_compiler_flags(kwargs, aten_mode = _is_aten_target(kwargs))
+    env.patch_cxx_compiler_flags(kwargs)
     env.patch_force_static(kwargs)
 
     env.cxx_library(*args, **kwargs)
@@ -307,8 +319,9 @@ def _cxx_library(*args, **kwargs):
 def _cxx_binary_helper(*args, **kwargs):
     _patch_kwargs_cxx(kwargs)
     _patch_build_mode_flags(kwargs)
+    _patch_aten_mode_std(kwargs)
     env.patch_platform_build_mode_flags(kwargs)
-    env.patch_cxx_compiler_flags(kwargs, aten_mode = _is_aten_target(kwargs))
+    env.patch_cxx_compiler_flags(kwargs)
 
     env.cxx_binary(*args, **kwargs)