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. It does this
once, also when the project found torch before calling it. Every target
that links torch_cpu_library, directly or through a PUBLIC link such as
custom_ops_aot_lib, now gets these settings, and a new link site cannot
forget them. With a CUDA build of PyTorch, torch also carries the CUDA
include directory and definitions of torch_cuda_library. Those are not
copied, since these targets do not use CUDA.

A new test configures a small project and checks that a target linking
torch_cpu_library, directly or through a PUBLIC link, gets torch's C++
API include directory, TORCH_CXX_FLAGS and C++ standard. It checks both
when find_package_torch finds torch and when the project found it first.
It passes with CPU and CUDA builds of torch and fails without this
change.

Author: shoumikhin

.ci/scripts/tests/test_torch_cpu_library_cmake.py

@@ -0,0 +1,114 @@
+# 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
+
+
+def _copied_from_torch(flag: str) -> bool:
+    """Whether a flag comes from what find_package_torch copies from torch.
+
+    A CUDA build of torch also gives torch the CUDA toolkit include dir and torch_cuda's
+    definitions, which torch_cpu_library correctly does not carry.
+    """
+    return (
+        flag == "-DET_TORCH_CXX_FLAGS_PROBE"
+        or flag.startswith("-std=")
+        or (flag.startswith("-isystem ") and flag.endswith("torch/csrc/api/include"))
+    )
+
+
+@unittest.skipIf(sys.platform == "win32", "Visual Studio writes no compile commands")
+class TestTorchCpuLibraryCMake(unittest.TestCase):
+    def test_torch_cpu_library_gets_torch_settings(self):
+        cmake = shutil.which("cmake")
+        if cmake is None or importlib.util.find_spec("torch") is None:
+            self.skipTest("CMake and torch are required")
+
+        found_first = (
+            "add_torch_to_cmake_prefix_path()\nfind_package(Torch CONFIG REQUIRED)"
+        )
+        for find_torch in ("", found_first):
+            with self.subTest(found_first=bool(find_torch)):
+                self._check(cmake, find_torch)
+
+    def _check(self, cmake: str, find_torch: str) -> None:
+        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(
+                f"""cmake_minimum_required(VERSION 3.24)
+project(TorchCpuLibraryProbe LANGUAGES CXX)
+include("${{EXECUTORCH_ROOT}}/tools/cmake/Utils.cmake")
+{find_torch}
+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)
+            expected = {
+                flag for flag in flags["links_torch"] if _copied_from_torch(flag)
+            }
+            self.assertIn("-DET_TORCH_CXX_FLAGS_PROBE", expected)
+            self.assertTrue(any(flag.startswith("-isystem ") for flag in expected))
+            for target in ("links_torch_cpu_library", "links_it_publicly", "consumer"):
+                self.assertEqual(expected - flags[target], set(), target)
+
+
+if __name__ == "__main__":
+    unittest.main()

tools/cmake/Utils.cmake

@@ -278,6 +278,30 @@ macro(find_package_torch)
     add_torch_to_cmake_prefix_path()
     find_package(Torch CONFIG REQUIRED)
   endif()
+  # TorchConfig gives its include dirs, compile flags and C++ standard to torch
+  # only. Our targets link torch_cpu_library instead, so copy them there once,
+  # also when the project found torch before calling this.
+  get_target_property(
+    _torch_settings_copied torch_cpu_library EXECUTORCH_TORCH_SETTINGS_COPIED
+  )
+  if(NOT _torch_settings_copied)
+    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()
+    set_property(
+      TARGET torch_cpu_library PROPERTY EXECUTORCH_TORCH_SETTINGS_COPIED TRUE
+    )
+  endif()
 endmacro()
 
 # Modify ${targetName}'s INTERFACE_INCLUDE_DIRECTORIES by wrapping each entry in