Pin the other direction of the moved overflow boundary

The vendored range check moved in both directions, and only the direction that
starts refusing values had a test. Cover the quiet one: filling an int8 tensor with
127.5 used to be refused and now stores 127.

Test Plan:
Compiled the real header from before and after this change into the same probe and
ran both. Before: 127.5 into int8 and 255.5 into uint8 both report overflow, and 2^63
into int64 is accepted. After: the first two are accepted and 2^63 overflows. So the
boundary moved both ways, and the case added here fails against the previous header
rather than passing either way.

Placed in this file rather than the shared macro because the macro expands into eight
suites, and several of them reach the scalar through a path that rejects a fractional
value before any range check, where the case would not measure what it claims.

Decide ATen mode before the wrapper consumes it on the test path too

The library and binary paths were fixed to read the dependency list before the
shared patch removes it. The test path has the same shape and was missed: it still
called its own check afterwards, so a test naming an ATen dependency was pinned to
C++17 and would fail on ATen's headers.

Read it in the same place, and pass the answer down, so both paths agree.

Test Plan:
Ran the test path over the cases that matter, with the dependency list removed first
to match what the wrapper really does. Before this a test naming libtorch, c10 or
torch-core-cpp came away pinned to C++17; after, all three take C++20 from the
toolchain. A test named for ATen is unchanged, and a plain test still gets C++17,
which is what the embedded builds rely on.

No open source test target has this shape today, so this closes the same defect on a
path that is not yet exercised rather than repairing a red job.

Author: pytorchbot

kernels/test/op_full_test.cpp

@@ -84,6 +84,19 @@ ET_FORALL_REALHBF16_TYPES(GENERATE_TEST)
 
 GENERATE_SCALAR_OVERFLOW_TESTS(OpFullOutTest)
 
+// The other half of the boundary change: 127.5 used to be refused for an int8
+// tensor and now truncates to 127.
+TEST_F(OpFullOutTest, CharTensorFractionalScalarTruncates) {
+  TensorFactory<ScalarType::Char> tf;
+  std::vector<int32_t> sizes = {2, 2};
+  std::vector<int64_t> sizes_int64_t(sizes.begin(), sizes.end());
+  auto aref = IntArrayRef(sizes_int64_t.data(), sizes_int64_t.size());
+  Tensor out = tf.zeros(sizes);
+
+  op_full_out(aref, 127.5, out);
+  EXPECT_TENSOR_EQ(out, tf.full(sizes, 127));
+}
+
 TEST_F(OpFullOutTest, HalfSupport) {
   TensorFactory<ScalarType::Half> tf;
 

shim_et/xplat/executorch/build/runtime_wrapper.bzl

@@ -157,7 +157,7 @@ def _is_aten_target(kwargs):
                 return True
     return False
 
-def _patch_test_compiler_flags(kwargs):
+def _patch_test_compiler_flags(kwargs, aten_mode = False):
     if "compiler_flags" not in kwargs:
         kwargs["compiler_flags"] = []
 
@@ -169,11 +169,11 @@ def _patch_test_compiler_flags(kwargs):
     xplat_deps = kwargs.get("xplat_deps", [])
     fbcode_deps = kwargs.get("fbcode_deps", [])
     is_aten_test = (
+        aten_mode or
         "_aten" in name or
         "aten_" in name or
         "gtest_aten" in external_deps or
         "gmock_aten" in external_deps or
-        _is_aten_target(kwargs) or
         _has_pytorch_dep(xplat_deps) or
         _has_pytorch_dep(fbcode_deps)
     )
@@ -340,10 +340,12 @@ def _cxx_test(*args, **kwargs):
         kwargs["deps"] = []
     kwargs["deps"].append("//executorch/test/utils:utils")
 
+    # Before _patch_kwargs_cxx, which consumes external_deps.
+    aten_mode = _is_aten_target(kwargs)
     _patch_kwargs_cxx(kwargs)
     env.patch_headers(kwargs)
     _patch_build_mode_flags(kwargs)
-    _patch_test_compiler_flags(kwargs)
+    _patch_test_compiler_flags(kwargs, aten_mode)
 
     env.patch_platform_build_mode_flags(kwargs)
     env.cxx_test(*args, **kwargs)