Decide ATen mode before the wrapper consumes the dependency list

The Buck build still failed compiling generated sources that include ATen:

    ATen/core/TensorBase.h:1031:5: error: unknown type name 'requires'

The check for "is this an ATen target" reads the external dependency list, but by
the time it ran, an earlier step in the same wrapper had already removed that list
after turning its entries into real dependencies. So every target looked like a
non-ATen one, no target was ever raised to C++20, and the flag added for it was
never added at all.

Read the list first, then let the rest of the wrapper consume it.

Test Plan:
Traced the order in the wrapper: the step that removes the list runs before the
step that read it. Reproduced that by running both against the target from the
failure: it reports ATen mode with the list present and not once it is gone, which
is exactly the sequence the wrapper produced.

Reran the whole path in the new order over the target from the failure, an ATen
target that exports its dependency instead of naming it directly, and a plain
library. The first two now come away at C++20 and the plain one is untouched, so
the embedded builds keep the C++17 they rely on.

Also read the build system's own source to confirm the flag can win where it is
placed: a target's flags are appended after the toolchain's, and its comment says
they are last on purpose. So the earlier concern that the flag was being placed
somewhere that could not take effect was unfounded; it simply was not being added.

Shortened an overlong comment that failed the formatter.

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

Author: pytorchbot

backends/aoti/common_shims.h

@@ -62,8 +62,7 @@ aoti_torch_get_dim(Tensor* tensor, int64_t* ret_dim);
 AOTI_SHIM_EXPORT AOTITorchError
 aoti_torch_get_numel(Tensor* tensor, int64_t* ret_numel);
 
-// Reports whether the handle refers to a real tensor. PyTorch has an undefined
-// tensor state that ExecuTorch has no equivalent for, so this is a null check.
+// PyTorch has an undefined-tensor state with no equivalent here: null check.
 AOTI_SHIM_EXPORT AOTITorchError
 aoti_torch_is_defined(Tensor* tensor, bool* ret_is_defined);
 

shim_et/xplat/executorch/build/runtime_wrapper.bzl

@@ -146,10 +146,9 @@ def _has_pytorch_dep(dep_list):
     return False
 
 def _is_aten_target(kwargs):
-    """Whether a target compiles against ATen, and so needs C++20.
+    """Whether a target compiles against ATen.
 
-    Keyed on the external dep names the build maps onto libtorch, rather than on
-    a substring of the label: every ExecuTorch label contains "torch".
+    Keyed on exact dep names, not a substring: every label contains "torch".
     """
     aten_external_deps = ["c10", "libtorch", "libtorch_python", "torch-core-cpp"]
     for key in ["external_deps", "exported_external_deps"]:
@@ -278,21 +277,21 @@ def _patch_kwargs_cxx(kwargs):
     env.remove_platform_specific_args(kwargs)
     return _patch_kwargs_common(kwargs)
 
-def _patch_aten_mode_std(kwargs):
+def _patch_aten_mode_std(kwargs, aten_mode):
     """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.
+    A plain compiler flag, which the prelude places after the toolchain's.
     """
-    if _is_aten_target(kwargs):
+    if aten_mode:
         kwargs["compiler_flags"] = kwargs.get("compiler_flags", []) + ["-std=c++20"]
     return kwargs
 
 def _cxx_library_common(*args, **kwargs):
+    # Before _patch_kwargs_cxx, which consumes external_deps.
+    aten_mode = _is_aten_target(kwargs)
     _patch_kwargs_cxx(kwargs)
     _patch_build_mode_flags(kwargs)
-    _patch_aten_mode_std(kwargs)
+    _patch_aten_mode_std(kwargs, aten_mode)
 
     env.patch_platform_build_mode_flags(kwargs)
     env.patch_headers(kwargs)
@@ -317,9 +316,11 @@ def _cxx_library(*args, **kwargs):
         _cxx_library_common(*args, **kwargs)
 
 def _cxx_binary_helper(*args, **kwargs):
+    # Before _patch_kwargs_cxx, which consumes external_deps.
+    aten_mode = _is_aten_target(kwargs)
     _patch_kwargs_cxx(kwargs)
     _patch_build_mode_flags(kwargs)
-    _patch_aten_mode_std(kwargs)
+    _patch_aten_mode_std(kwargs, aten_mode)
     env.patch_platform_build_mode_flags(kwargs)
     env.patch_cxx_compiler_flags(kwargs)