Give targets that link torch_cpu_library torch's compile settings back

Linking the torch target does more than link. TorchConfig also gives it
TORCH_INCLUDE_DIRS, which CMake treats as system headers because the
target is imported, TORCH_CXX_FLAGS, and on recent torch a minimum C++
standard (C++20). torch_cpu_library, which our targets now link instead
so that a CPU-only torch can load them, only passes on torch/include.

So those targets changed. torch/csrc/api/include became a
normal include directory, so warnings inside torch's headers are now
reported as if they were our code. And a TORCH_CXX_FLAGS set at
configure time no longer reached them. For example, compiling
kernels/portable/cpu/op_allclose.cpp with -Wall -Wextra -Werror went
from no errors to 25 errors, all inside torch's headers. Default builds
were not affected.

find_package_torch now copies torch's interface include directories,
compile options and compile features to torch_cpu_library right after it
finds torch. Every target that links torch_cpu_library, directly or
through a PUBLIC link such as custom_ops_aot_lib, compiles as if it
linked torch, and a new link site cannot forget it.

A new test configures a small project and checks that a target linking
torch_cpu_library, directly or through a PUBLIC link, gets the same
compile flags as a target linking torch. It fails without this change.

Author: shoumikhin

.ci/scripts/tests/test_torch_cpu_library_cmake.py

@@ -0,0 +1,87 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import importlib.util
+import json
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[3]
+
+
+def _compile_flags(entry: dict) -> set:
+    """The flags of one compile command, without the compiler, source and outputs."""
+    flags = set()
+    arguments = iter(shlex.split(entry["command"])[1:])
+    for argument in arguments:
+        if argument in ("-o", "-c", "-MT", "-MF"):
+            next(arguments)
+        elif argument == "-isystem":
+            flags.add(f"-isystem {next(arguments)}")
+        elif argument != "-MD":
+            flags.add(argument)
+    return flags
+
+
+@unittest.skipIf(sys.platform == "win32", "Visual Studio writes no compile commands")
+class TestTorchCpuLibraryCMake(unittest.TestCase):
+    def test_torch_cpu_library_compiles_like_torch(self):
+        cmake = shutil.which("cmake")
+        if cmake is None or importlib.util.find_spec("torch") is None:
+            self.skipTest("CMake and torch are required")
+
+        with tempfile.TemporaryDirectory() as directory:
+            source = Path(directory)
+            build = source / "build"
+            (source / "probe.cpp").write_text("int probe() { return 0; }\n")
+            (source / "CMakeLists.txt").write_text(
+                """cmake_minimum_required(VERSION 3.24)
+project(TorchCpuLibraryProbe LANGUAGES CXX)
+include("${EXECUTORCH_ROOT}/tools/cmake/Utils.cmake")
+find_package_torch()
+add_library(links_torch OBJECT probe.cpp)
+target_link_libraries(links_torch PRIVATE torch)
+add_library(links_torch_cpu_library OBJECT probe.cpp)
+target_link_libraries(links_torch_cpu_library PRIVATE torch_cpu_library)
+add_library(links_it_publicly STATIC probe.cpp)
+target_link_libraries(links_it_publicly PUBLIC torch_cpu_library)
+add_library(consumer OBJECT probe.cpp)
+target_link_libraries(consumer PRIVATE links_it_publicly)
+"""
+            )
+            result = subprocess.run(
+                [
+                    cmake,
+                    "-S",
+                    str(source),
+                    "-B",
+                    str(build),
+                    f"-DEXECUTORCH_ROOT={ROOT}",
+                    f"-DPYTHON_EXECUTABLE={sys.executable}",
+                    "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+                    # Recent torch sets no TORCH_CXX_FLAGS, so set one to check it travels too.
+                    "-DTORCH_CXX_FLAGS=-DET_TORCH_CXX_FLAGS_PROBE",
+                ],
+                capture_output=True,
+                text=True,
+            )
+            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+
+            flags = {}
+            for entry in json.loads((build / "compile_commands.json").read_text()):
+                target = Path(entry["output"]).parent.name.removesuffix(".dir")
+                flags[target] = _compile_flags(entry)
+            for target in ("links_torch_cpu_library", "links_it_publicly", "consumer"):
+                self.assertEqual(flags[target], flags["links_torch"], target)
+
+
+if __name__ == "__main__":
+    unittest.main()

tools/cmake/Utils.cmake

@@ -277,6 +277,22 @@ macro(find_package_torch)
   if(NOT TARGET torch)
     add_torch_to_cmake_prefix_path()
     find_package(Torch CONFIG REQUIRED)
+    # TorchConfig gives its include dirs, compile flags and C++ standard to
+    # torch only. Our targets link torch_cpu_library instead, so copy them over
+    # and those targets compile as if they linked torch.
+    foreach(_torch_property
+            INTERFACE_INCLUDE_DIRECTORIES INTERFACE_COMPILE_OPTIONS
+            INTERFACE_COMPILE_FEATURES
+    )
+      get_target_property(_torch_value torch ${_torch_property})
+      if(_torch_value)
+        set_property(
+          TARGET torch_cpu_library
+          APPEND
+          PROPERTY ${_torch_property} ${_torch_value}
+        )
+      endif()
+    endforeach()
   endif()
 endmacro()