diff --git a/tools/cmake/BUILD b/tools/cmake/BUILD index bfc1db6fe..124a43735 100644 --- a/tools/cmake/BUILD +++ b/tools/cmake/BUILD @@ -23,9 +23,11 @@ SRCS = [ "bazel_to_cmake/bzl_library/third_party_http_archive.py", "bazel_to_cmake/bzl_library/upb_proto_library.py", "bazel_to_cmake/cmake_builder.py", + "bazel_to_cmake/cmake_provider.py", "bazel_to_cmake/cmake_repository_test.py", "bazel_to_cmake/cmake_repository.py", "bazel_to_cmake/cmake_target.py", + "bazel_to_cmake/emit_alias.py", "bazel_to_cmake/emit_cc_test.py", "bazel_to_cmake/emit_cc.py", "bazel_to_cmake/emit_filegroup.py", @@ -42,6 +44,7 @@ SRCS = [ "bazel_to_cmake/native_rules.py", "bazel_to_cmake/package.py", "bazel_to_cmake/platforms.py", + "bazel_to_cmake/provider_util.py", "bazel_to_cmake/starlark/__init__.py", "bazel_to_cmake/starlark/bazel_build_file.py", "bazel_to_cmake/starlark/bazel_glob_test.py", diff --git a/tools/cmake/bazel_to_cmake/bzl_library/bazel_skylib.py b/tools/cmake/bazel_to_cmake/bzl_library/bazel_skylib.py index f3975d2f3..b099c043a 100644 --- a/tools/cmake/bazel_to_cmake/bzl_library/bazel_skylib.py +++ b/tools/cmake/bazel_to_cmake/bzl_library/bazel_skylib.py @@ -15,13 +15,15 @@ # pylint: disable=invalid-name,relative-beyond-top-level,missing-function-docstring,missing-class-docstring,g-long-lambda +import itertools import json import pathlib from typing import Any, Dict, List, Optional, Tuple, TypeVar, Union, cast from .. import native_rules_genrule from ..cmake_builder import CMakeBuilder -from ..cmake_target import CMakeAddDependenciesProvider +from ..cmake_provider import CMakeAddDependenciesProvider +from ..cmake_provider import default_providers from ..cmake_target import CMakeTarget from ..evaluation import EvaluationState from ..starlark.bazel_globals import BazelGlobals @@ -43,6 +45,7 @@ from ..util import quote_string from ..util import write_file_if_not_already_equal + T = TypeVar("T") @@ -189,10 +192,17 @@ def _expand_template_impl( cast(RelativeLabel, _context.evaluate_configurable(template)) ) - deps: List[CMakeTarget] = [] - template_paths = state.get_file_paths([resolved_template], deps) + template_collector = state.collect_targets([resolved_template]) + + add_dependencies: set[CMakeTarget] = set( + itertools.chain( + template_collector.add_dependencies(), + template_collector.file_paths(), + ) + ) + template_paths = list(template_collector.file_paths()) + assert len(template_paths) == 1, f"For {template_collector}" - assert len(template_paths) == 1 template_path = template_paths[0] script_path = pathlib.PurePath(__file__).parent.joinpath("expand_template.py") @@ -205,25 +215,27 @@ def _expand_template_impl( subs_path, json.dumps(_context.evaluate_configurable(substitutions)).encode("utf-8"), ) - deps.append(CMakeTarget(template_path)) - deps.append(CMakeTarget(script_path.as_posix())) - deps.append(CMakeTarget(subs_path.as_posix())) + add_dependencies.add(CMakeTarget(template_path)) + add_dependencies.add(CMakeTarget(script_path.as_posix())) + add_dependencies.add(CMakeTarget(subs_path.as_posix())) builder: CMakeBuilder = _context.access(CMakeBuilder) builder.addtext(f""" +# expand_template({_target.as_label()}) add_custom_command( OUTPUT {quote_path(out_file)} COMMAND ${{Python3_EXECUTABLE}} {quote_path(script_path)} {quote_path(template_path)} {quote_path(subs_path)} {quote_path(out_file)} -DEPENDS {quote_list(deps)} +DEPENDS {quote_list(sorted(add_dependencies))} VERBATIM ) add_custom_target({cmake_target_pair.target} DEPENDS {quote_path(out_file)}) """) _context.add_analyzed_target( - _target, TargetInfo(*cmake_target_pair.as_providers()) + _target, + TargetInfo(*default_providers(cmake_target_pair)), ) diff --git a/tools/cmake/bazel_to_cmake/bzl_library/grpc_generate_cc.py b/tools/cmake/bazel_to_cmake/bzl_library/grpc_generate_cc.py index dca17b6ad..7da550391 100644 --- a/tools/cmake/bazel_to_cmake/bzl_library/grpc_generate_cc.py +++ b/tools/cmake/bazel_to_cmake/bzl_library/grpc_generate_cc.py @@ -14,15 +14,16 @@ """CMake implementation of "@tensorstore//bazel:cc_grpc_library.bzl".""" # pylint: disable=invalid-name,missing-function-docstring,relative-beyond-top-level,g-long-lambda +import io +import pathlib from typing import Any, List, Optional, cast from ..cmake_builder import CMakeBuilder -from ..cmake_target import CMakeAddDependenciesProvider -from ..cmake_target import CMakeLinkLibrariesProvider -from ..cmake_target import CMakeTarget +from ..cmake_provider import CMakeAddDependenciesProvider +from ..cmake_provider import default_providers from ..evaluation import EvaluationState from ..native_aspect_proto import btc_protobuf -from ..native_aspect_proto import get_aspect_dep +from ..native_aspect_proto import plugin_generated_files from ..native_aspect_proto import PluginSettings from ..starlark.bazel_globals import BazelGlobals from ..starlark.bazel_globals import register_bzl_library @@ -34,8 +35,8 @@ from ..starlark.invocation_context import RelativeLabel from ..starlark.provider import TargetInfo from ..starlark.select import Configurable - -from .upb_proto_library import UPB_REPO # pylint: disable=unused-import +from ..util import quote_path_list +from .upb_proto_library import UPB_PLUGIN # pylint: disable=unused-import GRPC_REPO = RepositoryId("com_github_grpc_grpc") @@ -49,6 +50,7 @@ def _empty_target_list(t: TargetId) -> List[TargetId]: _GRPC = PluginSettings( name="grpc", + language="grpc", plugin=GRPC_REPO.parse_target("//src/compiler:grpc_cpp_plugin"), exts=[".grpc.pb.h", ".grpc.pb.cc"], runtime=[GRPC_REPO.parse_target("//:grpc++_codegen_proto")], @@ -92,6 +94,17 @@ def _generate_grpc_cc_impl( ): del kwargs state = _context.access(EvaluationState) + repo = state.workspace.all_repositories.get( + _context.caller_package_id.repository_id + ) + assert repo is not None + + # Only a single source is allowed. + resolved_srcs = _context.resolve_target_or_label_list( + _context.evaluate_configurable_list(srcs) + ) + assert len(resolved_srcs) == 1 + proto_target = resolved_srcs[0] plugin_settings = _GRPC if plugin is not None: @@ -100,79 +113,91 @@ def _generate_grpc_cc_impl( ) plugin_settings = PluginSettings( name=_GRPC.name, + language=_GRPC.language, plugin=resolved_plugin, exts=_GRPC.exts, runtime=_GRPC.runtime, aspectdeps=_empty_target_list, ) - assert plugin_settings.plugin is not None - cmake_target_pair = state.generate_cmake_target_pair(_target, alias=False) + proto_target_info = _context.get_target_info(proto_target) + proto_library_provider = proto_target_info.get(ProtoLibraryProvider) + assert proto_library_provider is not None - # Only a single source is allowed. - resolved_srcs = _context.resolve_target_or_label_list( - _context.evaluate_configurable_list(srcs) - ) - assert len(resolved_srcs) == 1 - proto_library_target = resolved_srcs[0] + cmake_target_pair = state.generate_cmake_target_pair(_target, alias=False) # Construct the generated paths, installing this rule as a dependency. # TODO: Handle skip_import_prefix? - generated_paths = [] - cmake_deps: List[CMakeTarget] = [ - get_aspect_dep( - _context, - proto_library_target.get_target_id( - f"{proto_library_target.target_name}__upb_library" - ), - ) - ] - proto_target_info = _context.get_target_info(proto_library_target) - proto_provider = proto_target_info.get(ProtoLibraryProvider) - assert proto_provider is not None + proto_cmake_target = state.generate_cmake_target_pair( + proto_library_provider.bazel_target + ).target + + import_targets = set( + state.collect_deps(proto_library_provider.deps).link_libraries() + ) + import_targets.add(proto_cmake_target) # Emit the generated files. # See also native_aspect_proto.py - repo = state.workspace.all_repositories.get( - _context.caller_package_id.repository_id - ) - assert repo is not None - for src in proto_provider.srcs: - assert src.target_name.endswith( - ".proto" - ), f"{src.as_label()} must end in .proto" - target_name = src.target_name.removesuffix(".proto") - for ext in plugin_settings.exts: - generated_target = src.get_target_id(f"{target_name}{ext}") - generated_path = generated_target.as_rooted_path(repo.cmake_binary_dir) + generated_files = [] + for src in proto_library_provider.srcs: + for t in plugin_generated_files( + src, + plugin_settings, + repo.cmake_binary_dir, + ): _context.add_analyzed_target( - generated_target, + t[0], TargetInfo( - FilesProvider([str(generated_path)]), CMakeAddDependenciesProvider(cmake_target_pair.target), + FilesProvider([t[1]]), ), ) - generated_paths.append(generated_path) - + generated_files.append(t[1]) _context.add_analyzed_target( _target, TargetInfo( - *cmake_target_pair.as_providers(), FilesProvider(generated_paths) + *default_providers(cmake_target_pair), + FilesProvider(generated_files), ), ) - out = btc_protobuf( + src_collector = state.collect_targets(proto_library_provider.srcs) + state.collect_deps(UPB_PLUGIN.aspectdeps(resolved_srcs[0])) + + # Augment output with strip import prefix + output_dir = repo.cmake_binary_dir + if proto_library_provider.strip_import_prefix: + include_path = str( + pathlib.PurePosixPath(_context.caller_package_id.package_name).joinpath( + proto_library_provider.strip_import_prefix + ) + ) + if include_path[0] == "/": + include_path = include_path[1:] + output_dir = output_dir.joinpath(include_path) + + # Emit. + out = io.StringIO() + out.write(f"\n# {_target.as_label()}") + + btc_protobuf( _context, - cmake_target_pair.target, - proto_target_info.get(CMakeLinkLibrariesProvider).target, - plugin_settings, - cmake_deps=cmake_deps, + out, + plugin_settings=plugin_settings, + # varname=str(cmake_target_pair.target), + proto_src=next(src_collector.file_paths()), + generated_files=generated_files, + import_targets=import_targets, + cmake_depends=set(src_collector.add_dependencies()), flags=flags, + output_dir=repo.replace_with_cmake_macro_dirs([output_dir])[0], + ) + sep = "\n " + + out.write( + f"add_custom_target({cmake_target_pair.target} DEPENDS\n" + f" {quote_path_list(generated_files, separator=sep)})\n" ) - builder = _context.access(CMakeBuilder) - builder.addtext(f""" -# {_target.as_label()} -add_custom_target({cmake_target_pair.target}) -{out} -""") + _context.access(CMakeBuilder).addtext(out.getvalue()) diff --git a/tools/cmake/bazel_to_cmake/bzl_library/local_mirror.py b/tools/cmake/bazel_to_cmake/bzl_library/local_mirror.py index 42a3bc286..3955ce251 100644 --- a/tools/cmake/bazel_to_cmake/bzl_library/local_mirror.py +++ b/tools/cmake/bazel_to_cmake/bzl_library/local_mirror.py @@ -25,6 +25,7 @@ from ..cmake_builder import LOCAL_MIRROR_DOWNLOAD_SECTION from ..cmake_repository import CMakeRepository from ..cmake_repository import make_repo_mapping +from ..cmake_target import CMakePackage from ..evaluation import EvaluationState from ..starlark.bazel_globals import BazelGlobals from ..starlark.bazel_globals import register_bzl_library @@ -53,7 +54,7 @@ def _local_mirror_impl( state = _context.access(EvaluationState) - cmake_name: str = kwargs["cmake_name"] + cmake_name = CMakePackage(kwargs["cmake_name"]) repository_id = RepositoryId(kwargs["name"]) new_repository = CMakeRepository( repository_id=repository_id, diff --git a/tools/cmake/bazel_to_cmake/bzl_library/rules_nasm.py b/tools/cmake/bazel_to_cmake/bzl_library/rules_nasm.py index 077c0df6d..677cf5aa8 100644 --- a/tools/cmake/bazel_to_cmake/bzl_library/rules_nasm.py +++ b/tools/cmake/bazel_to_cmake/bzl_library/rules_nasm.py @@ -16,12 +16,15 @@ # pylint: disable=relative-beyond-top-level,invalid-name,missing-function-docstring,missing-class-docstring import hashlib +import io import os import pathlib -from typing import List, Optional, cast +from typing import Iterable, List, Optional, cast from ..cmake_builder import CMakeBuilder +from ..cmake_provider import default_providers from ..cmake_target import CMakeTarget +from ..emit_alias import emit_library_alias from ..evaluation import EvaluationState from ..starlark.bazel_globals import BazelGlobals from ..starlark.bazel_globals import register_bzl_library @@ -37,6 +40,16 @@ from ..util import quote_string +_EMIT_YASM_CHECK = """ +get_filename_component(_nasm_compiler_barename "${CMAKE_ASM_NASM_COMPILER}" NAME) +if (_nasm_compiler_barename STREQUAL "yasm") + message(WARNING "CMake found YASM assembler. Please install 'nasm' instead.") +endif() +unset(_nasm_compiler_barename) + +""" + + @register_bzl_library("@tensorstore//bazel:rules_nasm.bzl", build=True) class RulesNasmLibrary(BazelGlobals): @@ -47,6 +60,7 @@ def bazel_nasm_library( **kwargs, ): context = self._context.snapshot() + target = context.resolve_target(name) context.add_rule( target, @@ -57,7 +71,7 @@ def bazel_nasm_library( def _nasm_includes( _context: InvocationContext, - resolved_includes: List[TargetId], + resolved_includes: Iterable[TargetId], cmake_deps: List[CMakeTarget], ) -> set[str]: state = _context.access(EvaluationState) @@ -78,8 +92,10 @@ def _nasm_includes( relative_target = include_target_str[len(package_prefix_str) :].replace( ":", "/" ) + collector = state.collect_targets([include_target]) + cmake_deps.extend(collector.add_dependencies()) - for include_file in state.get_file_paths([include_target], cmake_deps): + for include_file in collector.file_paths(): all_includes.add(str(pathlib.PurePosixPath(include_file).parent)) if relative_target and include_file.endswith(relative_target): all_includes.add(include_file[: -len(relative_target)].rstrip("/")) @@ -110,7 +126,8 @@ def _nasm_library_impl( resolved_includes = _context.resolve_target_or_label_list( _context.evaluate_configurable_list(includes or []) ) - src_files = set(state.get_file_paths(resolved_srcs, cmake_deps)) + + srcs_collector = state.collect_targets(resolved_srcs) use_builtin_rule = True @@ -136,43 +153,48 @@ def _nasm_library_impl( or not use_builtin_rule ): placeholder_source = state.get_placeholder_source() + + # Emit + out = io.StringIO() + out.write(f"\n# nasm_library({_target.as_label()})\n") _emit_nasm_library( - _context.access(CMakeBuilder), + out, target_name=cmake_target_pair.target, - alias_name=cmake_target_pair.alias, cmake_deps=cmake_deps, - srcs=src_files, + srcs=set(srcs_collector.file_paths()), flags=resolved_flags, includes=_nasm_includes(_context, resolved_includes, cmake_deps), - alwayslink=alwayslink, placeholder_source=placeholder_source, use_builtin_rule=use_builtin_rule, ) - _context.add_analyzed_target( - _target, TargetInfo(*cmake_target_pair.as_providers()) - ) - + extra_providers = () + if cmake_target_pair.alias: + extra_providers = emit_library_alias( + out, + target_name=cmake_target_pair.target, + alias_name=cmake_target_pair.alias, + alwayslink=alwayslink, + interface_only=False, + ) -_EMIT_YASM_CHECK = """ -get_filename_component(_nasm_compiler_barename "${CMAKE_ASM_NASM_COMPILER}" NAME) -if (_nasm_compiler_barename STREQUAL "yasm") - message(WARNING "CMake found YASM assembler. Please install 'nasm' instead.") -endif() -unset(_nasm_compiler_barename) + builder = _context.access(CMakeBuilder) + builder.addtext(_EMIT_YASM_CHECK, unique=True) + builder.addtext(out.getvalue()) -""" + _context.add_analyzed_target( + _target, + TargetInfo(*default_providers(cmake_target_pair), *extra_providers), + ) def _emit_nasm_library( - _builder: CMakeBuilder, + out: io.StringIO, target_name: CMakeTarget, - alias_name: Optional[CMakeTarget], cmake_deps: List[CMakeTarget], srcs: set[str], includes: set[str], flags: List[str], placeholder_source: Optional[str], - alwayslink: bool, use_builtin_rule: bool, ): """Generates an NASM library target.""" @@ -180,20 +202,22 @@ def _emit_nasm_library( placeholder_sources = ( [placeholder_source] if placeholder_source is not None else [] ) - _builder.addtext(f"add_library({target_name})\n") + + _sep = "\n " + + out.write(f"add_library({target_name})\n") if use_builtin_rule: - _builder.addtext(_EMIT_YASM_CHECK, unique=True) - _builder.addtext( - f"""target_sources({target_name} PRIVATE {quote_list(all_srcs + placeholder_sources)}) -target_include_directories({target_name} PRIVATE {quote_list(sorted(includes))}) + out.write( + f"""target_sources({target_name} PRIVATE {quote_list(all_srcs + placeholder_sources, separator=_sep)}) +target_include_directories({target_name} PRIVATE {quote_list(sorted(includes), separator=_sep)}) set_source_files_properties( - {quote_list(all_srcs)} + {quote_list(all_srcs, separator=_sep)} PROPERTIES LANGUAGE ASM_NASM COMPILE_OPTIONS {quote_string(";".join(flags))})\n""" ) if cmake_deps: - _builder.addtext( + out.write( f"add_dependencies({target_name} {quote_list(sorted(cmake_deps))})\n" ) else: @@ -209,7 +233,7 @@ def _emit_nasm_library( ) src_obj_expr = f"${{CMAKE_CURRENT_BINARY_DIR}}/{src_obj_base}${{CMAKE_C_OUTPUT_EXTENSION}}" all_src_obj_exprs.append(src_obj_expr) - _builder.addtext(f""" + out.write(f""" add_custom_command( OUTPUT {quote_string(src_obj_expr)} DEPENDS {quote_path_list(all_srcs + cast(List[str], cmake_deps))} @@ -221,14 +245,7 @@ def _emit_nasm_library( -o {quote_string(src_obj_expr)} ) """) - - _builder.addtext( - f"""target_sources({target_name} PRIVATE {quote_list(all_src_obj_exprs + placeholder_sources)})\n""" - ) - if alias_name: - _builder.add_library_alias( - target_name=target_name, - alias_name=alias_name, - alwayslink=alwayslink, - interface_only=False, + out.write( + f"target_sources({target_name} PRIVATE\n" + f"{_sep}{quote_list(all_src_obj_exprs + placeholder_sources, separator=_sep)})\n" ) diff --git a/tools/cmake/bazel_to_cmake/bzl_library/third_party_http_archive.py b/tools/cmake/bazel_to_cmake/bzl_library/third_party_http_archive.py index d2e477954..690bbdb14 100644 --- a/tools/cmake/bazel_to_cmake/bzl_library/third_party_http_archive.py +++ b/tools/cmake/bazel_to_cmake/bzl_library/third_party_http_archive.py @@ -214,6 +214,7 @@ from ..cmake_repository import CMakeRepository from ..cmake_repository import label_to_generated_cmake_target from ..cmake_repository import make_repo_mapping +from ..cmake_target import CMakePackage from ..cmake_target import CMakeTarget from ..evaluation import EvaluationState from ..starlark.bazel_globals import BazelGlobals @@ -445,7 +446,7 @@ def _third_party_http_archive_impl(_context: InvocationContext, **kwargs): state.active_repo.repository.cmake_binary_dir.joinpath("_deps") ) - cmake_name: str = kwargs["cmake_name"] + cmake_name = CMakePackage(kwargs["cmake_name"]) repository_id = RepositoryId(kwargs["name"]) new_repository = CMakeRepository( repository_id=repository_id, diff --git a/tools/cmake/bazel_to_cmake/bzl_library/upb_proto_library.py b/tools/cmake/bazel_to_cmake/bzl_library/upb_proto_library.py index 810d48843..4d009b1e8 100644 --- a/tools/cmake/bazel_to_cmake/bzl_library/upb_proto_library.py +++ b/tools/cmake/bazel_to_cmake/bzl_library/upb_proto_library.py @@ -80,6 +80,7 @@ def _upbdefs_target(t: TargetId) -> List[TargetId]: _UPB_MINITABLE = PluginSettings( name="upb_minitable", + language="upb_minitable", plugin=UPB_REPO.parse_target( "//upb_generator:protoc-gen-upb_minitable_stage1" ), @@ -92,21 +93,11 @@ def _upbdefs_target(t: TargetId) -> List[TargetId]: aspectdeps=_minitable_target, ) -_UPB = PluginSettings( - name="upb", - plugin=UPB_REPO.parse_target("//upb_generator:protoc-gen-upb"), - exts=[".upb.h", ".upb.c"], - runtime=[ - UPB_REPO.parse_target( - "//upb:generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - ), - ], - aspectdeps=_upb_target, -) # STAGE1 is used for bootstrapping upb via cmake. _UPB_STAGE1 = PluginSettings( name="upb", + language="upb", plugin=UPB_REPO.parse_target("//upb_generator:protoc-gen-upb_stage1"), exts=[".upb.h", ".upb.c"], runtime=[ @@ -120,6 +111,7 @@ def _upbdefs_target(t: TargetId) -> List[TargetId]: _UPBDEFS = PluginSettings( name="upbdefs", + language="upbdefs", plugin=UPB_REPO.parse_target("//upb_generator:protoc-gen-upbdefs"), exts=[".upbdefs.h", ".upbdefs.c"], runtime=[ @@ -131,6 +123,19 @@ def _upbdefs_target(t: TargetId) -> List[TargetId]: aspectdeps=_upbdefs_target, ) +UPB_PLUGIN = PluginSettings( + name="upb", + language="upb", + plugin=UPB_REPO.parse_target("//upb_generator:protoc-gen-upb"), + exts=[".upb.h", ".upb.c"], + runtime=[ + UPB_REPO.parse_target( + "//upb:generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" + ), + ], + aspectdeps=_upb_target, +) + def upb_minitable_aspect( context: InvocationContext, @@ -158,7 +163,7 @@ def upb_aspect( visibility: Optional[List[RelativeLabel]] = None, **kwargs, ): - plugin = _UPB + plugin = UPB_PLUGIN if proto_target.repository_id == UPB_REPO: plugin = _UPB_STAGE1 diff --git a/tools/cmake/bazel_to_cmake/cmake_provider.py b/tools/cmake/bazel_to_cmake/cmake_provider.py new file mode 100644 index 000000000..5ab27671a --- /dev/null +++ b/tools/cmake/bazel_to_cmake/cmake_provider.py @@ -0,0 +1,133 @@ +# Copyright 2022 The TensorStore Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""CMake Provider types. + +These providers are the primary way in which bazel_to_cmake references +bazel build targets. +""" + +from typing import Tuple, Union + +from .cmake_target import CMakePackage +from .cmake_target import CMakeTarget +from .cmake_target import CMakeTargetPair +from .starlark.provider import Provider + + +class CMakeHallucinatedTarget(Provider): + """CMake target corresponding to an unknown Bazel target.""" + + __slots__ = ("target",) + + def __init__(self, target: CMakeTarget): + assert isinstance(target, CMakeTarget), f"{repr(target)}" + self.target = target + + def __repr__(self): + return f"{self.__class__.__name__}({repr(self.target)})" + + +class CMakePackageDepsProvider(Provider): + """CMake packages required by a Bazel target.""" + + __slots__ = ("package",) + + def __init__(self, package: CMakePackage): + assert isinstance(package, CMakePackage), f"{repr(package)}" + self.package = package + + def __repr__(self): + return f"{self.__class__.__name__}({repr(self.package)})" + + +class CMakeAddDependenciesProvider(Provider): + """CMake add_dependencies required by a Bazel target.""" + + __slots__ = ("target",) + + def __init__(self, target: CMakeTarget): + assert isinstance(target, CMakeTarget), f"{repr(target)}" + self.target = target + + def __repr__(self): + return f"{self.__class__.__name__}({repr(self.target)})" + + +class CMakeLinkLibrariesProvider(Provider): + """CMake link_libraries required by a Bazel target.""" + + __slots__ = ("target",) + + def __init__(self, target: CMakeTarget): + assert isinstance(target, CMakeTarget), f"{repr(target)}" + self.target = target + + def __repr__(self): + return f"{self.__class__.__name__}({repr(self.target)})" + + +class CMakeExecutableTargetProvider(Provider): + """CMake target corresponding to a Bazel executable target.""" + + __slots__ = ("target",) + + def __init__(self, target: CMakeTarget): + assert isinstance(target, CMakeTarget), f"{repr(target)}" + self.target = target + + def __repr__(self): + return f"{self.__class__.__name__}({repr(self.target)})" + + +class CMakeAliasProvider(Provider): + """Indicates that this target is aliased to another target.""" + + __slots__ = ("target",) + + def __init__(self, target: CMakeTarget): + assert isinstance(target, CMakeTarget), f"{repr(target)}" + self.target = target + + def __repr__(self): + return f"{self.__class__.__name__}({repr(self.target)})" + + +def make_providers( + source: Union[CMakeTarget, CMakeTargetPair], *providers +) -> Tuple[Provider, ...]: + """Construct providers from a CMakeTarget or CMakeTargetPair.""" + result = () + if isinstance(source, CMakeTargetPair): + if CMakePackageDepsProvider in providers: + result += (CMakePackageDepsProvider(source.cmake_package),) + source = source.dep + + if isinstance(source, CMakeTarget): + if CMakeAddDependenciesProvider in providers: + result += (CMakeAddDependenciesProvider(source),) + if CMakeLinkLibrariesProvider in providers: + result += (CMakeLinkLibrariesProvider(source),) + if CMakeExecutableTargetProvider in providers: + result += (CMakeExecutableTargetProvider(source),) + + assert result + return result + + +def default_providers(source: CMakeTargetPair) -> Tuple[Provider, ...]: + return make_providers( + source, + CMakePackageDepsProvider, + CMakeLinkLibrariesProvider, + ) diff --git a/tools/cmake/bazel_to_cmake/cmake_repository.py b/tools/cmake/bazel_to_cmake/cmake_repository.py index fefacfb74..e021ad29d 100644 --- a/tools/cmake/bazel_to_cmake/cmake_repository.py +++ b/tools/cmake/bazel_to_cmake/cmake_repository.py @@ -81,6 +81,13 @@ def set_persisted_canonical_name( generated automatically by bazel_to_cmake, and is set from the third_party_http_archive target_mapping setting. """ + assert isinstance( + cmake_target_pair, CMakeTargetPair + ), f"{repr(cmake_target_pair)}" + assert isinstance( + cmake_target_pair.cmake_package, CMakePackage + ), f"{repr(cmake_target_pair)}" + assert cmake_target_pair.cmake_package is not None assert cmake_target_pair.cmake_package == self.cmake_project_name assert target_id.repository_id == self.repository_id @@ -140,6 +147,7 @@ def label_to_generated_cmake_target( target_id: TargetId, cmake_project: CMakePackage ) -> CMakeTargetPair: """Computes the generated CMake target corresponding to a Bazel target.""" + assert isinstance(cmake_project, CMakePackage), f"{repr(cmake_project)}" parts: List[str] = [] parts.extend(x for x in _SPLIT_RE.split(target_id.package_name) if x) diff --git a/tools/cmake/bazel_to_cmake/cmake_target.py b/tools/cmake/bazel_to_cmake/cmake_target.py index 2b838a0ee..09948df1a 100644 --- a/tools/cmake/bazel_to_cmake/cmake_target.py +++ b/tools/cmake/bazel_to_cmake/cmake_target.py @@ -13,67 +13,15 @@ # limitations under the License. """CMake Provider types.""" -from typing import List, NamedTuple, NewType, Optional, Type, TypeVar +from typing import NamedTuple, Optional -from .starlark.provider import Provider -CMakePackage = NewType("CMakePackage", str) -CMakeTarget = NewType("CMakeTarget", str) +class CMakePackage(str): + pass -class CMakePackageDepsProvider(Provider): - """CMake packages required by a Bazel target.""" - - __slots__ = ("packages",) - - def __init__(self, packages: List[CMakePackage]): - self.packages = packages - - def __repr__(self): - return f"{self.__class__.__name__}({repr(self.packages)})" - - -class CMakeAddDependenciesProvider(Provider): - """CMake add_dependencies required by a Bazel target.""" - - __slots__ = ("target",) - - def __init__(self, target: CMakeTarget): - self.target = target - - def __repr__(self): - return f"{self.__class__.__name__}({repr(self.target)})" - - -class CMakeLinkLibrariesProvider(Provider): - """CMake link_libraries required by a Bazel target.""" - - __slots__ = ("target",) - - def __init__(self, target: CMakeTarget): - self.target = target - - def __repr__(self): - return f"{self.__class__.__name__}({repr(self.target)})" - - -class CMakeExecutableTargetProvider(Provider): - """CMake target corresponding to a Bazel executable target.""" - - __slots__ = ("target",) - - def __init__(self, target: CMakeTarget): - self.target = target - - def __repr__(self): - return f"{self.__class__.__name__}({repr(self.target)})" - - -AnyCMakeTargetProvider = TypeVar( - "AnyCMakeTargetProvider", - CMakeLinkLibrariesProvider, - CMakeExecutableTargetProvider, -) +class CMakeTarget(str): + pass class CMakeTargetPair(NamedTuple): @@ -84,23 +32,13 @@ class CMakeTargetPair(NamedTuple): alias: Optional[CMakeTarget] = None def with_alias(self, alias: Optional[CMakeTarget]) -> "CMakeTargetPair": + if alias is not None: + assert isinstance(alias, CMakeTarget) return self._replace(alias=alias) @property def dep(self) -> CMakeTarget: return self.alias or self.target - def as_providers( - self, - provider: Optional[ - Type[AnyCMakeTargetProvider] - ] = CMakeLinkLibrariesProvider, - ): - a = (provider(self.target),) if provider is not None else tuple() - return ( - CMakeAddDependenciesProvider(self.dep), - CMakePackageDepsProvider([self.cmake_package]), - ) + a - def __str__(self) -> str: raise NotImplementedError diff --git a/tools/cmake/bazel_to_cmake/emit_alias.py b/tools/cmake/bazel_to_cmake/emit_alias.py new file mode 100644 index 000000000..c6a5a6607 --- /dev/null +++ b/tools/cmake/bazel_to_cmake/emit_alias.py @@ -0,0 +1,45 @@ +# Copyright 2022 The TensorStore Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Emits a library alias.""" + +import io + +from .cmake_provider import CMakeAliasProvider +from .cmake_target import CMakeTarget +from .starlark.provider import ProviderTuple + + +def emit_library_alias( + out: io.StringIO, + target_name: CMakeTarget, + alias_name: CMakeTarget, + interface_only: bool = False, + alwayslink: bool = False, +) -> ProviderTuple: + """Generates an alias target with support for `alwayslink`.""" + alias_dest_name = target_name + if alwayslink and not interface_only: + alias_dest_name = CMakeTarget(f"{target_name}.alwayslink") + out.write(f""" +add_library({alias_dest_name} INTERFACE) +if (BUILD_SHARED_LIBS) + target_link_libraries({alias_dest_name} INTERFACE "$") +else () + target_link_libraries({alias_dest_name} INTERFACE "$") +endif() +""") + out.write(f"add_library({alias_name} ALIAS {alias_dest_name})\n") + if alias_dest_name != target_name: + return (CMakeAliasProvider(alias_dest_name),) + return tuple() diff --git a/tools/cmake/bazel_to_cmake/emit_cc.py b/tools/cmake/bazel_to_cmake/emit_cc.py index 23831f654..de822c5a1 100644 --- a/tools/cmake/bazel_to_cmake/emit_cc.py +++ b/tools/cmake/bazel_to_cmake/emit_cc.py @@ -15,23 +15,27 @@ # pylint: disable=relative-beyond-top-level,invalid-name,missing-function-docstring,g-long-lambda +import io +import itertools import pathlib -from typing import Any, Dict, Iterable, List, Optional, cast +from typing import Any, Collection, Dict, Iterable, List, Optional, cast -from .cmake_builder import CMakeBuilder from .cmake_repository import CMakeRepository from .cmake_repository import PROJECT_BINARY_DIR from .cmake_repository import PROJECT_SOURCE_DIR from .cmake_target import CMakeTarget from .cmake_target import CMakeTargetPair +from .emit_alias import emit_library_alias from .evaluation import EvaluationState from .starlark.bazel_target import PackageId +from .starlark.bazel_target import TargetId from .starlark.invocation_context import InvocationContext -from .starlark.label import RelativeLabel +from .starlark.provider import ProviderTuple from .starlark.select import Configurable from .util import is_relative_to from .util import make_relative_path from .util import partition_by +from .util import PathCollection from .util import quote_list from .util import quote_path_list from .util import quote_unescaped_list @@ -50,10 +54,10 @@ def default_asm_dialect(workspace: Workspace) -> str: def _emit_cc_common_options( - _builder: CMakeBuilder, + out: io.StringIO, target_name: str, asm_dialect: Optional[str] = None, - deps: Optional[Iterable[str]] = None, + link_libraries: Optional[Iterable[str]] = None, copts: Optional[Iterable[str]] = None, linkopts: Optional[Iterable[str]] = None, defines: Optional[Iterable[str]] = None, @@ -67,27 +71,28 @@ def _emit_cc_common_options( **kwargs, ): """Emits CMake rules for common C++ target options.""" + assert "deps" not in kwargs del kwargs public_context = "INTERFACE" if interface_only else "PUBLIC" if local_defines is not None and local_defines and not interface_only: - _builder.addtext( + out.write( f"target_compile_definitions({target_name} PRIVATE" f" {quote_unescaped_list(local_defines)})\n" ) if defines is not None and defines: - _builder.addtext( + out.write( f"target_compile_definitions({target_name} {public_context} {quote_unescaped_list(defines)})\n" ) if copts is not None and copts and not interface_only: - _builder.addtext( + out.write( f"target_compile_options({target_name} PRIVATE {quote_list(copts)})\n" ) - if deps or linkopts: + if link_libraries or linkopts: link_libs: List[str] = [] - if deps: - link_libs.extend(sorted(deps)) + if link_libraries: + link_libs.extend(sorted(link_libraries)) link_options: List[str] = [] for x in linkopts or []: @@ -96,11 +101,11 @@ def _emit_cc_common_options( else: link_options.append(x) if link_libs: - _builder.addtext( + out.write( f"target_link_libraries({target_name} {public_context}{_SEP}{quote_list(link_libs, separator=_SEP)})\n" ) if link_options: - _builder.addtext( + out.write( f"target_link_options({target_name} {public_context}{_SEP}{quote_list(link_options, separator=_SEP)})\n" ) @@ -109,7 +114,7 @@ def _emit_cc_common_options( for include_dir in sorted(set(includes)) ] if include_dirs: - _builder.addtext( + out.write( f"target_include_directories({target_name} {public_context}" f"{_SEP}{quote_path_list(include_dirs, separator=_SEP)})\n" ) @@ -119,49 +124,49 @@ def _emit_cc_common_options( for include_dir in sorted(set(private_includes)) ] if include_dirs: - _builder.addtext( + out.write( f"target_include_directories({target_name} PRIVATE" f"{_SEP}{quote_path_list(include_dirs, separator=_SEP)})\n" ) - _builder.addtext( + out.write( f"target_compile_features({target_name} {public_context} cxx_std_17)\n" ) if add_dependencies: - _builder.addtext( + out.write( f"add_dependencies({target_name} {quote_list(sorted(add_dependencies))})\n" ) if extra_public_compile_options: - _builder.addtext( + out.write( f"target_compile_options({target_name} {public_context} {quote_list(extra_public_compile_options)})\n" ) if srcs: - non_header_srcs = partition_by(*srcs, pattern=_HEADER_SRC_PATTERN)[1] - _builder.addtext( + non_header_srcs = partition_by(srcs, pattern=_HEADER_SRC_PATTERN)[1] + out.write( f"target_sources({target_name} PRIVATE{_SEP}{quote_path_list(non_header_srcs , separator=_SEP)})\n" ) - - asm_srcs = partition_by(*srcs, pattern=_ASM_SRC_PATTERN)[0] + asm_srcs = partition_by(non_header_srcs, pattern=_ASM_SRC_PATTERN)[0] if asm_srcs: if asm_dialect is None: raise ValueError( f"asm_dialect must be specified for ASM srcs: {asm_srcs!r}" ) - _builder.addtext(f"""set_source_files_properties( + out.write(f"""set_source_files_properties( {quote_path_list(asm_srcs)} PROPERTIES LANGUAGE {asm_dialect})\n""") def construct_cc_includes( - repo: CMakeRepository, current_package_id: PackageId, *, + source_directory: pathlib.PurePath, + cmake_binary_dir: pathlib.PurePath, includes: Optional[Configurable[List[str]]] = None, include_prefix: Optional[str] = None, strip_include_prefix: Optional[str] = None, - known_include_files: Optional[Iterable[str]] = None, -) -> List[str]: + known_include_files: Optional[PathCollection] = None, +) -> set[pathlib.PurePath]: """Returns the list of system includes for the configuration. By default Bazel generates private includes (-iquote) for the SRCDIR @@ -172,12 +177,10 @@ def construct_cc_includes( bazel flags, however it is a best effort technique which, so far, has met the needs of cmake translation. """ - assert repo is not None - if not known_include_files: + if known_include_files is None: known_include_files = [] - include_dirs = set() - + include_dirs: set[pathlib.PurePath] = set() current_package_path = pathlib.PurePosixPath(current_package_id.package_name) # This include manipulation is a best effort that works for known cases. @@ -207,8 +210,8 @@ def construct_cc_includes( if constructed[0] == "/": constructed = constructed[1:] - include_dirs.add(str(repo.source_directory.joinpath(constructed))) - include_dirs.add(str(repo.cmake_binary_dir.joinpath(constructed))) + include_dirs.add(source_directory.joinpath(constructed)) + include_dirs.add(cmake_binary_dir.joinpath(constructed)) # For the package foo/bar # - default include path is foo/bar/file.h @@ -234,8 +237,8 @@ def construct_cc_includes( else: constructed = str(current_package_path.joinpath(strip_include_prefix)) - src_path = repo.source_directory.joinpath(constructed) - bin_path = repo.cmake_binary_dir.joinpath(constructed) + src_path = source_directory.joinpath(constructed) + bin_path = cmake_binary_dir.joinpath(constructed) # Only add if existing files are discoverable at the prefix for x in known_include_files: (c, _) = make_relative_path(x, (src_path, src_path), (bin_path, bin_path)) @@ -257,8 +260,9 @@ def construct_cc_includes( # at the current package and trying to remove the prefix of the path, # thus omitting it from the C search path. constructed = current_package_id.package_name[: -len(include_prefix)] - src_path = repo.source_directory.joinpath(constructed) - bin_path = repo.cmake_binary_dir.joinpath(constructed) + + src_path = source_directory.joinpath(constructed) + bin_path = cmake_binary_dir.joinpath(constructed) # Only add if existing files are discoverable at the prefix for x in known_include_files: (c, _) = make_relative_path( @@ -270,14 +274,14 @@ def construct_cc_includes( # HACK: Bazel does not add such a fallback, but since three are potential # includes CMake needs to include SRC/BIN as interface includes. if not include_dirs: - src_path = repo.source_directory - bin_path = repo.cmake_binary_dir + src_path = source_directory + bin_path = cmake_binary_dir for x in known_include_files: (c, _) = make_relative_path(x, (src_path, src_path), (bin_path, bin_path)) if c is not None: include_dirs.add(c) - return sorted(repo.replace_with_cmake_macro_dirs(include_dirs)) + return include_dirs def construct_cc_private_includes( @@ -303,41 +307,47 @@ def construct_cc_private_includes( def handle_cc_common_options( _context: InvocationContext, src_required=False, - add_dependencies: Optional[List[CMakeTarget]] = None, - srcs: Optional[Configurable[List[RelativeLabel]]] = None, - deps: Optional[Configurable[List[RelativeLabel]]] = None, - includes: Optional[Configurable[List[str]]] = None, + add_dependencies: Optional[Collection[CMakeTarget]] = None, + srcs: Optional[Collection[TargetId]] = None, + deps: Optional[Collection[TargetId]] = None, + includes: Optional[Collection[TargetId]] = None, include_prefix: Optional[str] = None, strip_include_prefix: Optional[str] = None, - hdrs_file_paths: Optional[List[str]] = None, - textual_hdrs_file_paths: Optional[List[str]] = None, + hdrs_file_paths: Optional[Collection[str]] = None, + textual_hdrs_file_paths: Optional[Collection[str]] = None, + _source_directory: Optional[pathlib.PurePath] = None, + _cmake_binary_dir: Optional[pathlib.PurePath] = None, **kwargs, ) -> Dict[str, Any]: + state = _context.access(EvaluationState) + repo = state.workspace.all_repositories.get( + _context.caller_package_id.repository_id + ) + assert repo is not None + if add_dependencies is None: add_dependencies = [] - state = _context.access(EvaluationState) + if _source_directory is None: + _source_directory = repo.source_directory + if _cmake_binary_dir is None: + _cmake_binary_dir = repo.cmake_binary_dir - resolved_srcs = _context.resolve_target_or_label_list( - _context.evaluate_configurable_list(srcs) - ) - resolved_deps = _context.resolve_target_or_label_list( - _context.evaluate_configurable_list(deps) - ) - srcs_file_paths = [ - str(x) for x in state.get_file_paths(resolved_srcs, add_dependencies) - ] + srcs_collector = state.collect_targets(srcs) + srcs_file_paths = list(srcs_collector.file_paths()) if src_required and not srcs_file_paths: srcs_file_paths = [state.get_placeholder_source()] - cmake_deps = set(state.get_deps(resolved_deps)) + deps_collector = state.collect_deps(deps) + + link_libraries = set(deps_collector.link_libraries()) # Since Bazel implicitly adds a dependency on the C math library, also add # it here. if state.workspace.cmake_vars["CMAKE_SYSTEM_NAME"] != "Windows": - cmake_deps.add(CMakeTarget("m")) + link_libraries.add(CMakeTarget("m")) - cmake_deps.add(CMakeTarget("Threads::Threads")) + link_libraries.add(CMakeTarget("Threads::Threads")) extra_public_compile_options = [] @@ -350,15 +360,14 @@ def add_compile_options(lang: str, options: List[str]): add_compile_options("C,CXX", state.workspace.copts) add_compile_options("CXX", state.workspace.cxxopts) - repo = state.workspace.all_repositories.get( - _context.caller_package_id.repository_id - ) - assert repo is not None - result: Dict[str, Any] = { "srcs": repo.replace_with_cmake_macro_dirs(sorted(set(srcs_file_paths))), - "deps": cmake_deps, - "add_dependencies": set(add_dependencies), + "link_libraries": link_libraries, + "add_dependencies": set( + itertools.chain( + iter(add_dependencies), srcs_collector.add_dependencies() + ) + ), "extra_public_compile_options": extra_public_compile_options, "asm_dialect": default_asm_dialect(state.workspace), } @@ -378,18 +387,21 @@ def add_compile_options(lang: str, options: List[str]): ) known_include_files = ( - partition_by(*srcs_file_paths, pattern=_HEADER_SRC_PATTERN)[0] + partition_by(srcs_file_paths, pattern=_HEADER_SRC_PATTERN)[0] + (hdrs_file_paths or []) + (textual_hdrs_file_paths or []) ) - result["includes"] = construct_cc_includes( - repo, - _context.caller_package_id, - includes=_context.evaluate_configurable_list(includes), - include_prefix=include_prefix, - strip_include_prefix=strip_include_prefix, - known_include_files=known_include_files, + result["includes"] = repo.replace_with_cmake_macro_dirs( + construct_cc_includes( + _context.caller_package_id, + source_directory=_source_directory, + cmake_binary_dir=_cmake_binary_dir, + includes=includes, + include_prefix=include_prefix, + strip_include_prefix=strip_include_prefix, + known_include_files=known_include_files, + ) ) result["private_includes"] = construct_cc_private_includes( @@ -402,75 +414,87 @@ def add_compile_options(lang: str, options: List[str]): def emit_cc_library( - _builder: CMakeBuilder, + out: io.StringIO, _cmake_target_pair: CMakeTargetPair, - srcs: set[str], - hdrs: set[str], + *, + srcs: Collection[str], + hdrs: Iterable[str], alwayslink: bool = False, header_only: Optional[bool] = None, **kwargs, -): +) -> ProviderTuple: """Generates a C++ library target.""" if header_only is None: - header_only = not (partition_by(*srcs, pattern=_HEADER_SRC_PATTERN)[1]) + header_only = not (partition_by(srcs, pattern=_HEADER_SRC_PATTERN)[1]) del hdrs target_name = _cmake_target_pair.target assert target_name is not None if not header_only: - _builder.addtext(f""" + out.write(f""" add_library({target_name}) set_property(TARGET {target_name} PROPERTY LINKER_LANGUAGE "CXX") """) else: - _builder.addtext(f""" + out.write(f""" add_library({target_name} INTERFACE) """) _emit_cc_common_options( - _builder, + out, target_name=target_name, interface_only=header_only, srcs=sorted(srcs), **kwargs, ) if _cmake_target_pair.alias is not None: - _builder.add_library_alias( + return emit_library_alias( + out, target_name=target_name, alias_name=_cmake_target_pair.alias, alwayslink=alwayslink, interface_only=header_only, ) + return tuple() def emit_cc_binary( - _builder: CMakeBuilder, + out: io.StringIO, _cmake_target_pair: CMakeTargetPair, srcs: set[str], **kwargs, ): target_name = _cmake_target_pair.target assert _cmake_target_pair.alias is not None - _builder.addtext(f""" + + out.write(f""" add_executable({target_name} "") add_executable({_cmake_target_pair.alias} ALIAS {target_name}) """) _emit_cc_common_options( - _builder, target_name=target_name, srcs=sorted(srcs), **kwargs + out, target_name=target_name, srcs=sorted(srcs), **kwargs ) def emit_cc_test( - _builder: CMakeBuilder, + out: io.StringIO, _cmake_target_pair: CMakeTargetPair, args: Optional[List[str]] = None, + properties: Optional[Dict[str, str]] = None, **kwargs, ): - emit_cc_binary(_builder, _cmake_target_pair, **kwargs) + emit_cc_binary(out, _cmake_target_pair, **kwargs) target_name = _cmake_target_pair.target args_suffix = "" if args: args_suffix = " " + " ".join(args) - _builder.addtext( - f"""add_test(NAME {target_name} COMMAND {target_name}{args_suffix} WORKING_DIRECTORY ${{CMAKE_CURRENT_SOURCE_DIR}})\n""" + out.write( + f"add_test(NAME {target_name}\n" + f" COMMAND {target_name}{args_suffix}\n" + f" WORKING_DIRECTORY ${{CMAKE_CURRENT_SOURCE_DIR}})\n" ) + if properties: + out.write(f"set_tests_properties({target_name} PROPERTIES\n") + for k, v in properties.items(): + out.write(f" {k} {v}\n") + out.write(")\n") diff --git a/tools/cmake/bazel_to_cmake/emit_cc_test.py b/tools/cmake/bazel_to_cmake/emit_cc_test.py index f6dc10fe4..9db966dd2 100644 --- a/tools/cmake/bazel_to_cmake/emit_cc_test.py +++ b/tools/cmake/bazel_to_cmake/emit_cc_test.py @@ -16,45 +16,42 @@ # pylint: disable=g-importing-member import pathlib -from .cmake_repository import CMakeRepository -from .cmake_target import CMakePackage from .emit_cc import construct_cc_includes from .starlark.bazel_target import PackageId -from .starlark.bazel_target import RepositoryId -REPO = CMakeRepository( - RepositoryId("foo"), - CMakePackage("Foo"), - pathlib.PurePath("foo-srcdir"), - pathlib.PurePath("foo-bindir"), - {}, - {}, -) + +SRCDIR = pathlib.PurePath("foo-srcdir") +BINDIR = pathlib.PurePath("foo-bindir") + def test_construct_cc_includes_bare(): # No includes assert not construct_cc_includes( - REPO, PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, ) # Individual srcdir / bindir includes - assert ["${PROJECT_SOURCE_DIR}"] == construct_cc_includes( - REPO, + assert set([SRCDIR]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, known_include_files=["foo-srcdir/bar/a.inc"], ) - assert ["${PROJECT_BINARY_DIR}"] == construct_cc_includes( - REPO, + assert set([BINDIR]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, known_include_files=["foo-bindir/bar/b.inc"], ) # Other combinations - assert [ - "${PROJECT_BINARY_DIR}", - "${PROJECT_SOURCE_DIR}", - ] == construct_cc_includes( - REPO, + assert set([ + BINDIR, + SRCDIR, + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, known_include_files=[ "foo-srcdir/bar/e.inc", "foo-bindir/bar/ee.h", @@ -64,41 +61,45 @@ def test_construct_cc_includes_bare(): def test_construct_cc_includes_includes(): # includes does not test for file presence. - assert [ - "${PROJECT_BINARY_DIR}/bar", - "${PROJECT_SOURCE_DIR}/bar", - ] == construct_cc_includes( - REPO, + assert set([ + BINDIR.joinpath("bar"), + SRCDIR.joinpath("bar"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, includes=["."], ) # package-relative - assert [ - "${PROJECT_BINARY_DIR}/bar/includes", - "${PROJECT_SOURCE_DIR}/bar/includes", - ] == construct_cc_includes( - REPO, + assert set([ + BINDIR.joinpath("bar/includes"), + SRCDIR.joinpath("bar/includes"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, includes=["includes"], known_include_files=["foo-srcdir/includes/b.h"], ) - assert [ - "${PROJECT_BINARY_DIR}/bar/includes", - "${PROJECT_SOURCE_DIR}/bar/includes", - ] == construct_cc_includes( - REPO, + assert set([ + BINDIR.joinpath("bar/includes"), + SRCDIR.joinpath("bar/includes"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, includes=["includes"], known_include_files=["foo-srcdir/bar/includes/c.h"], ) # reposnitory-relative # bazel doesn't generate this one; it probably builds file symlinks. - assert [ - "${PROJECT_BINARY_DIR}/includes", - "${PROJECT_SOURCE_DIR}/includes", - ] == construct_cc_includes( - REPO, + assert set([ + BINDIR.joinpath("includes"), + SRCDIR.joinpath("includes"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, includes=["/includes"], known_include_files=["foo-srcdir/includes/a.h"], ) @@ -106,19 +107,21 @@ def test_construct_cc_includes_includes(): def test_construct_cc_includes_include_prefix(): # include_prefix really doesn't work for bazel_to_cmake. - assert [ - "${PROJECT_SOURCE_DIR}", - ] == construct_cc_includes( - REPO, + assert set([ + SRCDIR, + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, include_prefix="bar", known_include_files=["foo-srcdir/bar/x.h"], ) - assert [ - "${PROJECT_SOURCE_DIR}", - ] == construct_cc_includes( - REPO, + assert set([ + SRCDIR, + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, include_prefix="_mismatch_", known_include_files=["foo-srcdir/bar/y.h"], ) @@ -126,62 +129,69 @@ def test_construct_cc_includes_include_prefix(): def test_construct_cc_includes_strip_include_prefix(): # mismatched - assert [ - "${PROJECT_SOURCE_DIR}", - ] == construct_cc_includes( - REPO, + assert set([ + SRCDIR, + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="xyz", known_include_files=["foo-srcdir/bar/a.h"], ) - assert [ - "${PROJECT_BINARY_DIR}", - ] == construct_cc_includes( - repo=REPO, + assert set([ + BINDIR, + ]) == construct_cc_includes( + PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="xyz", - current_package_id=PackageId("foo", "bar"), known_include_files=["foo-bindir/bar/b.h"], ) # Respoitory relative - assert [ - "${PROJECT_SOURCE_DIR}/bar", - ] == construct_cc_includes( - REPO, + assert set([ + SRCDIR.joinpath("bar"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="/bar", known_include_files=["foo-srcdir/bar/c.h"], ) - assert [ - "${PROJECT_BINARY_DIR}/bar", - "${PROJECT_SOURCE_DIR}/bar", - ] == construct_cc_includes( - REPO, + assert set([ + BINDIR.joinpath("bar"), + SRCDIR.joinpath("bar"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="/bar", known_include_files=["foo-srcdir/bar/d.h", "foo-bindir/bar/dd.h"], ) - assert [ - "${PROJECT_SOURCE_DIR}/bar", - ] == construct_cc_includes( - REPO, + assert set([ + SRCDIR.joinpath("bar"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="/bar", known_include_files=["foo-srcdir/bar/e.inc", "foo-srcdir/bar/e.h"], ) # Package includes - assert [ - "${PROJECT_SOURCE_DIR}", - ] == construct_cc_includes( - repo=REPO, + assert set([ + SRCDIR, + ]) == construct_cc_includes( + PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="bar", - current_package_id=PackageId("foo", "bar"), known_include_files=["foo-srcdir/bar/f.h"], ) - assert [ - "${PROJECT_SOURCE_DIR}/bar/includes", - ] == construct_cc_includes( - REPO, + assert set([ + SRCDIR.joinpath("bar/includes"), + ]) == construct_cc_includes( PackageId("foo", "bar"), + source_directory=SRCDIR, + cmake_binary_dir=BINDIR, strip_include_prefix="includes", known_include_files=["foo-srcdir/bar/includes/g.h"], ) diff --git a/tools/cmake/bazel_to_cmake/emit_filegroup.py b/tools/cmake/bazel_to_cmake/emit_filegroup.py index 3640b5378..ad7ef218f 100644 --- a/tools/cmake/bazel_to_cmake/emit_filegroup.py +++ b/tools/cmake/bazel_to_cmake/emit_filegroup.py @@ -30,48 +30,62 @@ def emit_filegroup( out: io.StringIO, + *, cmake_name: str, filegroup_files: Collection[str], source_directory: pathlib.PurePath, cmake_binary_dir: pathlib.PurePath, add_dependencies: Optional[Iterable[CMakeTarget]] = None, + link_libraries: Optional[Iterable[CMakeTarget]] = None, + includes: Optional[set[str]] = None, ): + add_includes = False has_proto = False has_ch = False - includes: set[str] = set() + if includes is None: + add_includes = True + includes = set() + for path in filegroup_files: - has_proto = has_proto or path.endswith(".proto") + path = pathlib.PurePath(path) + has_proto = has_proto or path.suffix == ".proto" has_ch = ( has_ch - or path.endswith(".c") - or path.endswith(".h") - or path.endswith(".hpp") - or path.endswith(".cc") - or path.endswith(".inc") - ) - (c, _) = make_relative_path( - pathlib.PurePath(path), - (PROJECT_SOURCE_DIR, source_directory), - (PROJECT_BINARY_DIR, cmake_binary_dir), + or path.suffix == ".c" + or path.suffix == ".h" + or path.suffix == ".hpp" + or path.suffix == ".cc" + or path.suffix == ".inc" ) - if c is not None: - includes.add(c) + if add_includes: + (c, _) = make_relative_path( + path, + (PROJECT_SOURCE_DIR, source_directory), + (PROJECT_BINARY_DIR, cmake_binary_dir), + ) + if c is not None: + includes.add(c) sep = "\n " - quoted_includes = quote_list(sorted(includes), sep) quoted_srcs = quote_path_list(sorted(filegroup_files), sep) + quoted_includes = None + if includes and (has_ch or has_proto): + quoted_includes = quote_list(sorted(includes), sep) + quoted_libraries = None + if link_libraries: + quoted_libraries = quote_list(sorted(link_libraries), sep) + out.write(f"add_library({cmake_name} INTERFACE)\n") out.write(f"target_sources({cmake_name} INTERFACE{sep}{quoted_srcs})\n") - if has_proto: + if quoted_includes and (has_ch or has_proto): out.write( - f"set_property(TARGET {cmake_name} PROPERTY" - f" INTERFACE_IMPORTS{sep}{quoted_includes})\n" + f"target_include_directories({cmake_name} INTERFACE{sep}{quoted_includes})\n" ) - if has_ch: + # TODO: Introduce a custom property for proto files? INTERFACE_IMPORTS? + if quoted_libraries: out.write( - f"set_property(TARGET {cmake_name} PROPERTY" - f" INTERFACE_INCLUDE_DIRECTORIES{sep}{quoted_includes})\n" + f"target_link_libraries({cmake_name} INTERFACE{sep}{quoted_libraries})\n" ) if add_dependencies: deps_str = sep.join(sorted(set(add_dependencies))) diff --git a/tools/cmake/bazel_to_cmake/evaluation.py b/tools/cmake/bazel_to_cmake/evaluation.py index afb993ff7..a3315b81a 100644 --- a/tools/cmake/bazel_to_cmake/evaluation.py +++ b/tools/cmake/bazel_to_cmake/evaluation.py @@ -80,15 +80,15 @@ from . import cmake_builder from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeAddDependenciesProvider -from .cmake_target import CMakeExecutableTargetProvider -from .cmake_target import CMakeLinkLibrariesProvider +from .cmake_provider import CMakeExecutableTargetProvider +from .cmake_provider import CMakeHallucinatedTarget +from .cmake_provider import CMakeLinkLibrariesProvider +from .cmake_provider import CMakePackageDepsProvider from .cmake_target import CMakePackage -from .cmake_target import CMakePackageDepsProvider -from .cmake_target import CMakeTarget from .cmake_target import CMakeTargetPair from .package import Package from .package import Visibility +from .provider_util import ProviderCollection from .starlark import dict_polyfill from .starlark.bazel_build_file import BuildFileGlobals from .starlark.bazel_build_file import BuildFileLibraryGlobals @@ -399,24 +399,43 @@ def evaluate_configurable(self, configurable: Configurable[T]) -> T: return configurable.evaluate(self.evaluate_condition) return configurable - def get_file_paths( + def collect_targets( self, targets: Iterable[TargetId], - add_dependencies: Optional[List[CMakeTarget]] = None, - ) -> List[str]: - files = [] + collector: Optional[ProviderCollection] = None, + ) -> ProviderCollection: + if collector is None: + collector = ProviderCollection() for t in targets: - info = self.get_target_info(t) - if add_dependencies is not None: - cmake_info = info.get(CMakeAddDependenciesProvider) - if cmake_info is not None: - add_dependencies.append(cmake_info.target) - files_provider = info.get(FilesProvider) - if files_provider is not None: - files.extend(files_provider.paths) - else: - raise ValueError(f"get_file_paths failed for {t} info {repr(info)}") - return sorted(set(files)) + assert isinstance(t, TargetId), f"Requires TargetId: {repr(t)}" + try: + target_info = self.get_target_info(t) + collector.collect(t, target_info) + assert target_info.get(FilesProvider) is not None + except Exception as e: + e.args = (e.args if e.args else tuple()) + ( + f"collecting target {t.as_label()}", + ) + raise + return collector + + def collect_deps( + self, + targets: Iterable[TargetId], + collector: Optional[ProviderCollection] = None, + alias: bool = True, + ) -> ProviderCollection: + if collector is None: + collector = ProviderCollection() + for t in targets: + try: + collector.collect(t, self._get_dep(t, alias)) + except Exception as e: + e.args = (e.args if e.args else tuple()) + ( + f"collecting target {t.as_label()}", + ) + raise + return collector def _generate_cmake_target_pair_imp( self, target_id: TargetId, alias: bool = True @@ -425,9 +444,9 @@ def _generate_cmake_target_pair_imp( if repo is None: raise ValueError(f"Unknown repo in target {target_id.as_label()}") cmake_target_pair = repo.get_cmake_target_pair(target_id) - if not alias: - cmake_target_pair = cmake_target_pair.with_alias(None) - return cmake_target_pair + if alias: + return cmake_target_pair + return cmake_target_pair.with_alias(None) def generate_cmake_target_pair( self, target_id: TargetId, alias: bool = True @@ -446,9 +465,11 @@ def add_required_dep_package(self, package: CMakePackage) -> None: if package != self.active_repo.cmake_project_name: self._required_dep_packages.add(package) - def get_dep( - self, target_id: TargetId, alias: bool = True - ) -> List[CMakeTarget]: + def _get_dep( + self, + target_id: TargetId, + alias: bool, + ) -> TargetInfo: """Maps a Bazel target to the corresponding CMake target.""" # Local target. assert isinstance( @@ -457,10 +478,8 @@ def get_dep( info = self.get_optional_target_info(target_id) if info is not None: if info.get(CMakePackageDepsProvider): - for package in info[CMakePackageDepsProvider].packages: - self.add_required_dep_package(package) - if info.get(CMakeAddDependenciesProvider): - return [info[CMakeAddDependenciesProvider].target] + self.add_required_dep_package(info[CMakePackageDepsProvider].package) + return info # If this package is already a required dependency, return that. cmake_target = self._required_dep_targets.get(target_id) @@ -470,13 +489,7 @@ def get_dep( self._required_dep_targets[target_id] = cmake_target self.add_required_dep_package(cmake_target.cmake_package) - return [cmake_target.dep] - - def get_deps(self, targets: Iterable[TargetId]) -> List[CMakeTarget]: - deps: List[CMakeTarget] = [] - for target in targets: - deps.extend(self.get_dep(target)) - return deps + return TargetInfo(CMakeHallucinatedTarget(cmake_target.dep)) def get_placeholder_source(self): """Returns the path to a placeholder source file. @@ -803,6 +816,7 @@ def apply_repo_mapping( mapping_repo = self._state.workspace.all_repositories.get( mapping_repository_id ) + assert mapping_repo is not None target = mapping_repo.apply_repo_mapping(target_id) # Resolve --bind in the active repo. diff --git a/tools/cmake/bazel_to_cmake/native_aspect_proto.py b/tools/cmake/bazel_to_cmake/native_aspect_proto.py index ea7f6c8c7..81855eaf7 100644 --- a/tools/cmake/bazel_to_cmake/native_aspect_proto.py +++ b/tools/cmake/bazel_to_cmake/native_aspect_proto.py @@ -39,25 +39,39 @@ import hashlib import io import pathlib -from typing import Callable, Collection, List, NamedTuple, Optional +from typing import Callable, Iterable, List, NamedTuple, Optional, Set, Tuple from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeAddDependenciesProvider -from .cmake_target import CMakeLinkLibrariesProvider +from .cmake_provider import CMakeAddDependenciesProvider +from .cmake_provider import CMakePackageDepsProvider +from .cmake_provider import default_providers +from .cmake_provider import make_providers +from .cmake_repository import PROJECT_BINARY_DIR from .cmake_target import CMakeTarget from .emit_cc import emit_cc_library +from .emit_cc import handle_cc_common_options +from .emit_filegroup import emit_filegroup from .evaluation import EvaluationState +from .provider_util import ProviderCollection from .starlark.bazel_target import RepositoryId from .starlark.bazel_target import TargetId from .starlark.common_providers import FilesProvider from .starlark.common_providers import ProtoLibraryProvider from .starlark.invocation_context import InvocationContext from .starlark.provider import TargetInfo +from .util import exactly_one +from .util import partition_by +from .util import PathIterable +from .util import PathLike from .util import quote_list +from .util import quote_path +from .util import quote_path_list +from .util import quote_string PROTO_REPO = RepositoryId("com_google_protobuf") PROTO_COMPILER = PROTO_REPO.parse_target("//:protoc") +_HEADER_SRC_PATTERN = r"\.(?:h|hpp|inc)$" class PluginSettings(NamedTuple): @@ -69,137 +83,257 @@ class PluginSettings(NamedTuple): language: Optional[str] = None -def _get_proto_output_dir( - _context: InvocationContext, - out_hash: Optional[str], - strip_import_prefix: Optional[str], -) -> pathlib.PurePath: - """Construct the output path for the proto compiler. - - This is typically a path relative to ${PROJECT_BINARY_DIR} where the - protocol compiler will output copied protos. - """ - output_dir = pathlib.PurePath("") - if out_hash: - output_dir = pathlib.PurePath(out_hash) - if strip_import_prefix is not None: - include_path = str( - pathlib.PurePosixPath(_context.caller_package_id.package_name).joinpath( - strip_import_prefix - ) - ) - if include_path[0] == "/": - include_path = include_path[1:] - output_dir = output_dir.joinpath(include_path) - return output_dir +############################################################################## -def _emit_btc_protobuf( +def btc_protobuf( + _context: InvocationContext, out: io.StringIO, *, plugin_settings: PluginSettings, - plugin_name: Optional[str] = None, - cmake_name: CMakeTarget, - proto_cmake_target: CMakeTarget, - add_dependencies: Collection[CMakeTarget], + proto_src: PathLike, + generated_files: PathIterable, + cmake_depends: Optional[Iterable[CMakeTarget]] = None, flags: Optional[List[str]] = None, - output_dir: Optional[pathlib.PurePath] = None, + output_dir: Optional[str] = None, + import_targets: Optional[Iterable[CMakeTarget]] = None, ): - language = ( - plugin_settings.language - if plugin_settings.language - else plugin_settings.name - ) + """Generate text to invoke btc_protobuf for a single target.""" + if not output_dir: + output_dir = PROJECT_BINARY_DIR - plugin = "" - if plugin_name: - assert plugin_name in add_dependencies - plugin = f"\n PLUGIN protoc-gen-{language}=$" - - # Construct the output path. This is also the target include dir. - # ${PROJECT_BINARY_DIR} - if output_dir: - output_dir = f"${{PROJECT_BINARY_DIR}}/{output_dir.as_posix()}" + if not cmake_depends: + cmake_depends = set() else: - output_dir = "${PROJECT_BINARY_DIR}" + cmake_depends = set(cmake_depends) + cmake_depends.add("protobuf::protoc") + cmake_depends.add(proto_src) + + state = _context.access(EvaluationState) + collector = ProviderCollection() - plugin_flags = "" + plugin = "" + if plugin_settings.plugin: + plugin_name = exactly_one( + state.collect_deps([plugin_settings.plugin], collector).targets() + ) + cmake_depends.add(plugin_name) + plugin = ( + "\n " + f" --plugin=protoc-gen-{plugin_settings.language}=$" + ) + + state.collect_deps([PROTO_COMPILER], collector) + cmake_depends.update(collector.targets()) + + # Build the flags for the plugin. if flags: - plugin_flags = f"\n PLUGIN_OPTIONS {quote_list(flags)}" + flags = ",".join(flags) + flags = f"--{plugin_settings.language}_out={flags}:{output_dir}" + else: + flags = f"--{plugin_settings.language}_out={output_dir}" + _sep = "\n " + + mkdirs = set() + + def _generated_files(): + for x in generated_files: + mkdirs.add(pathlib.PurePath(x).parent) + yield x + + quoted_paths = quote_path_list(_generated_files(), separator=_sep) + + # Emit. + if mkdirs: + out.write(f"file(MAKE_DIRECTORY {quote_path_list(sorted(mkdirs))})\n") + out.write(f"""add_custom_command( +OUTPUT + {quoted_paths} +COMMAND $ + --experimental_allow_proto3_optional{plugin}""") + for x in sorted(set(import_targets)): + _prop = f"$" + _expr = f"-I$-I>" + # _ifexists = f"$<$:$<$:{_expr}>>" + out.write(f"\n {quote_string(_expr)}") out.write(f""" -btc_protobuf( - TARGET {cmake_name} - PROTO_TARGET {proto_cmake_target} - LANGUAGE {language} - GENERATE_EXTENSIONS {quote_list(plugin_settings.exts)} - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR {output_dir}{plugin}{plugin_flags} - DEPENDS {quote_list(sorted(add_dependencies))} -) -""") + {quote_string(flags)} + {quote_path(proto_src)} +DEPENDS + {quote_list(cmake_depends, separator=_sep)} +COMMENT "Running protoc {plugin_settings.name} on {proto_src}" +COMMAND_EXPAND_LISTS +VERBATIM +)\n""") + + +############################################################################## +# Single Protoaspect details +############################################################################## +# +# Bazel proto_libraries() can reference soruce files multiple times, so +# the aspect actually needs to generate a target per source file. +# +def _assert_is_proto(src: TargetId): + assert src.target_name.endswith( + ".proto" + ), f"{src.as_label()} must end in .proto" -def btc_protobuf( - _context: InvocationContext, - cmake_name: CMakeTarget, - proto_cmake_target: CMakeTarget, +def singleproto_aspect_target( + src: TargetId, plugin_settings: PluginSettings, - *, - cmake_deps: List[CMakeTarget], - flags: Optional[List[str]] = None, - output_dir: Optional[pathlib.PurePath] = None, -) -> str: - """Generate text to invoke btc_protobuf for a single target.""" +) -> TargetId: + _assert_is_proto(src) + hash_id = hashlib.sha1(src.as_label().encode("utf-8")).hexdigest()[:8] + return src.get_target_id(f"aspect_{plugin_settings.name}__{hash_id}") + + +def plugin_generated_files( + src: TargetId, + plugin_settings: PluginSettings, + binary_dir: pathlib.PurePath, +) -> List[Tuple[TargetId, pathlib.PurePath]]: + """Returns a list of (target, path)... generated by plugin_settings.""" + _assert_is_proto(src) + target_name = src.target_name.removesuffix(".proto") + def _mktuple(ext: str) -> Tuple[TargetId, pathlib.PurePath]: + generated_target = src.get_target_id(f"{target_name}{ext}") + generated_path = generated_target.as_rooted_path(binary_dir) + return (generated_target, generated_path) + + return [_mktuple(ext) for ext in plugin_settings.exts] + + +def aspect_genproto_singleproto( + _context: InvocationContext, + *, + aspect_target: TargetId, + src: TargetId, + proto_library_provider: ProtoLibraryProvider, + plugin_settings: PluginSettings, + output_dir: pathlib.PurePath, +): + _assert_is_proto(src) state = _context.access(EvaluationState) + repo = state.workspace.all_repositories.get( + _context.caller_package_id.repository_id + ) + assert repo is not None - plugin_name = None - if plugin_settings.plugin: - plugin = state.get_dep(plugin_settings.plugin) - if len(plugin) != 1: - raise ValueError( - f"Resolving {plugin_settings.plugin} returned: {plugin_name}" - ) - cmake_deps.append(plugin[0]) - plugin_name = plugin[0] + # This library could already have been constructed. + if state.get_optional_target_info(aspect_target) is not None: + return + + # Get our cmake name; proto libraries need aliases to be referenced + # from other source trees. + cmake_target_pair = state.generate_cmake_target_pair( + aspect_target, alias=False + ) + + src_collector = state.collect_targets([src]) + proto_src_files: List[str] = list(set(src_collector.file_paths())) + if not proto_src_files: + raise ValueError( + f"Proto generation failed: {src.as_label()} has no proto srcs" + ) + assert len(proto_src_files) == 1 + + proto_cmake_target = state.generate_cmake_target_pair( + proto_library_provider.bazel_target + ).target + import_targets = set( + state.collect_deps(proto_library_provider.deps).link_libraries() + ) + import_targets.add(proto_cmake_target) - cmake_deps.extend(state.get_dep(PROTO_COMPILER)) + # Emit the generated files. + generated_files = [] + for t in plugin_generated_files( + src, + plugin_settings, + output_dir, + ): + _context.add_analyzed_target( + t[0], + TargetInfo( + *make_providers( + cmake_target_pair, + CMakePackageDepsProvider, + CMakeAddDependenciesProvider, + ), + FilesProvider([t[1]]), + ), + ) + generated_files.append(t[1]) + _context.add_analyzed_target( + aspect_target, + TargetInfo( + *default_providers(cmake_target_pair), + FilesProvider(generated_files), + ), + ) + + # Augment output with strip import prefix + if proto_library_provider.strip_import_prefix: + include_path = str( + pathlib.PurePosixPath(_context.caller_package_id.package_name).joinpath( + proto_library_provider.strip_import_prefix + ) + ) + if include_path[0] == "/": + include_path = include_path[1:] + output_dir = output_dir.joinpath(include_path) + + relative_includes = repo.replace_with_cmake_macro_dirs([output_dir]) + + # Emit. out = io.StringIO() - _emit_btc_protobuf( + out.write( + f"\n# {aspect_target.as_label()}\n" + f"# genproto {plugin_settings.name} {src.as_label()}\n" + ) + btc_protobuf( + _context, out, plugin_settings=plugin_settings, - cmake_name=cmake_name, - proto_cmake_target=proto_cmake_target, - plugin_name=plugin_name, - add_dependencies=cmake_deps, - flags=flags, - output_dir=output_dir, + # varname=str(cmake_target_pair.target), + proto_src=proto_src_files[0], + generated_files=generated_files, + import_targets=import_targets, + cmake_depends=src_collector.add_dependencies(), + output_dir=relative_includes[0], ) - return out.getvalue() + sep = "\n " + quoted_outputs = quote_path_list( + repo.replace_with_cmake_macro_dirs(generated_files), sep + ) + out.write( + f"add_custom_target(genrule_{cmake_target_pair.target} DEPENDS{sep}{quoted_outputs})\n" + ) + # NOTE: We probably don't need this file group once the aspect target + # includes .h files as INTERFACE sources to ensure that they are generated. + # Without that, CMake had trouble finding the files properly, but that + # may have been by attempted includes across directories (.pb.h): + # https://gitlab.kitware.com/cmake/cmake/-/issues/18399 + emit_filegroup( + out, + cmake_name=cmake_target_pair.target, + filegroup_files=generated_files, + source_directory=repo.source_directory, + cmake_binary_dir=output_dir, + add_dependencies=[CMakeTarget("genrule__" + cmake_target_pair.target)], + includes=relative_includes, + ) -def get_aspect_dep( - _context: InvocationContext, - t: TargetId, -) -> CMakeTarget: - # First-party proto references must exist. - state = _context.access(EvaluationState) - if _context.caller_package_id.repository_id == t.repository_id: - target_info = state.get_target_info(t) - else: - target_info = state.get_optional_target_info(t) + _context.access(CMakeBuilder).addtext(out.getvalue()) - if target_info: - provider = target_info.get(CMakeLinkLibrariesProvider) - if provider: - return provider.target - # Get our cmake name; proto libraries need aliases to be referenced - # from other source trees. - print(f"Blind reference to {t.as_label()} from {_context.caller_package_id}") - return state.generate_cmake_target_pair(t).target +############################################################################## def aspect_genproto_library_target( @@ -211,6 +345,10 @@ def aspect_genproto_library_target( ): """Emit or return an appropriate TargetId for protos compiled.""" state = _context.access(EvaluationState) + repo = state.workspace.all_repositories.get( + _context.caller_package_id.repository_id + ) + assert repo is not None # Ensure that the proto_library() target has already been created. # First-party rules must exists; this is the common case. @@ -228,7 +366,7 @@ def aspect_genproto_library_target( if not proto_target_info or ( proto_target_info.get(ProtoLibraryProvider) is None - and proto_target_info.get(CMakeLinkLibrariesProvider) is None + and proto_target_info.get(CMakeAddDependenciesProvider) is None and proto_target_info.get(FilesProvider) is None ): # This target is not available; construct an ephemeral reference. @@ -238,105 +376,69 @@ def aspect_genproto_library_target( ) return - proto_provider = proto_target_info.get(ProtoLibraryProvider) - assert proto_provider is not None + proto_library_provider = proto_target_info.get(ProtoLibraryProvider) + assert proto_library_provider is not None # Resovle aspect deps, excluding self. - aspect_deps = set(plugin_settings.aspectdeps(proto_target)) - for d in proto_provider.deps: + aspect_deps: Set[TargetId] = set() + aspect_deps.update(plugin_settings.aspectdeps(proto_target)) + for d in proto_library_provider.deps: aspect_deps.update(plugin_settings.aspectdeps(d)) + aspect_deps.update(plugin_settings.runtime) if target in aspect_deps: aspect_deps.remove(target) - link_libraries = state.get_deps(plugin_settings.runtime) - link_libraries.extend(state.get_deps(sorted(aspect_deps))) - - # Get our cmake name; proto libraries need aliases to be referenced - # from other source trees. cmake_target_pair = state.generate_cmake_target_pair(target) - # NOTE: Consider using generator expressions to add to the library target. - # Something like $ - cmake_deps: List[CMakeTarget] = [] - proto_src_files: List[str] = state.get_file_paths( - proto_provider.srcs, cmake_deps - ) - import_target = cmake_target_pair.target + # Build per-file stuff. + output_dir = repo.cmake_binary_dir.joinpath(f"_gen_{plugin_settings.name}") - proto_src_files = sorted(set(proto_src_files)) - if not proto_src_files and not link_libraries and not import_target: - raise ValueError( - f"Proto generation failed: {target.as_label()} no inputs for" - f" {proto_target.as_label()}" + aspect_srcs: set[TargetId] = set() + for src in proto_library_provider.srcs: + aspect_target = singleproto_aspect_target(src, plugin_settings) + aspect_srcs.add(aspect_target) + aspect_genproto_singleproto( + _context, + aspect_target=aspect_target, + src=src, + proto_library_provider=proto_library_provider, + plugin_settings=plugin_settings, + output_dir=output_dir, ) - # Construct the output path. This is also the target include dir. - # ${PROJECT_BINARY_DIR} - hash_id = proto_target.as_label() - hash_prefix = hashlib.sha1(hash_id.encode("utf-8")).hexdigest()[:8] - output_dir = _get_proto_output_dir( - _context, - hash_prefix, - proto_provider.strip_import_prefix, + # Now emit a cc_library for each proto_library + srcs_collector = state.collect_targets(aspect_srcs) + split_srcs = partition_by( + srcs_collector.file_paths(), pattern=_HEADER_SRC_PATTERN ) - assert not output_dir or str(output_dir)[0] != "/" - # For the input protos, if known, generate the output files. - # This also adds an "alias", or rather, a mapping to the generated file - # path for the generated target, which just happens to be in a separate - # directory. - repo = state.workspace.all_repositories.get( - _context.caller_package_id.repository_id + common_options = handle_cc_common_options( + _context, + src_required=True, + add_dependencies=set(srcs_collector.add_dependencies()), + srcs=aspect_srcs, + deps=aspect_deps, + includes=None, + include_prefix=proto_library_provider.import_prefix, + strip_include_prefix=proto_library_provider.strip_import_prefix, + hdrs_file_paths=split_srcs[0], + _source_directory=repo.source_directory, + _cmake_binary_dir=output_dir, ) + del common_options["private_includes"] - # Emit the generated files. - generated_paths = [] - for src in proto_provider.srcs: - assert src.target_name.endswith( - ".proto" - ), f"{src.as_label()} must end in .proto" - target_name = src.target_name.removesuffix(".proto") - for ext in plugin_settings.exts: - generated_target = src.get_target_id(f"{target_name}{ext}") - generated_path = generated_target.as_rooted_path( - repo.cmake_binary_dir.joinpath(output_dir) - ) - _context.add_analyzed_target( - generated_target, - TargetInfo( - FilesProvider([str(generated_path)]), - CMakeAddDependenciesProvider(cmake_target_pair.target), - ), - ) - generated_paths.append(generated_path) - _context.add_analyzed_target( - target, - TargetInfo( - *cmake_target_pair.as_providers(), FilesProvider(generated_paths) - ), + out = io.StringIO() + out.write( + f"\n# {target.as_label()}" + f"\n# aspect {plugin_settings.name} {proto_target.as_label()}" ) - - # Emit. - btc_protobuf_txt = "" - if proto_src_files: - btc_protobuf_txt = btc_protobuf( - _context, - cmake_target_pair.target, - proto_target_info.get(CMakeLinkLibrariesProvider).target, - plugin_settings, - cmake_deps=cmake_deps.copy(), - output_dir=output_dir, - ) - - builder = _context.access(CMakeBuilder) - builder.addtext(f"\n# {target.as_label()}") emit_cc_library( - builder, + out, cmake_target_pair, - hdrs=set(), - srcs=set(), - deps=set(link_libraries), - header_only=(not bool(proto_src_files)), - includes=[], + hdrs=split_srcs[0], + **common_options, + ) + _context.access(CMakeBuilder).addtext(out.getvalue()) + _context.add_analyzed_target( + target, TargetInfo(*default_providers(cmake_target_pair)) ) - builder.addtext(btc_protobuf_txt) diff --git a/tools/cmake/bazel_to_cmake/native_rules_alias.py b/tools/cmake/bazel_to_cmake/native_rules_alias.py index a3478ee73..b6c38f4ed 100644 --- a/tools/cmake/bazel_to_cmake/native_rules_alias.py +++ b/tools/cmake/bazel_to_cmake/native_rules_alias.py @@ -14,19 +14,24 @@ """CMake implementation of native Bazel alias() rule.""" # pylint: disable=relative-beyond-top-level,invalid-name,missing-function-docstring,g-long-lambda - +import io from typing import List, Optional from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeExecutableTargetProvider -from .cmake_target import CMakeLinkLibrariesProvider +from .cmake_provider import CMakeAddDependenciesProvider +from .cmake_provider import CMakeAliasProvider +from .cmake_provider import CMakeExecutableTargetProvider +from .cmake_provider import CMakeLinkLibrariesProvider from .cmake_target import CMakeTarget from .cmake_target import CMakeTargetPair from .evaluation import EvaluationState from .starlark.bazel_build_file import register_native_build_rule from .starlark.bazel_target import TargetId +from .starlark.common_providers import BuildSettingProvider +from .starlark.common_providers import ConditionProvider from .starlark.invocation_context import InvocationContext from .starlark.label import RelativeLabel +from .starlark.provider import TargetInfo from .starlark.select import Configurable @@ -53,48 +58,54 @@ def _alias_impl( _target: TargetId, actual: Configurable[RelativeLabel], ): + state = _context.access(EvaluationState) + resolved = _context.resolve_target_or_label( _context.evaluate_configurable(actual) ) target_info = _context.get_target_info(resolved) - _context.add_analyzed_target(_target, target_info) - if resolved.repository_name != _context.caller_package_id.repository_name: - # When this is an alias to another repository, don't add a CMake ALIAS. + # Special case any target info with conditions or build settings. + if target_info.get(ConditionProvider) or target_info.get( + BuildSettingProvider + ): + _context.add_analyzed_target(_target, target_info) return - state = _context.access(EvaluationState) + # CMake doesn't allow aliases to aliases, so if that happens, use the + # same alias target. + if target_info.get(CMakeAliasProvider): + cmake_alias_target = target_info[CMakeAliasProvider].target + else: + cmake_alias_target = state.generate_cmake_target_pair(resolved).target - resolved_provider = target_info.get(CMakeLinkLibrariesProvider) - if resolved_provider is None: - resolved_provider = target_info.get(CMakeExecutableTargetProvider) - if resolved_provider is not None: - # When the rule resolves to a CMakeTarget, emit an alias for that target. - _emit_cmake_alias( - _context, - f"\n# alias({_target.as_label()})\n", - state.generate_cmake_target_pair(_target), - resolved_provider.target, - is_executable=isinstance( - resolved_provider, CMakeExecutableTargetProvider - ), - ) + _context.add_analyzed_target( + _target, + TargetInfo(*tuple(target_info), CMakeAliasProvider(cmake_alias_target)), + ) + if resolved.repository_name != _context.caller_package_id.repository_name: + # When this is an alias to another repository, don't add a CMake ALIAS. + return -def _emit_cmake_alias( - _context: InvocationContext, - prefix_str: str, - source: CMakeTargetPair, - dest: CMakeTarget, - is_executable: bool, -): - # Don't emit an alias for self. - if source.target == dest: + source = state.generate_cmake_target_pair(_target) + if source.target == cmake_alias_target: return - add_fn = ["add_library", "add_executable"][is_executable] - builder = _context.access(CMakeBuilder) - if prefix_str: - builder.addtext(prefix_str) - builder.addtext(f"{add_fn}({source.target} ALIAS {dest})\n") - if source.alias: - builder.addtext(f"{add_fn}({source.alias} ALIAS {dest})\n") + + function = None + if target_info.get(CMakeExecutableTargetProvider): + function = "add_executable" + elif target_info.get(CMakeLinkLibrariesProvider) or target_info.get( + CMakeAddDependenciesProvider + ): + function = "add_library" + + out = io.StringIO() + out.write(f"\n# alias({_target.as_label()})\n") + if function: + out.write(f"{function}({source.target} ALIAS {cmake_alias_target})\n") + if source.alias: + out.write(f"{function}({source.alias} ALIAS {cmake_alias_target})\n") + else: + out.write(f"# No alias emitted for {cmake_alias_target})\n") + _context.access(CMakeBuilder).addtext(out.getvalue()) diff --git a/tools/cmake/bazel_to_cmake/native_rules_cc.py b/tools/cmake/bazel_to_cmake/native_rules_cc.py index 483b404d3..5c41df707 100644 --- a/tools/cmake/bazel_to_cmake/native_rules_cc.py +++ b/tools/cmake/bazel_to_cmake/native_rules_cc.py @@ -15,10 +15,15 @@ # pylint: disable=relative-beyond-top-level,invalid-name,missing-function-docstring,g-long-lambda -from typing import List, Optional +import io +import itertools +from typing import Callable, Dict, List, Optional from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeExecutableTargetProvider +from .cmake_provider import CMakeExecutableTargetProvider +from .cmake_provider import CMakePackageDepsProvider +from .cmake_provider import default_providers +from .cmake_provider import make_providers from .cmake_target import CMakeTarget from .emit_cc import emit_cc_binary from .emit_cc import emit_cc_library @@ -35,6 +40,54 @@ from .variable_substitution import apply_location_substitutions +def _common_cc_resolve( + _next: Callable[..., None], + _context: InvocationContext, + _target: TargetId, + srcs: Optional[Configurable[List[RelativeLabel]]] = None, + hdrs: Optional[Configurable[List[RelativeLabel]]] = None, + textual_hdrs: Optional[Configurable[List[RelativeLabel]]] = None, + deps: Optional[Configurable[List[RelativeLabel]]] = None, + includes: Optional[Configurable[List[str]]] = None, + include_prefix: Optional[Configurable[str]] = None, + strip_include_prefix: Optional[Configurable[str]] = None, + tags: Optional[Configurable[List[str]]] = None, + args: Optional[Configurable[List[str]]] = None, + **kwargs, +): + """Applies evaluate_configurable to common (and uncommon) cc rule arguments.""" + _next( + _context, + _target, + srcs=_context.resolve_target_or_label_list( + _context.evaluate_configurable_list(srcs) + ), + hdrs=_context.resolve_target_or_label_list( + _context.evaluate_configurable_list(hdrs) + ), + deps=_context.resolve_target_or_label_list( + _context.evaluate_configurable_list(deps) + ), + textual_hdrs=_context.resolve_target_or_label_list( + _context.evaluate_configurable_list(textual_hdrs) + ), + includes=_context.evaluate_configurable_list(includes), + include_prefix=( + _context.evaluate_configurable(include_prefix) + if include_prefix + else None + ), + strip_include_prefix=( + _context.evaluate_configurable(strip_include_prefix) + if strip_include_prefix + else None + ), + tags=_context.evaluate_configurable_list(tags), + args=_context.evaluate_configurable_list(args), + **kwargs, + ) + + @register_native_build_rule def cc_library( self: InvocationContext, @@ -49,7 +102,7 @@ def cc_library( target = context.parse_rule_target(name) context.add_rule( target, - lambda: _cc_library_impl(context, target, **kwargs), + lambda: _common_cc_resolve(_cc_library_impl, context, target, **kwargs), visibility=visibility, ) @@ -57,46 +110,51 @@ def cc_library( def _cc_library_impl( _context: InvocationContext, _target: TargetId, - hdrs: Optional[Configurable[List[RelativeLabel]]] = None, - textual_hdrs: Optional[Configurable[List[RelativeLabel]]] = None, + hdrs: Optional[List[TargetId]] = None, + textual_hdrs: Optional[List[TargetId]] = None, alwayslink: bool = False, **kwargs, ): - resolved_hdrs = _context.resolve_target_or_label_list( - _context.evaluate_configurable_list(hdrs) + state = _context.access(EvaluationState) + + hdrs_collector = state.collect_targets(hdrs) + textual_hdrs_collector = state.collect_targets(textual_hdrs) + + add_dependencies: List[CMakeTarget] = list( + itertools.chain( + hdrs_collector.add_dependencies(), + textual_hdrs_collector.add_dependencies(), + ) ) - resolved_textual_hdrs = _context.resolve_target_or_label_list( - _context.evaluate_configurable_list(textual_hdrs) + all_hdrs = set( + itertools.chain( + hdrs_collector.file_paths(), textual_hdrs_collector.file_paths() + ) ) - state = _context.access(EvaluationState) - cmake_target_pair = state.generate_cmake_target_pair(_target) - add_dependencies: List[CMakeTarget] = [] - hdrs_file_paths = state.get_file_paths(resolved_hdrs, add_dependencies) - textual_hdrs_file_paths = state.get_file_paths( - resolved_textual_hdrs, add_dependencies - ) common_options = handle_cc_common_options( _context, add_dependencies=add_dependencies, - hdrs_file_paths=hdrs_file_paths, - textual_hdrs_file_paths=textual_hdrs_file_paths, + hdrs_file_paths=list(hdrs_collector.file_paths()), + textual_hdrs_file_paths=list(textual_hdrs_collector.file_paths()), **kwargs, ) - builder = _context.access(CMakeBuilder) - builder.addtext(f"\n# cc_library({_target.as_label()})") - emit_cc_library( - builder, + out = io.StringIO() + out.write(f"\n# cc_library({_target.as_label()})") + extra_providers = emit_cc_library( + out, cmake_target_pair, - hdrs=set(hdrs_file_paths + textual_hdrs_file_paths), + hdrs=all_hdrs, alwayslink=alwayslink, **common_options, ) + _context.access(CMakeBuilder).addtext(out.getvalue()) _context.add_analyzed_target( - _target, TargetInfo(*cmake_target_pair.as_providers()) + _target, + TargetInfo(*default_providers(cmake_target_pair), *extra_providers), ) @@ -124,7 +182,7 @@ def cc_binary( context.add_rule( target, - lambda: _cc_binary_impl(context, target, **kwargs), + lambda: _common_cc_resolve(_cc_binary_impl, context, target, **kwargs), analyze_by_default=analyze_by_default, ) @@ -137,19 +195,22 @@ def _cc_binary_impl(_context: InvocationContext, _target: TargetId, **kwargs): common_options = handle_cc_common_options( _context, src_required=True, **kwargs ) - builder = _context.access(CMakeBuilder) - builder.addtext(f"\n# cc_binary({_target.as_label()})") + out = io.StringIO() + out.write(f"\n# cc_binary({_target.as_label()})") emit_cc_binary( - _context.access(CMakeBuilder), + out, cmake_target_pair, **common_options, ) + _context.access(CMakeBuilder).addtext(out.getvalue()) _context.add_analyzed_target( _target, TargetInfo( - *cmake_target_pair.as_providers( - provider=CMakeExecutableTargetProvider + *make_providers( + cmake_target_pair, + CMakePackageDepsProvider, + CMakeExecutableTargetProvider, ) ), ) @@ -162,18 +223,13 @@ def cc_test( visibility: Optional[List[RelativeLabel]] = None, **kwargs, ): - if "skip-cmake" in kwargs.get("tags", []): - return - # CMake does not run tests multiple times, so skip the flaky tests. - if kwargs.get("flaky", False): - return context = self.snapshot() target = context.parse_rule_target(name) resolved_visibility = context.resolve_target_or_label_list(visibility or []) context.add_rule( target, - lambda: _cc_test_impl(context, target, **kwargs), + lambda: _common_cc_resolve(_cc_test_impl, context, target, **kwargs), analyze_by_default=context.access(Visibility).analyze_test_by_default( resolved_visibility ), @@ -183,35 +239,55 @@ def cc_test( def _cc_test_impl( _context: InvocationContext, _target: TargetId, - args: Optional[Configurable[List[str]]] = None, + args: Optional[List[str]] = None, + tags: Optional[List[str]] = None, **kwargs, ): + # CMake does not run tests multiple times, so skip the flaky tests. + if "skip-cmake" in tags or "flaky" in tags: + _context.access(CMakeBuilder).addtext( + f"\n# Skipping cc_test {_target.as_label()}\n" + ) + _context.add_analyzed_target(_target, TargetInfo()) + return + state = _context.access(EvaluationState) + cmake_target_pair = state.generate_cmake_target_pair(_target) resolved_args = [ apply_location_substitutions( _context, arg, relative_to=state.active_repo.source_directory ) - for arg in _context.evaluate_configurable_list(args) + for arg in args ] common_options = handle_cc_common_options( _context, src_required=True, **kwargs ) - builder = _context.access(CMakeBuilder) - builder.addtext(f"\n# cc_test({_target.as_label()})") + # Translate tags to CMake properties. + # https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#test-properties + properties: Dict[str, str] = {} + for t in tags: + if t.startswith("cpu:"): + properties["RUN_SERIAL"] = "TRUE" + out = io.StringIO() + out.write(f"\n# cc_test({_target.as_label()})") emit_cc_test( - _context.access(CMakeBuilder), + out, cmake_target_pair, args=resolved_args, + properties=properties, **common_options, ) + _context.access(CMakeBuilder).addtext(out.getvalue()) _context.add_analyzed_target( _target, TargetInfo( - *cmake_target_pair.as_providers( - provider=CMakeExecutableTargetProvider + *make_providers( + cmake_target_pair, + CMakePackageDepsProvider, + CMakeExecutableTargetProvider, ) ), ) diff --git a/tools/cmake/bazel_to_cmake/native_rules_cc_proto.py b/tools/cmake/bazel_to_cmake/native_rules_cc_proto.py index d4551f3e1..5c5d02693 100644 --- a/tools/cmake/bazel_to_cmake/native_rules_cc_proto.py +++ b/tools/cmake/bazel_to_cmake/native_rules_cc_proto.py @@ -47,12 +47,13 @@ """ # pylint: disable=invalid-name - +import io from typing import Callable, List, Optional from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeTarget +from .cmake_provider import default_providers from .emit_cc import emit_cc_library +from .emit_cc import handle_cc_common_options from .evaluation import EvaluationState from .native_aspect import add_proto_aspect from .native_aspect_proto import aspect_genproto_library_target @@ -67,6 +68,7 @@ PROTO_REPO = RepositoryId("com_google_protobuf") PROTO_RUNTIME = PROTO_REPO.parse_target("//:protobuf") + _WELL_KNOWN_TYPES = [ "any", "api", @@ -81,7 +83,7 @@ ] _IGNORED = set([ - PROTO_REPO.parse_target(f"//src/google/protobuf:{x}_proto") + PROTO_REPO.parse_target(f"//src/google/protobuf:{x}_proto__cpp_library") for x in _WELL_KNOWN_TYPES ]) @@ -92,6 +94,7 @@ def _cpp_proto_target(t: TargetId) -> List[TargetId]: _CC = PluginSettings( name="cpp", + language="cpp", plugin=None, exts=[".pb.h", ".pb.cc"], runtime=[PROTO_RUNTIME], @@ -105,9 +108,9 @@ def cpp_proto_aspect( visibility: Optional[List[RelativeLabel]] = None, **kwargs, ): - if proto_target in _IGNORED: - return aspect_target = _CC.aspectdeps(proto_target)[0] + if aspect_target in _IGNORED: + return context.add_rule( aspect_target, lambda: aspect_genproto_library_target( @@ -173,18 +176,26 @@ def cc_proto_library_impl( print(f"WARNING: {_target.as_label()} is identical to an aspect target") aspect_deps.remove(_target) - library_deps: List[CMakeTarget] = state.get_deps(aspect_deps) + aspect_deps.update(resolved_deps) + + common_options = handle_cc_common_options( + _context, + src_required=True, + srcs=[], + deps=aspect_deps, + includes=None, + ) - builder = _context.access(CMakeBuilder) - builder.addtext(f"\n# {_mnemonic}({_target.as_label()})") - emit_cc_library( - builder, + out = io.StringIO() + out.write(f"\n# {_mnemonic}({_target.as_label()})") + extra_providers = emit_cc_library( + out, cmake_target_pair, - hdrs=set(), - srcs=set(), - includes=[], - deps=set(library_deps), + hdrs=[], + **common_options, ) + _context.access(CMakeBuilder).addtext(out.getvalue()) _context.add_analyzed_target( - _target, TargetInfo(*cmake_target_pair.as_providers()) + _target, + TargetInfo(*default_providers(cmake_target_pair), *extra_providers), ) diff --git a/tools/cmake/bazel_to_cmake/native_rules_genrule.py b/tools/cmake/bazel_to_cmake/native_rules_genrule.py index 59999d686..5b8f8cede 100644 --- a/tools/cmake/bazel_to_cmake/native_rules_genrule.py +++ b/tools/cmake/bazel_to_cmake/native_rules_genrule.py @@ -23,11 +23,14 @@ # pylint: disable=relative-beyond-top-level,invalid-name,missing-function-docstring,g-long-lambda import io +import itertools import pathlib -from typing import List, Optional, cast +from typing import List, Optional from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeAddDependenciesProvider +from .cmake_provider import CMakeAddDependenciesProvider +from .cmake_provider import CMakePackageDepsProvider +from .cmake_provider import make_providers from .cmake_target import CMakeTarget from .emit_filegroup import emit_filegroup from .emit_filegroup import emit_genrule @@ -46,11 +49,6 @@ from .variable_substitution import generate_substitutions -def _emit_make_directory(out: io.StringIO, out_dirs: set[pathlib.PurePath]): - if out_dirs: - out.write(f"file(MAKE_DIRECTORY {quote_path_list(sorted(out_dirs))})\n") - - @register_native_build_rule def filegroup( self: InvocationContext, @@ -89,12 +87,19 @@ def _filegroup_impl( cmake_target_pair = state.generate_cmake_target_pair(_target, alias=False) - cmake_deps: List[CMakeTarget] = [] - srcs_files = state.get_file_paths(resolved_srcs, cmake_deps) + srcs_collector = state.collect_targets(resolved_srcs) + srcs_files = sorted(set(srcs_collector.file_paths())) _context.add_analyzed_target( _target, - TargetInfo(*cmake_target_pair.as_providers(), FilesProvider(srcs_files)), + TargetInfo( + *make_providers( + cmake_target_pair, + CMakePackageDepsProvider, + CMakeAddDependenciesProvider, + ), + FilesProvider(srcs_files), + ), ) # Also add an INTERFACE_LIBRARY in order to reference in compile targets. @@ -102,11 +107,11 @@ def _filegroup_impl( out.write(f"\n# filegroup({_target.as_label()})\n") emit_filegroup( out, - cmake_target_pair.target, - srcs_files, - repo.source_directory, - repo.cmake_binary_dir, - add_dependencies=cmake_deps, + cmake_name=cmake_target_pair.target, + filegroup_files=srcs_files, + source_directory=repo.source_directory, + cmake_binary_dir=repo.cmake_binary_dir, + add_dependencies=set(srcs_collector.add_dependencies()), ) _context.access(CMakeBuilder).addtext(out.getvalue()) @@ -186,14 +191,21 @@ def _genrule_impl( out_target, TargetInfo(FilesProvider([str_path]), cmake_deps_provider) ) - cmake_deps: List[CMakeTarget] = state.get_deps(resolved_tools) - src_files = state.get_file_paths(resolved_srcs, cmake_deps) - cmake_deps.extend(cast(List[CMakeTarget], src_files)) + tools_collector = state.collect_deps(resolved_tools) + src_collector = state.collect_targets(resolved_srcs) + + add_dependencies: List[CMakeTarget] = list( + itertools.chain( + tools_collector.targets(), + src_collector.add_dependencies(), + ) + ) + add_dependencies.extend(CMakeTarget(x) for x in src_collector.file_paths()) substitutions = generate_substitutions( _context, _target, - src_files=src_files, + src_files=list(src_collector.file_paths()), out_files=out_files, ) source_directory = _context.resolve_source_root( @@ -204,7 +216,7 @@ def _genrule_impl( _context, cmd=_context.evaluate_configurable(cmd), relative_to=str(source_directory), - add_dependencies=cmake_deps, + add_dependencies=add_dependencies, substitutions=substitutions, toolchains=resolved_toolchains, ) @@ -230,22 +242,23 @@ def _genrule_impl( out = io.StringIO() out.write(f"\n# genrule({_target.as_label()})\n") - _emit_make_directory(out, out_dirs) + if out_dirs: + out.write(f"file(MAKE_DIRECTORY {quote_path_list(sorted(out_dirs))})\n") emit_genrule( out, "genrule__" + cmake_target_pair.target, generated_files=out_files, - add_dependencies=cmake_deps, + add_dependencies=add_dependencies, cmd_text=cmd_text, message=message_text, ) emit_filegroup( out, - cmake_target_pair.target, - out_files, - repo.source_directory, - repo.cmake_binary_dir, + cmake_name=cmake_target_pair.target, + filegroup_files=out_files, + source_directory=repo.source_directory, + cmake_binary_dir=repo.cmake_binary_dir, add_dependencies=[CMakeTarget("genrule__" + cmake_target_pair.target)], ) _context.access(CMakeBuilder).addtext(out.getvalue()) diff --git a/tools/cmake/bazel_to_cmake/native_rules_proto.py b/tools/cmake/bazel_to_cmake/native_rules_proto.py index 074186533..d022b0b94 100644 --- a/tools/cmake/bazel_to_cmake/native_rules_proto.py +++ b/tools/cmake/bazel_to_cmake/native_rules_proto.py @@ -62,20 +62,19 @@ from typing import List, Optional from .cmake_builder import CMakeBuilder -from .cmake_target import CMakeTarget +from .cmake_provider import default_providers from .emit_cc import construct_cc_includes +from .emit_filegroup import emit_filegroup from .evaluation import EvaluationState from .native_aspect import invoke_proto_aspects from .starlark.bazel_build_file import register_native_build_rule from .starlark.bazel_target import RepositoryId from .starlark.bazel_target import TargetId +from .starlark.common_providers import FilesProvider from .starlark.common_providers import ProtoLibraryProvider from .starlark.invocation_context import InvocationContext from .starlark.label import RelativeLabel from .starlark.provider import TargetInfo -from .util import quote_list -from .util import quote_path -from .util import quote_path_list PROTO_REPO = RepositoryId("com_google_protobuf") @@ -131,25 +130,20 @@ def maybe_set_import_var(d: TargetId): # Validate src properties: files ending in .proto within the same repo, # and add them to the proto_src_files. - cmake_deps: List[CMakeTarget] = [] - proto_src_files: List[str] = state.get_file_paths(resolved_srcs, cmake_deps) + srcs_collector = state.collect_targets(resolved_srcs) + proto_src_files = sorted(set(srcs_collector.file_paths())) + for proto in resolved_srcs: assert proto.target_name.endswith(".proto"), f"{proto} must end in .proto" # Verify that the source is in the same repository as the proto_library rule assert proto.repository_id == _target.repository_id maybe_set_import_var(proto) - proto_src_files = sorted(set(proto_src_files)) - # Resolve deps. When using system protobuffers, well-known-proto targets need # 'Protobuf_IMPORT_DIRS' added to their transitive includes. - import_var: str = "" - import_targets: List[CMakeTarget] = [] - for d in resolved_deps: - maybe_set_import_var(d) - import_targets.extend(state.get_dep(d, False)) - - import_targets = list(sorted(set(import_targets))) + for t in resolved_deps: + maybe_set_import_var(t) + deps_collector = state.collect_deps(resolved_deps, alias=False) # In order to propagate the includes to our compile targets, each # proto_library() becomes a custom CMake target which contains an @@ -166,47 +160,34 @@ def maybe_set_import_var(d: TargetId): assert repo is not None # strip_import_prefix and import_prefix behave the same as for cc_library - includes = construct_cc_includes( - repo, - _context.caller_package_id, - includes=None, - include_prefix=import_prefix, - strip_include_prefix=strip_import_prefix, - known_include_files=proto_src_files, + includes = repo.replace_with_cmake_macro_dirs( + construct_cc_includes( + _context.caller_package_id, + source_directory=repo.source_directory, + cmake_binary_dir=repo.cmake_binary_dir, + includes=None, + include_prefix=import_prefix, + strip_include_prefix=strip_import_prefix, + known_include_files=proto_src_files, + ) ) # Sanity check; if there are sources, then there should be includes. if proto_src_files: assert includes - relative_src_files = repo.replace_with_cmake_macro_dirs(proto_src_files) - out = io.StringIO() - out.write(f""" -# proto_library({_target.as_label()}) -add_library({cmake_target_pair.target} INTERFACE) -""") - if relative_src_files: - out.write( - f"target_sources({cmake_target_pair.target} INTERFACE" - f"{_SEP}{quote_path_list(sorted(relative_src_files), _SEP)})\n" - ) - if import_targets: - out.write( - f"target_link_libraries({cmake_target_pair.target} INTERFACE" - f"{_SEP}{quote_list(import_targets, _SEP)})\n" - ) - - if includes or import_var: - out.write( - f"target_include_directories({cmake_target_pair.target} INTERFACE" - ) - if import_var: - out.write(f"\n {import_var}") - for x in sorted(includes): - out.write(f"\n {quote_path(x)}") - out.write(")\n") - + out.write(f"\n# proto_library({_target.as_label()})\n") + emit_filegroup( + out, + cmake_name=cmake_target_pair.target, + filegroup_files=repo.replace_with_cmake_macro_dirs(proto_src_files), + source_directory=repo.source_directory, + cmake_binary_dir=repo.cmake_binary_dir, + add_dependencies=list(srcs_collector.add_dependencies()), + link_libraries=deps_collector.link_libraries(), + includes=set(includes), + ) if cmake_target_pair.alias is not None: out.write( f"add_library({cmake_target_pair.alias} ALIAS" @@ -217,9 +198,14 @@ def maybe_set_import_var(d: TargetId): _context.add_analyzed_target( _target, TargetInfo( - *cmake_target_pair.as_providers(), + *default_providers(cmake_target_pair), + FilesProvider(proto_src_files), ProtoLibraryProvider( - resolved_srcs, resolved_deps, strip_import_prefix + _target, + resolved_srcs, + resolved_deps, + strip_import_prefix, + import_prefix, ), ), ) diff --git a/tools/cmake/bazel_to_cmake/provider_util.py b/tools/cmake/bazel_to_cmake/provider_util.py new file mode 100644 index 000000000..7327bf83a --- /dev/null +++ b/tools/cmake/bazel_to_cmake/provider_util.py @@ -0,0 +1,97 @@ +# Copyright 2024 The TensorStore Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Provides a collector interface for aggregating dependencies. + +Example: + from .starlark.common_provider import FilesProvider + from .provider_util import ProviderCollection + + srcs_collector = ProviderCollection(FilesProvider) + state.collect_targets(resolved_srcs, srcs_collector) + + srcs = sorted(srcs_collector.file_paths()) +""" + +# pylint: disable=missing-function-docstring,relative-beyond-top-level,missing-class-docstring + +from typing import Iterator, Type, TypeVar + +from .cmake_provider import CMakeAddDependenciesProvider +from .cmake_provider import CMakeExecutableTargetProvider +from .cmake_provider import CMakeHallucinatedTarget +from .cmake_provider import CMakeLinkLibrariesProvider +from .cmake_target import CMakeTarget +from .starlark.bazel_target import TargetId +from .starlark.common_providers import FilesProvider +from .starlark.provider import Provider +from .starlark.provider import TargetInfo + +P = TypeVar('P', bound=Provider) + + +class ProviderCollection: + """Collects TargetInfo for multiple targets.""" + + __slots__ = ('_providers', '_assertions') + + def __init__(self): + self._providers = {} + + def __repr__(self): + return f'{self.__class__.__name__}(providers={self._providers})' + + def collect(self, target_id: TargetId, target_info: TargetInfo): + self._providers[target_id] = target_info + + def assert_provider(self, t: Type[P]): + failed = [] + for target_id, target_info in self._providers.items(): + if target_info.get(t) is None: + failed.append(target_id.as_label()) + if failed: + raise ValueError( + f'Failed to collect type {t.__name__} from Targets {" ".join(failed)}' + ) + + def items(self, t: Type[P]) -> Iterator[P]: + for x in self._providers.values(): + provider = x.get(t) + if provider is not None: + yield provider + + def targets(self) -> Iterator[CMakeTarget]: + seen = set() + for t in ( + CMakeHallucinatedTarget, + CMakeAddDependenciesProvider, + CMakeLinkLibrariesProvider, + CMakeExecutableTargetProvider, + ): + for provider in self.items(t): + if provider.target not in seen: + seen.add(provider.target) + yield provider.target + + def file_paths(self) -> Iterator[str]: + for files_provider in self.items(FilesProvider): + yield from files_provider.paths + + def add_dependencies(self) -> Iterator[CMakeTarget]: + for add_dependencies_provider in self.items(CMakeAddDependenciesProvider): + yield add_dependencies_provider.target + + def link_libraries(self) -> Iterator[CMakeTarget]: + for t in (CMakeHallucinatedTarget, CMakeLinkLibrariesProvider): + for provider in self.items(t): + yield provider.target diff --git a/tools/cmake/bazel_to_cmake/starlark/common_providers.py b/tools/cmake/bazel_to_cmake/starlark/common_providers.py index 63fa031f4..8ddbab570 100644 --- a/tools/cmake/bazel_to_cmake/starlark/common_providers.py +++ b/tools/cmake/bazel_to_cmake/starlark/common_providers.py @@ -15,12 +15,18 @@ # pylint: disable=missing-function-docstring,relative-beyond-top-level -from typing import Any, List, Optional +import pathlib +from typing import Any, Iterable, Optional, TypeVar from .bazel_target import TargetId from .provider import Provider +PathLike = TypeVar( + "PathLike", str, pathlib.Path, pathlib.PurePath, pathlib.PurePosixPath +) + + class BuildSettingProvider(Provider): """Build setting value (i.e. flag value) corresponding to a Bazel target.""" @@ -50,28 +56,42 @@ class FilesProvider(Provider): __slots__ = ("paths",) - def __init__(self, paths: List[str]): - self.paths = paths + def __init__(self, paths: Iterable[PathLike]): + self.paths = [str(x) for x in paths] def __repr__(self): return f"{self.__class__.__name__}({repr(self.paths)})" class ProtoLibraryProvider(Provider): - __slots__ = ("srcs", "deps", "strip_import_prefix") + __slots__ = ( + "bazel_target", + "srcs", + "deps", + "strip_import_prefix", + "import_prefix", + ) def __init__( self, - srcs: List[TargetId], - deps: List[TargetId], + bazel_target: TargetId, + srcs: Iterable[TargetId], + deps: Iterable[TargetId], strip_import_prefix: Optional[str], + import_prefix: Optional[str], ): - self.srcs = sorted(set(srcs)) - self.deps = sorted(set(deps)) + self.bazel_target = bazel_target + self.srcs = set(srcs) + self.deps = set(deps) self.strip_import_prefix = strip_import_prefix + self.import_prefix = import_prefix def __repr__(self): return ( - f"{self.__class__.__name__}({repr(self.srcs)}, {repr(self.deps)}," - f" {repr(self.strip_import_prefix)})" + f"{self.__class__.__name__}(" + f"{repr(self.bazel_target)}," + f"{repr(self.srcs)}," + f"{repr(self.deps)}," + f"{repr(self.strip_import_prefix)}," + f"{repr(self.import_prefix)})" ) diff --git a/tools/cmake/bazel_to_cmake/starlark/provider.py b/tools/cmake/bazel_to_cmake/starlark/provider.py index 064663adf..9f968e1f8 100644 --- a/tools/cmake/bazel_to_cmake/starlark/provider.py +++ b/tools/cmake/bazel_to_cmake/starlark/provider.py @@ -18,7 +18,7 @@ # pylint: disable=missing-function-docstring,relative-beyond-top-level,missing-class-docstring -from typing import Optional, Type, TypeVar, cast +from typing import Optional, Tuple, Type, TypeVar, cast class Provider: @@ -26,6 +26,7 @@ class Provider: P = TypeVar('P', bound=Provider) +ProviderTuple = Tuple[Provider, ...] class TargetInfo: @@ -48,6 +49,9 @@ def get(self, provider_type: Type[P]) -> Optional[P]: def __iter__(self): return iter(self._providers.values()) + def __tuple__(self): + return tuple(self._providers.values()) + def __repr__(self): return ( '{' + ', '.join(repr(value) for value in self._providers.values()) + '}' diff --git a/tools/cmake/bazel_to_cmake/testdata/bazel_skylib/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/bazel_skylib/golden/_srcdir/build_rules.cmake index ed3fbb17f..cd0e9ac77 100644 --- a/tools/cmake/bazel_to_cmake/testdata/bazel_skylib/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/bazel_skylib/golden/_srcdir/build_rules.cmake @@ -1,13 +1,14 @@ # bazel_to_cmake wrote ${TEST_BINDIR}/config.h +# expand_template(@bazel_skylib_test_repo//:config2_h) add_custom_command( OUTPUT "${TEST_BINDIR}/config2.h" COMMAND ${Python3_EXECUTABLE} "${SCRIPT_DIRECTORY}/bzl_library/expand_template.py" "${TEST_BINDIR}/config.h" "${TEST_BINDIR}/CMakeProject_config2_h.subs.json" "${TEST_BINDIR}/config2.h" -DEPENDS "${TEST_BINDIR}/config.h" "${SCRIPT_DIRECTORY}/bzl_library/expand_template.py" "${TEST_BINDIR}/CMakeProject_config2_h.subs.json" +DEPENDS "${SCRIPT_DIRECTORY}/bzl_library/expand_template.py" "${TEST_BINDIR}/CMakeProject_config2_h.subs.json" "${TEST_BINDIR}/config.h" VERBATIM ) add_custom_target(CMakeProject_config2_h DEPENDS "${TEST_BINDIR}/config2.h") @@ -28,6 +29,6 @@ add_custom_target(genrule__CMakeProject_config_copy_rule DEPENDS add_library(CMakeProject_config_copy_rule INTERFACE) target_sources(CMakeProject_config_copy_rule INTERFACE "${TEST_BINDIR}/config3.h") -set_property(TARGET CMakeProject_config_copy_rule PROPERTY INTERFACE_INCLUDE_DIRECTORIES +target_include_directories(CMakeProject_config_copy_rule INTERFACE "${PROJECT_BINARY_DIR}") add_dependencies(CMakeProject_config_copy_rule genrule__CMakeProject_config_copy_rule) diff --git a/tools/cmake/bazel_to_cmake/testdata/cc_includes/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/cc_includes/golden/_srcdir/build_rules.cmake index 2fe23bd6c..3463c10b1 100644 --- a/tools/cmake/bazel_to_cmake/testdata/cc_includes/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/cc_includes/golden/_srcdir/build_rules.cmake @@ -14,7 +14,7 @@ add_custom_target(genrule__CMakeProject_parent_c_inc DEPENDS add_library(CMakeProject_parent_c_inc INTERFACE) target_sources(CMakeProject_parent_c_inc INTERFACE "${TEST_BINDIR}/parent/child/c.inc") -set_property(TARGET CMakeProject_parent_c_inc PROPERTY INTERFACE_INCLUDE_DIRECTORIES +target_include_directories(CMakeProject_parent_c_inc INTERFACE "${PROJECT_BINARY_DIR}") add_dependencies(CMakeProject_parent_c_inc genrule__CMakeProject_parent_c_inc) diff --git a/tools/cmake/bazel_to_cmake/testdata/grpc_generate_cc/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/grpc_generate_cc/golden/_srcdir/build_rules.cmake index aeca53a50..d318fd502 100644 --- a/tools/cmake/bazel_to_cmake/testdata/grpc_generate_cc/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/grpc_generate_cc/golden/_srcdir/build_rules.cmake @@ -4,65 +4,128 @@ find_package(gRPC REQUIRED) # proto_library(@grpc_generate_cc_test_repo//:c_proto) add_library(CMakeProject_c_proto INTERFACE) target_sources(CMakeProject_c_proto INTERFACE - "${PROJECT_SOURCE_DIR}/c.proto") + "${PROJECT_SOURCE_DIR}/c.proto") target_include_directories(CMakeProject_c_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::c_proto ALIAS CMakeProject_c_proto) +# @grpc_generate_cc_test_repo//:aspect_upb__71950a86 +# genproto upb @grpc_generate_cc_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/c.upb.h" + "${TEST_BINDIR}/_gen_upb/c.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "${TEST_SRCDIR}/c.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb__71950a86 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/c.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/c.upb.c") +add_library(CMakeProject_aspect_upb__71950a86 INTERFACE) +target_sources(CMakeProject_aspect_upb__71950a86 INTERFACE + "${TEST_BINDIR}/_gen_upb/c.upb.c" + "${TEST_BINDIR}/_gen_upb/c.upb.h") +target_include_directories(CMakeProject_aspect_upb__71950a86 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__71950a86 genrule__CMakeProject_aspect_upb__71950a86) + +# @grpc_generate_cc_test_repo//:aspect_upb_minitable__71950a86 +# genproto upb_minitable @grpc_generate_cc_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "${TEST_SRCDIR}/c.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__71950a86 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/c.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/c.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__71950a86 INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__71950a86 INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__71950a86 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__71950a86 genrule__CMakeProject_aspect_upb_minitable__71950a86) + # @grpc_generate_cc_test_repo//:c_proto__minitable_library +# aspect upb_minitable @grpc_generate_cc_test_repo//:c_proto add_library(CMakeProject_c_proto__minitable_library) set_property(TARGET CMakeProject_c_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_c_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_c_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_c_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/c.upb_minitable.c") add_library(CMakeProject::c_proto__minitable_library ALIAS CMakeProject_c_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_c_proto__minitable_library - PROTO_TARGET CMakeProject_c_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/bdf6942a - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" -) - # @grpc_generate_cc_test_repo//:c_proto__upb_library +# aspect upb @grpc_generate_cc_test_repo//:c_proto add_library(CMakeProject_c_proto__upb_library) set_property(TARGET CMakeProject_c_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_c_proto__upb_library PUBLIC "CMakeProject::c_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_c_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_c_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/c.upb.c") add_library(CMakeProject::c_proto__upb_library ALIAS CMakeProject_c_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_c_proto__upb_library - PROTO_TARGET CMakeProject_c_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/bdf6942a - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" +# @grpc_generate_cc_test_repo//:cc__grpc_codegenfile(MAKE_DIRECTORY "${TEST_BINDIR}") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/c.grpc.pb.h" + "${TEST_BINDIR}/c.grpc.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-grpc=$ + "-I$,$-I>" + "--grpc_out=services_namespace=grpc_gen:${PROJECT_BINARY_DIR}" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "${TEST_SRCDIR}/c.proto" + "protobuf::protoc" + "gRPC::grpc_cpp_plugin" +COMMENT "Running protoc grpc on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) - -# @grpc_generate_cc_test_repo//:cc__grpc_codegen -add_custom_target(CMakeProject_cc__grpc_codegen) - -btc_protobuf( - TARGET CMakeProject_cc__grpc_codegen - PROTO_TARGET CMakeProject_c_proto - LANGUAGE grpc - GENERATE_EXTENSIONS ".grpc.pb.h" ".grpc.pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR} - PLUGIN protoc-gen-grpc=$ - PLUGIN_OPTIONS "services_namespace=grpc_gen" - DEPENDS "CMakeProject_c_proto__upb_library" "gRPC::grpc_cpp_plugin" "protobuf::protoc" -) - +add_custom_target(CMakeProject_cc__grpc_codegen DEPENDS + "${TEST_BINDIR}/c.grpc.pb.h" + "${TEST_BINDIR}/c.grpc.pb.cc") # cc_library(@grpc_generate_cc_test_repo//:cc_grpc) add_library(CMakeProject_cc_grpc) @@ -76,7 +139,6 @@ target_include_directories(CMakeProject_cc_grpc PUBLIC target_include_directories(CMakeProject_cc_grpc PRIVATE "$") target_compile_features(CMakeProject_cc_grpc PUBLIC cxx_std_17) -add_dependencies(CMakeProject_cc_grpc "CMakeProject_cc__grpc_codegen") target_sources(CMakeProject_cc_grpc PRIVATE "${PROJECT_BINARY_DIR}/c.grpc.pb.cc") add_library(CMakeProject::cc_grpc ALIAS CMakeProject_cc_grpc) @@ -95,41 +157,96 @@ target_sources(CMakeProject_a PRIVATE "${PROJECT_SOURCE_DIR}/a.cc") add_library(CMakeProject::a ALIAS CMakeProject_a) +# @grpc_generate_cc_test_repo//:aspect_cpp__71950a86 +# genproto cpp @grpc_generate_cc_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/c.pb.h" + "${TEST_BINDIR}/_gen_cpp/c.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "${TEST_SRCDIR}/c.proto" + "protobuf::protoc" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__71950a86 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") +add_library(CMakeProject_aspect_cpp__71950a86 INTERFACE) +target_sources(CMakeProject_aspect_cpp__71950a86 INTERFACE + "${TEST_BINDIR}/_gen_cpp/c.pb.cc" + "${TEST_BINDIR}/_gen_cpp/c.pb.h") +target_include_directories(CMakeProject_aspect_cpp__71950a86 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__71950a86 genrule__CMakeProject_aspect_cpp__71950a86) + # @grpc_generate_cc_test_repo//:c_proto__cpp_library +# aspect cpp @grpc_generate_cc_test_repo//:c_proto add_library(CMakeProject_c_proto__cpp_library) set_property(TARGET CMakeProject_c_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_c_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_c_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_c_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") add_library(CMakeProject::c_proto__cpp_library ALIAS CMakeProject_c_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_c_proto__cpp_library - PROTO_TARGET CMakeProject_c_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/bdf6942a - DEPENDS "protobuf::protoc" +# @grpc_generate_cc_test_repo//:aspect_upbdefs__71950a86 +# genproto upbdefs @grpc_generate_cc_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "${TEST_SRCDIR}/c.proto" + "protobuf::protoc_gen_upbdefs" + "protobuf::protoc" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__71950a86 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/c.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/c.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__71950a86 INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__71950a86 INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__71950a86 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__71950a86 genrule__CMakeProject_aspect_upbdefs__71950a86) # @grpc_generate_cc_test_repo//:c_proto__upbdefs_library +# aspect upbdefs @grpc_generate_cc_test_repo//:c_proto add_library(CMakeProject_c_proto__upbdefs_library) set_property(TARGET CMakeProject_c_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_c_proto__upbdefs_library PUBLIC "CMakeProject::c_proto__minitable_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_c_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_c_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/c.upbdefs.c") add_library(CMakeProject::c_proto__upbdefs_library ALIAS CMakeProject_c_proto__upbdefs_library) - -btc_protobuf( - TARGET CMakeProject_c_proto__upbdefs_library - PROTO_TARGET CMakeProject_c_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/bdf6942a - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) diff --git a/tools/cmake/bazel_to_cmake/testdata/native_rules/config.json b/tools/cmake/bazel_to_cmake/testdata/native_rules/config.json index 00f3810e6..35e3a9064 100644 --- a/tools/cmake/bazel_to_cmake/testdata/native_rules/config.json +++ b/tools/cmake/bazel_to_cmake/testdata/native_rules/config.json @@ -22,5 +22,8 @@ "//subdir:y_strip_include_prefix", "//subdir:z_proto__cpp_library", "//:defines" + ], + "excludes": [ + "_bindir/bazel_to_cmake_empty_source.cc" ] } diff --git a/tools/cmake/bazel_to_cmake/testdata/native_rules/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/native_rules/golden/_srcdir/build_rules.cmake index fa6325158..68fb65d7c 100644 --- a/tools/cmake/bazel_to_cmake/testdata/native_rules/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/native_rules/golden/_srcdir/build_rules.cmake @@ -16,7 +16,7 @@ target_sources(CMakeProject_bb PRIVATE add_library(CMakeProject_subdir_z INTERFACE) target_sources(CMakeProject_subdir_z INTERFACE "${TEST_SRCDIR}/subdir/z.proto") -set_property(TARGET CMakeProject_subdir_z PROPERTY INTERFACE_IMPORTS +target_include_directories(CMakeProject_subdir_z INTERFACE "${PROJECT_SOURCE_DIR}") # genrule(@native_rules_test_repo//:h_file) @@ -26,7 +26,7 @@ add_custom_command( DEPENDS "${TEST_SRCDIR}/x.h" "CMakeProject::bb" - COMMAND $ ./a . -I${TEST_BINDIR}/foo -Isubdir/../.. "x.h" "${TEST_BINDIR}/a.h" + COMMAND $ ./a . -I${TEST_BINDIR}/foo -Isubdir/../.. "x.h" "${TEST_BINDIR}/a.h" VERBATIM WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" ) @@ -35,7 +35,7 @@ add_custom_target(genrule__CMakeProject_h_file DEPENDS add_library(CMakeProject_h_file INTERFACE) target_sources(CMakeProject_h_file INTERFACE "${TEST_BINDIR}/a.h") -set_property(TARGET CMakeProject_h_file PROPERTY INTERFACE_INCLUDE_DIRECTORIES +target_include_directories(CMakeProject_h_file INTERFACE "${PROJECT_BINARY_DIR}") add_dependencies(CMakeProject_h_file genrule__CMakeProject_h_file) @@ -62,38 +62,73 @@ add_library(CMakeProject::a_alias ALIAS CMakeProject_a) # proto_library(@native_rules_test_repo//:c_proto) add_library(CMakeProject_c_proto INTERFACE) target_sources(CMakeProject_c_proto INTERFACE - "${PROJECT_SOURCE_DIR}/c.proto") -target_link_libraries(CMakeProject_c_proto INTERFACE - "Protobuf_timestamp_proto") + "${PROJECT_SOURCE_DIR}/c.proto") target_include_directories(CMakeProject_c_proto INTERFACE - ${Protobuf_IMPORT_DIRS} - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") +target_link_libraries(CMakeProject_c_proto INTERFACE + "Protobuf_timestamp_proto") add_library(CMakeProject::c_proto ALIAS CMakeProject_c_proto) +# @native_rules_test_repo//:aspect_cpp__2c7be24c +# genproto cpp @native_rules_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/c.pb.h" + "${TEST_BINDIR}/_gen_cpp/c.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "protobuf::protoc" + "${TEST_SRCDIR}/c.proto" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__2c7be24c DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") +add_library(CMakeProject_aspect_cpp__2c7be24c INTERFACE) +target_sources(CMakeProject_aspect_cpp__2c7be24c INTERFACE + "${TEST_BINDIR}/_gen_cpp/c.pb.cc" + "${TEST_BINDIR}/_gen_cpp/c.pb.h") +target_include_directories(CMakeProject_aspect_cpp__2c7be24c INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__2c7be24c genrule__CMakeProject_aspect_cpp__2c7be24c) + # @native_rules_test_repo//:c_proto__cpp_library +# aspect cpp @native_rules_test_repo//:c_proto add_library(CMakeProject_c_proto__cpp_library) set_property(TARGET CMakeProject_c_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_c_proto__cpp_library PUBLIC "Protobuf::timestamp_proto__cpp_library" + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_c_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_c_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") add_library(CMakeProject::c_proto__cpp_library ALIAS CMakeProject_c_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_c_proto__cpp_library - PROTO_TARGET CMakeProject_c_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/de6f8ca9 - DEPENDS "protobuf::protoc" -) - # cc_proto_library(@native_rules_test_repo//:c_proto_cc) -add_library(CMakeProject_c_proto_cc INTERFACE) -target_link_libraries(CMakeProject_c_proto_cc INTERFACE - "CMakeProject::c_proto__cpp_library") -target_compile_features(CMakeProject_c_proto_cc INTERFACE cxx_std_17) +add_library(CMakeProject_c_proto_cc) +set_property(TARGET CMakeProject_c_proto_cc PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_c_proto_cc PUBLIC + "CMakeProject::c_proto" + "CMakeProject::c_proto__cpp_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_c_proto_cc PRIVATE + "$") +target_compile_features(CMakeProject_c_proto_cc PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto_cc PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::c_proto_cc ALIAS CMakeProject_c_proto_cc) # cc_test(@native_rules_test_repo//:a_test) @@ -108,34 +143,33 @@ target_include_directories(CMakeProject_a_test PRIVATE target_compile_features(CMakeProject_a_test PUBLIC cxx_std_17) target_sources(CMakeProject_a_test PRIVATE "${PROJECT_SOURCE_DIR}/a.cc") -add_test(NAME CMakeProject_a_test COMMAND CMakeProject_a_test WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) +add_test(NAME CMakeProject_a_test + COMMAND CMakeProject_a_test + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) # proto_library(@native_rules_test_repo//:c_proto_2) add_library(CMakeProject_c_proto_2 INTERFACE) target_sources(CMakeProject_c_proto_2 INTERFACE - "${PROJECT_SOURCE_DIR}/c.proto") + "${PROJECT_SOURCE_DIR}/c.proto") target_include_directories(CMakeProject_c_proto_2 INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::c_proto_2 ALIAS CMakeProject_c_proto_2) # @native_rules_test_repo//:c_proto_2__cpp_library +# aspect cpp @native_rules_test_repo//:c_proto_2 add_library(CMakeProject_c_proto_2__cpp_library) set_property(TARGET CMakeProject_c_proto_2__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_c_proto_2__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_c_proto_2__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_c_proto_2__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_c_proto_2__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") add_library(CMakeProject::c_proto_2__cpp_library ALIAS CMakeProject_c_proto_2__cpp_library) -btc_protobuf( - TARGET CMakeProject_c_proto_2__cpp_library - PROTO_TARGET CMakeProject_c_proto_2 - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/c5077a10 - DEPENDS "protobuf::protoc" -) - # alias(@native_rules_test_repo//:c_proto_alias) add_library(CMakeProject_c_proto_alias ALIAS CMakeProject_c_proto) add_library(CMakeProject::c_proto_alias ALIAS CMakeProject_c_proto) @@ -164,7 +198,7 @@ add_custom_command( "${TEST_BINDIR}/subdir/y.cc" DEPENDS "CMakeProject::bb" - COMMAND $ "${TEST_BINDIR}/subdir/y.cc" + COMMAND $ "${TEST_BINDIR}/subdir/y.cc" VERBATIM WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" ) @@ -173,7 +207,7 @@ add_custom_target(genrule__CMakeProject_subdir_make_ycc DEPENDS add_library(CMakeProject_subdir_make_ycc INTERFACE) target_sources(CMakeProject_subdir_make_ycc INTERFACE "${TEST_BINDIR}/subdir/y.cc") -set_property(TARGET CMakeProject_subdir_make_ycc PROPERTY INTERFACE_INCLUDE_DIRECTORIES +target_include_directories(CMakeProject_subdir_make_ycc INTERFACE "${PROJECT_BINARY_DIR}") add_dependencies(CMakeProject_subdir_make_ycc genrule__CMakeProject_subdir_make_ycc) @@ -184,7 +218,7 @@ add_custom_command( "${TEST_BINDIR}/subdir/y.h" DEPENDS "CMakeProject::bb" - COMMAND $ "${TEST_BINDIR}/subdir/y.h" + COMMAND $ "${TEST_BINDIR}/subdir/y.h" VERBATIM WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" ) @@ -193,7 +227,7 @@ add_custom_target(genrule__CMakeProject_subdir_make_y DEPENDS add_library(CMakeProject_subdir_make_y INTERFACE) target_sources(CMakeProject_subdir_make_y INTERFACE "${TEST_BINDIR}/subdir/y.h") -set_property(TARGET CMakeProject_subdir_make_y PROPERTY INTERFACE_INCLUDE_DIRECTORIES +target_include_directories(CMakeProject_subdir_make_y INTERFACE "${PROJECT_BINARY_DIR}") add_dependencies(CMakeProject_subdir_make_y genrule__CMakeProject_subdir_make_y) @@ -271,29 +305,56 @@ add_library(CMakeProject::subdir_y_strip_include_prefix ALIAS CMakeProject_subdi # proto_library(@native_rules_test_repo//subdir:z_proto) add_library(CMakeProject_subdir_z_proto INTERFACE) target_sources(CMakeProject_subdir_z_proto INTERFACE - "${PROJECT_SOURCE_DIR}/subdir/z.proto") + "${PROJECT_SOURCE_DIR}/subdir/z.proto") target_include_directories(CMakeProject_subdir_z_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::subdir_z_proto ALIAS CMakeProject_subdir_z_proto) +# @native_rules_test_repo//subdir:aspect_cpp__2eff1b8c +# genproto cpp @native_rules_test_repo//subdir:z.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp/subdir") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/subdir/z.pb.h" + "${TEST_BINDIR}/_gen_cpp/subdir/z.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/subdir/z.proto" +DEPENDS + "${TEST_SRCDIR}/subdir/z.proto" + "protobuf::protoc" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/subdir/z.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_subdir_aspect_cpp__2eff1b8c DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/subdir/z.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/subdir/z.pb.cc") +add_library(CMakeProject_subdir_aspect_cpp__2eff1b8c INTERFACE) +target_sources(CMakeProject_subdir_aspect_cpp__2eff1b8c INTERFACE + "${TEST_BINDIR}/_gen_cpp/subdir/z.pb.cc" + "${TEST_BINDIR}/_gen_cpp/subdir/z.pb.h") +target_include_directories(CMakeProject_subdir_aspect_cpp__2eff1b8c INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_subdir_aspect_cpp__2eff1b8c genrule__CMakeProject_subdir_aspect_cpp__2eff1b8c) + # @native_rules_test_repo//subdir:z_proto__cpp_library +# aspect cpp @native_rules_test_repo//subdir:z_proto add_library(CMakeProject_subdir_z_proto__cpp_library) set_property(TARGET CMakeProject_subdir_z_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_subdir_z_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_subdir_z_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_subdir_z_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_subdir_z_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/subdir/z.pb.cc") add_library(CMakeProject::subdir_z_proto__cpp_library ALIAS CMakeProject_subdir_z_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_subdir_z_proto__cpp_library - PROTO_TARGET CMakeProject_subdir_z_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/fb9b71f5 - DEPENDS "protobuf::protoc" -) - # cc_library(@native_rules_test_repo//:defines) add_library(CMakeProject_defines) set_property(TARGET CMakeProject_defines PROPERTY LINKER_LANGUAGE "CXX") diff --git a/tools/cmake/bazel_to_cmake/testdata/rules_nasm/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/rules_nasm/golden/_srcdir/build_rules.cmake index 260346fb3..616676974 100644 --- a/tools/cmake/bazel_to_cmake/testdata/rules_nasm/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/rules_nasm/golden/_srcdir/build_rules.cmake @@ -1,4 +1,3 @@ -add_library(CMakeProject_asm_library) get_filename_component(_nasm_compiler_barename "${CMAKE_ASM_NASM_COMPILER}" NAME) if (_nasm_compiler_barename STREQUAL "yasm") @@ -6,8 +5,12 @@ if (_nasm_compiler_barename STREQUAL "yasm") endif() unset(_nasm_compiler_barename) + +# nasm_library(@rules_nasm_test_repo//:asm_library) +add_library(CMakeProject_asm_library) target_sources(CMakeProject_asm_library PRIVATE "${TEST_SRCDIR}/a.asm") -target_include_directories(CMakeProject_asm_library PRIVATE "${TEST_SRCDIR}" "${TEST_SRCDIR}/include") +target_include_directories(CMakeProject_asm_library PRIVATE "${TEST_SRCDIR}" + "${TEST_SRCDIR}/include") set_source_files_properties( "${TEST_SRCDIR}/a.asm" PROPERTIES diff --git a/tools/cmake/bazel_to_cmake/testdata/rules_proto/config.json b/tools/cmake/bazel_to_cmake/testdata/rules_proto/config.json index 6f06e3d37..20c251699 100644 --- a/tools/cmake/bazel_to_cmake/testdata/rules_proto/config.json +++ b/tools/cmake/bazel_to_cmake/testdata/rules_proto/config.json @@ -28,5 +28,8 @@ "//:x_proto_cc", "//:y_proto__cpp_library", "//:y_proto__upb_library" + ], + "excludes": [ + "_bindir/bazel_to_cmake_empty_source.cc" ] } diff --git a/tools/cmake/bazel_to_cmake/testdata/rules_proto/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/rules_proto/golden/_srcdir/build_rules.cmake index 8812f233c..faad8e354 100644 --- a/tools/cmake/bazel_to_cmake/testdata/rules_proto/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/rules_proto/golden/_srcdir/build_rules.cmake @@ -3,301 +3,712 @@ find_package(Protobuf REQUIRED) # proto_library(@rules_proto_test_repo//:a_proto) add_library(CMakeProject_a_proto INTERFACE) target_sources(CMakeProject_a_proto INTERFACE - "${PROJECT_SOURCE_DIR}/a.proto") + "${PROJECT_SOURCE_DIR}/a.proto") target_include_directories(CMakeProject_a_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::a_proto ALIAS CMakeProject_a_proto) +# @rules_proto_test_repo//:aspect_cpp__43b0bcf1 +# genproto cpp @rules_proto_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/a.pb.h" + "${TEST_BINDIR}/_gen_cpp/a.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "${TEST_SRCDIR}/a.proto" + "protobuf::protoc" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__43b0bcf1 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.cc") +add_library(CMakeProject_aspect_cpp__43b0bcf1 INTERFACE) +target_sources(CMakeProject_aspect_cpp__43b0bcf1 INTERFACE + "${TEST_BINDIR}/_gen_cpp/a.pb.cc" + "${TEST_BINDIR}/_gen_cpp/a.pb.h") +target_include_directories(CMakeProject_aspect_cpp__43b0bcf1 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__43b0bcf1 genrule__CMakeProject_aspect_cpp__43b0bcf1) + # @rules_proto_test_repo//:a_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:a_proto add_library(CMakeProject_a_proto__cpp_library) set_property(TARGET CMakeProject_a_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_a_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.cc") add_library(CMakeProject::a_proto__cpp_library ALIAS CMakeProject_a_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_a_proto__cpp_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/7647136c - DEPENDS "protobuf::protoc" +# @rules_proto_test_repo//:aspect_upb_minitable__43b0bcf1 +# genproto upb_minitable @rules_proto_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "${TEST_SRCDIR}/a.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__43b0bcf1 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__43b0bcf1 INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__43b0bcf1 INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__43b0bcf1 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__43b0bcf1 genrule__CMakeProject_aspect_upb_minitable__43b0bcf1) # @rules_proto_test_repo//:a_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:a_proto add_library(CMakeProject_a_proto__minitable_library) set_property(TARGET CMakeProject_a_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_a_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.c") add_library(CMakeProject::a_proto__minitable_library ALIAS CMakeProject_a_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_a_proto__minitable_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/7647136c - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" +# @rules_proto_test_repo//:aspect_upb__43b0bcf1 +# genproto upb @rules_proto_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/a.upb.h" + "${TEST_BINDIR}/_gen_upb/a.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "${TEST_SRCDIR}/a.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb__43b0bcf1 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.c") +add_library(CMakeProject_aspect_upb__43b0bcf1 INTERFACE) +target_sources(CMakeProject_aspect_upb__43b0bcf1 INTERFACE + "${TEST_BINDIR}/_gen_upb/a.upb.c" + "${TEST_BINDIR}/_gen_upb/a.upb.h") +target_include_directories(CMakeProject_aspect_upb__43b0bcf1 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__43b0bcf1 genrule__CMakeProject_aspect_upb__43b0bcf1) # @rules_proto_test_repo//:a_proto__upb_library +# aspect upb @rules_proto_test_repo//:a_proto add_library(CMakeProject_a_proto__upb_library) set_property(TARGET CMakeProject_a_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__upb_library PUBLIC "CMakeProject::a_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_a_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.c") add_library(CMakeProject::a_proto__upb_library ALIAS CMakeProject_a_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_a_proto__upb_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/7647136c - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" +# @rules_proto_test_repo//:aspect_upbdefs__43b0bcf1 +# genproto upbdefs @rules_proto_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "${TEST_SRCDIR}/a.proto" + "protobuf::protoc_gen_upbdefs" + "protobuf::protoc" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__43b0bcf1 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__43b0bcf1 INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__43b0bcf1 INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__43b0bcf1 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__43b0bcf1 genrule__CMakeProject_aspect_upbdefs__43b0bcf1) # @rules_proto_test_repo//:a_proto__upbdefs_library +# aspect upbdefs @rules_proto_test_repo//:a_proto add_library(CMakeProject_a_proto__upbdefs_library) set_property(TARGET CMakeProject_a_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__upbdefs_library PUBLIC "CMakeProject::a_proto__minitable_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_a_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.c") add_library(CMakeProject::a_proto__upbdefs_library ALIAS CMakeProject_a_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_a_proto__upbdefs_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/7647136c - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) - # proto_library(@rules_proto_test_repo//:ab_proto) add_library(CMakeProject_ab_proto INTERFACE) target_sources(CMakeProject_ab_proto INTERFACE - "${PROJECT_SOURCE_DIR}/a.proto" - "${PROJECT_SOURCE_DIR}/b.proto") + "${PROJECT_SOURCE_DIR}/a.proto" + "${PROJECT_SOURCE_DIR}/b.proto") target_include_directories(CMakeProject_ab_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::ab_proto ALIAS CMakeProject_ab_proto) +# @rules_proto_test_repo//:aspect_cpp__3daadd2b +# genproto cpp @rules_proto_test_repo//:b.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/b.pb.h" + "${TEST_BINDIR}/_gen_cpp/b.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/b.proto" +DEPENDS + "${TEST_SRCDIR}/b.proto" + "protobuf::protoc" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/b.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__3daadd2b DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/b.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/b.pb.cc") +add_library(CMakeProject_aspect_cpp__3daadd2b INTERFACE) +target_sources(CMakeProject_aspect_cpp__3daadd2b INTERFACE + "${TEST_BINDIR}/_gen_cpp/b.pb.cc" + "${TEST_BINDIR}/_gen_cpp/b.pb.h") +target_include_directories(CMakeProject_aspect_cpp__3daadd2b INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__3daadd2b genrule__CMakeProject_aspect_cpp__3daadd2b) + # @rules_proto_test_repo//:ab_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:ab_proto add_library(CMakeProject_ab_proto__cpp_library) set_property(TARGET CMakeProject_ab_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_ab_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_ab_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_ab_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_ab_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.cc" + "${PROJECT_BINARY_DIR}/_gen_cpp/b.pb.cc") add_library(CMakeProject::ab_proto__cpp_library ALIAS CMakeProject_ab_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_ab_proto__cpp_library - PROTO_TARGET CMakeProject_ab_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/3ec71571 - DEPENDS "protobuf::protoc" +# @rules_proto_test_repo//:aspect_upb__3daadd2b +# genproto upb @rules_proto_test_repo//:b.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/b.upb.h" + "${TEST_BINDIR}/_gen_upb/b.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/b.proto" +DEPENDS + "${TEST_SRCDIR}/b.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/b.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb__3daadd2b DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/b.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/b.upb.c") +add_library(CMakeProject_aspect_upb__3daadd2b INTERFACE) +target_sources(CMakeProject_aspect_upb__3daadd2b INTERFACE + "${TEST_BINDIR}/_gen_upb/b.upb.c" + "${TEST_BINDIR}/_gen_upb/b.upb.h") +target_include_directories(CMakeProject_aspect_upb__3daadd2b INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__3daadd2b genrule__CMakeProject_aspect_upb__3daadd2b) + +# @rules_proto_test_repo//:aspect_upb_minitable__3daadd2b +# genproto upb_minitable @rules_proto_test_repo//:b.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/b.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/b.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/b.proto" +DEPENDS + "${TEST_SRCDIR}/b.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/b.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__3daadd2b DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/b.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/b.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__3daadd2b INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__3daadd2b INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/b.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/b.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__3daadd2b INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__3daadd2b genrule__CMakeProject_aspect_upb_minitable__3daadd2b) # @rules_proto_test_repo//:ab_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:ab_proto add_library(CMakeProject_ab_proto__minitable_library) set_property(TARGET CMakeProject_ab_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_ab_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_ab_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_ab_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_ab_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.c" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/b.upb_minitable.c") add_library(CMakeProject::ab_proto__minitable_library ALIAS CMakeProject_ab_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_ab_proto__minitable_library - PROTO_TARGET CMakeProject_ab_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/3ec71571 - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" -) - # @rules_proto_test_repo//:ab_proto__upb_library +# aspect upb @rules_proto_test_repo//:ab_proto add_library(CMakeProject_ab_proto__upb_library) set_property(TARGET CMakeProject_ab_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_ab_proto__upb_library PUBLIC "CMakeProject::ab_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_ab_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_ab_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_ab_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.c" + "${PROJECT_BINARY_DIR}/_gen_upb/b.upb.c") add_library(CMakeProject::ab_proto__upb_library ALIAS CMakeProject_ab_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_ab_proto__upb_library - PROTO_TARGET CMakeProject_ab_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/3ec71571 - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" +# @rules_proto_test_repo//:aspect_upbdefs__3daadd2b +# genproto upbdefs @rules_proto_test_repo//:b.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/b.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/b.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/b.proto" +DEPENDS + "protobuf::protoc_gen_upbdefs" + "${TEST_SRCDIR}/b.proto" + "protobuf::protoc" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/b.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__3daadd2b DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/b.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/b.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__3daadd2b INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__3daadd2b INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/b.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/b.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__3daadd2b INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__3daadd2b genrule__CMakeProject_aspect_upbdefs__3daadd2b) # @rules_proto_test_repo//:ab_proto__upbdefs_library +# aspect upbdefs @rules_proto_test_repo//:ab_proto add_library(CMakeProject_ab_proto__upbdefs_library) set_property(TARGET CMakeProject_ab_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_ab_proto__upbdefs_library PUBLIC "CMakeProject::ab_proto__minitable_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_ab_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_ab_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_ab_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.c" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/b.upbdefs.c") add_library(CMakeProject::ab_proto__upbdefs_library ALIAS CMakeProject_ab_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_ab_proto__upbdefs_library - PROTO_TARGET CMakeProject_ab_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/3ec71571 - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) - # cc_proto_library(@rules_proto_test_repo//:ab_protos_cc) -add_library(CMakeProject_ab_protos_cc INTERFACE) -target_link_libraries(CMakeProject_ab_protos_cc INTERFACE - "CMakeProject::ab_proto__cpp_library") -target_compile_features(CMakeProject_ab_protos_cc INTERFACE cxx_std_17) +add_library(CMakeProject_ab_protos_cc) +set_property(TARGET CMakeProject_ab_protos_cc PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_ab_protos_cc PUBLIC + "CMakeProject::ab_proto" + "CMakeProject::ab_proto__cpp_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_ab_protos_cc PRIVATE + "$") +target_compile_features(CMakeProject_ab_protos_cc PUBLIC cxx_std_17) +target_sources(CMakeProject_ab_protos_cc PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::ab_protos_cc ALIAS CMakeProject_ab_protos_cc) # proto_library(@rules_proto_test_repo//:d_proto) add_library(CMakeProject_d_proto INTERFACE) target_sources(CMakeProject_d_proto INTERFACE - "${PROJECT_SOURCE_DIR}/d.proto") + "${PROJECT_SOURCE_DIR}/d.proto") target_include_directories(CMakeProject_d_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::d_proto ALIAS CMakeProject_d_proto) # proto_library(@rules_proto_test_repo//:abcd_proto) add_library(CMakeProject_abcd_proto INTERFACE) target_sources(CMakeProject_abcd_proto INTERFACE - "${PROJECT_SOURCE_DIR}/c.proto") -target_link_libraries(CMakeProject_abcd_proto INTERFACE - "CMakeProject::ab_proto" - "CMakeProject::d_proto") + "${PROJECT_SOURCE_DIR}/c.proto") target_include_directories(CMakeProject_abcd_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") +target_link_libraries(CMakeProject_abcd_proto INTERFACE + "CMakeProject::ab_proto" + "CMakeProject::d_proto") add_library(CMakeProject::abcd_proto ALIAS CMakeProject_abcd_proto) +# @rules_proto_test_repo//:aspect_cpp__84819b61 +# genproto cpp @rules_proto_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/c.pb.h" + "${TEST_BINDIR}/_gen_cpp/c.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "-I$,$-I>" + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "protobuf::protoc" + "${TEST_SRCDIR}/c.proto" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__84819b61 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") +add_library(CMakeProject_aspect_cpp__84819b61 INTERFACE) +target_sources(CMakeProject_aspect_cpp__84819b61 INTERFACE + "${TEST_BINDIR}/_gen_cpp/c.pb.cc" + "${TEST_BINDIR}/_gen_cpp/c.pb.h") +target_include_directories(CMakeProject_aspect_cpp__84819b61 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__84819b61 genrule__CMakeProject_aspect_cpp__84819b61) + +# @rules_proto_test_repo//:aspect_cpp__ae7c401d +# genproto cpp @rules_proto_test_repo//:d.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/d.pb.h" + "${TEST_BINDIR}/_gen_cpp/d.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/d.proto" +DEPENDS + "${TEST_SRCDIR}/d.proto" + "protobuf::protoc" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/d.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__ae7c401d DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/d.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/d.pb.cc") +add_library(CMakeProject_aspect_cpp__ae7c401d INTERFACE) +target_sources(CMakeProject_aspect_cpp__ae7c401d INTERFACE + "${TEST_BINDIR}/_gen_cpp/d.pb.cc" + "${TEST_BINDIR}/_gen_cpp/d.pb.h") +target_include_directories(CMakeProject_aspect_cpp__ae7c401d INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__ae7c401d genrule__CMakeProject_aspect_cpp__ae7c401d) + # @rules_proto_test_repo//:d_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:d_proto add_library(CMakeProject_d_proto__cpp_library) set_property(TARGET CMakeProject_d_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_d_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_d_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_d_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_d_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/d.pb.cc") add_library(CMakeProject::d_proto__cpp_library ALIAS CMakeProject_d_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_d_proto__cpp_library - PROTO_TARGET CMakeProject_d_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/d09c8c10 - DEPENDS "protobuf::protoc" -) - # @rules_proto_test_repo//:abcd_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:abcd_proto add_library(CMakeProject_abcd_proto__cpp_library) set_property(TARGET CMakeProject_abcd_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_abcd_proto__cpp_library PUBLIC "CMakeProject::ab_proto__cpp_library" "CMakeProject::d_proto__cpp_library" + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_abcd_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_abcd_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_abcd_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/c.pb.cc") add_library(CMakeProject::abcd_proto__cpp_library ALIAS CMakeProject_abcd_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_abcd_proto__cpp_library - PROTO_TARGET CMakeProject_abcd_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/109212d3 - DEPENDS "protobuf::protoc" +# @rules_proto_test_repo//:aspect_upb__84819b61 +# genproto upb @rules_proto_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/c.upb.h" + "${TEST_BINDIR}/_gen_upb/c.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "-I$,$-I>" + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "protobuf::protoc_gen_upb" + "protobuf::protoc" + "${TEST_SRCDIR}/c.proto" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb__84819b61 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/c.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/c.upb.c") +add_library(CMakeProject_aspect_upb__84819b61 INTERFACE) +target_sources(CMakeProject_aspect_upb__84819b61 INTERFACE + "${TEST_BINDIR}/_gen_upb/c.upb.c" + "${TEST_BINDIR}/_gen_upb/c.upb.h") +target_include_directories(CMakeProject_aspect_upb__84819b61 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__84819b61 genrule__CMakeProject_aspect_upb__84819b61) + +# @rules_proto_test_repo//:aspect_upb_minitable__ae7c401d +# genproto upb_minitable @rules_proto_test_repo//:d.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/d.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/d.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/d.proto" +DEPENDS + "${TEST_SRCDIR}/d.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/d.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__ae7c401d DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/d.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/d.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__ae7c401d INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__ae7c401d INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/d.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/d.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__ae7c401d INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__ae7c401d genrule__CMakeProject_aspect_upb_minitable__ae7c401d) # @rules_proto_test_repo//:d_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:d_proto add_library(CMakeProject_d_proto__minitable_library) set_property(TARGET CMakeProject_d_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_d_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_d_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_d_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_d_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/d.upb_minitable.c") add_library(CMakeProject::d_proto__minitable_library ALIAS CMakeProject_d_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_d_proto__minitable_library - PROTO_TARGET CMakeProject_d_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/d09c8c10 - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" +# @rules_proto_test_repo//:aspect_upb_minitable__84819b61 +# genproto upb_minitable @rules_proto_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "-I$,$-I>" + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "protobuf::protoc" + "${TEST_SRCDIR}/c.proto" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__84819b61 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/c.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/c.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__84819b61 INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__84819b61 INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/c.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__84819b61 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__84819b61 genrule__CMakeProject_aspect_upb_minitable__84819b61) # @rules_proto_test_repo//:abcd_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:abcd_proto add_library(CMakeProject_abcd_proto__minitable_library) set_property(TARGET CMakeProject_abcd_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_abcd_proto__minitable_library PUBLIC "CMakeProject::ab_proto__minitable_library" "CMakeProject::d_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_abcd_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_abcd_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_abcd_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/c.upb_minitable.c") add_library(CMakeProject::abcd_proto__minitable_library ALIAS CMakeProject_abcd_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_abcd_proto__minitable_library - PROTO_TARGET CMakeProject_abcd_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/109212d3 - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" +# @rules_proto_test_repo//:aspect_upb__ae7c401d +# genproto upb @rules_proto_test_repo//:d.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/d.upb.h" + "${TEST_BINDIR}/_gen_upb/d.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/d.proto" +DEPENDS + "${TEST_SRCDIR}/d.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/d.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb__ae7c401d DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/d.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/d.upb.c") +add_library(CMakeProject_aspect_upb__ae7c401d INTERFACE) +target_sources(CMakeProject_aspect_upb__ae7c401d INTERFACE + "${TEST_BINDIR}/_gen_upb/d.upb.c" + "${TEST_BINDIR}/_gen_upb/d.upb.h") +target_include_directories(CMakeProject_aspect_upb__ae7c401d INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__ae7c401d genrule__CMakeProject_aspect_upb__ae7c401d) # @rules_proto_test_repo//:d_proto__upb_library +# aspect upb @rules_proto_test_repo//:d_proto add_library(CMakeProject_d_proto__upb_library) set_property(TARGET CMakeProject_d_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_d_proto__upb_library PUBLIC "CMakeProject::d_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_d_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_d_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_d_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/d.upb.c") add_library(CMakeProject::d_proto__upb_library ALIAS CMakeProject_d_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_d_proto__upb_library - PROTO_TARGET CMakeProject_d_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/d09c8c10 - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" -) - # @rules_proto_test_repo//:abcd_proto__upb_library +# aspect upb @rules_proto_test_repo//:abcd_proto add_library(CMakeProject_abcd_proto__upb_library) set_property(TARGET CMakeProject_abcd_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_abcd_proto__upb_library PUBLIC @@ -306,43 +717,101 @@ target_link_libraries(CMakeProject_abcd_proto__upb_library PUBLIC "CMakeProject::abcd_proto__minitable_library" "CMakeProject::d_proto__minitable_library" "CMakeProject::d_proto__upb_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_abcd_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_abcd_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_abcd_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/c.upb.c") add_library(CMakeProject::abcd_proto__upb_library ALIAS CMakeProject_abcd_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_abcd_proto__upb_library - PROTO_TARGET CMakeProject_abcd_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/109212d3 - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" +# @rules_proto_test_repo//:aspect_upbdefs__84819b61 +# genproto upbdefs @rules_proto_test_repo//:c.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "-I$,$-I>" + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/c.proto" +DEPENDS + "protobuf::protoc_gen_upbdefs" + "protobuf::protoc" + "${TEST_SRCDIR}/c.proto" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/c.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__84819b61 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/c.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/c.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__84819b61 INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__84819b61 INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/c.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__84819b61 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__84819b61 genrule__CMakeProject_aspect_upbdefs__84819b61) + +# @rules_proto_test_repo//:aspect_upbdefs__ae7c401d +# genproto upbdefs @rules_proto_test_repo//:d.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/d.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/d.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/d.proto" +DEPENDS + "${TEST_SRCDIR}/d.proto" + "protobuf::protoc_gen_upbdefs" + "protobuf::protoc" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/d.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__ae7c401d DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/d.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/d.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__ae7c401d INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__ae7c401d INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/d.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/d.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__ae7c401d INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__ae7c401d genrule__CMakeProject_aspect_upbdefs__ae7c401d) # @rules_proto_test_repo//:d_proto__upbdefs_library +# aspect upbdefs @rules_proto_test_repo//:d_proto add_library(CMakeProject_d_proto__upbdefs_library) set_property(TARGET CMakeProject_d_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_d_proto__upbdefs_library PUBLIC "CMakeProject::d_proto__minitable_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_d_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_d_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_d_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/d.upbdefs.c") add_library(CMakeProject::d_proto__upbdefs_library ALIAS CMakeProject_d_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_d_proto__upbdefs_library - PROTO_TARGET CMakeProject_d_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/d09c8c10 - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) - # @rules_proto_test_repo//:abcd_proto__upbdefs_library +# aspect upbdefs @rules_proto_test_repo//:abcd_proto add_library(CMakeProject_abcd_proto__upbdefs_library) set_property(TARGET CMakeProject_abcd_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_abcd_proto__upbdefs_library PUBLIC @@ -352,168 +821,247 @@ target_link_libraries(CMakeProject_abcd_proto__upbdefs_library PUBLIC "CMakeProject::d_proto__minitable_library" "CMakeProject::d_proto__upbdefs_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_abcd_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_abcd_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_abcd_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/c.upbdefs.c") add_library(CMakeProject::abcd_proto__upbdefs_library ALIAS CMakeProject_abcd_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_abcd_proto__upbdefs_library - PROTO_TARGET CMakeProject_abcd_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/109212d3 - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) - # cc_proto_library(@rules_proto_test_repo//:abcd_protos_cc) -add_library(CMakeProject_abcd_protos_cc INTERFACE) -target_link_libraries(CMakeProject_abcd_protos_cc INTERFACE - "CMakeProject::abcd_proto__cpp_library") -target_compile_features(CMakeProject_abcd_protos_cc INTERFACE cxx_std_17) +add_library(CMakeProject_abcd_protos_cc) +set_property(TARGET CMakeProject_abcd_protos_cc PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_abcd_protos_cc PUBLIC + "CMakeProject::abcd_proto" + "CMakeProject::abcd_proto__cpp_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_abcd_protos_cc PRIVATE + "$") +target_compile_features(CMakeProject_abcd_protos_cc PUBLIC cxx_std_17) +target_sources(CMakeProject_abcd_protos_cc PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::abcd_protos_cc ALIAS CMakeProject_abcd_protos_cc) # proto_library(@rules_proto_test_repo//:b_proto) add_library(CMakeProject_b_proto INTERFACE) target_sources(CMakeProject_b_proto INTERFACE - "${PROJECT_SOURCE_DIR}/b.proto") + "${PROJECT_SOURCE_DIR}/b.proto") target_include_directories(CMakeProject_b_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::b_proto ALIAS CMakeProject_b_proto) # @rules_proto_test_repo//:b_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:b_proto add_library(CMakeProject_b_proto__cpp_library) set_property(TARGET CMakeProject_b_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_b_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_b_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_b_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_b_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/b.pb.cc") add_library(CMakeProject::b_proto__cpp_library ALIAS CMakeProject_b_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_b_proto__cpp_library - PROTO_TARGET CMakeProject_b_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/0cdcec13 - DEPENDS "protobuf::protoc" -) - # @rules_proto_test_repo//:b_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:b_proto add_library(CMakeProject_b_proto__minitable_library) set_property(TARGET CMakeProject_b_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_b_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_b_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_b_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_b_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/b.upb_minitable.c") add_library(CMakeProject::b_proto__minitable_library ALIAS CMakeProject_b_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_b_proto__minitable_library - PROTO_TARGET CMakeProject_b_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/0cdcec13 - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" -) - # @rules_proto_test_repo//:b_proto__upb_library +# aspect upb @rules_proto_test_repo//:b_proto add_library(CMakeProject_b_proto__upb_library) set_property(TARGET CMakeProject_b_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_b_proto__upb_library PUBLIC "CMakeProject::b_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_b_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_b_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_b_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/b.upb.c") add_library(CMakeProject::b_proto__upb_library ALIAS CMakeProject_b_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_b_proto__upb_library - PROTO_TARGET CMakeProject_b_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/0cdcec13 - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" -) - # @rules_proto_test_repo//:b_proto__upbdefs_library +# aspect upbdefs @rules_proto_test_repo//:b_proto add_library(CMakeProject_b_proto__upbdefs_library) set_property(TARGET CMakeProject_b_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_b_proto__upbdefs_library PUBLIC "CMakeProject::b_proto__minitable_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_b_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_b_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_b_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/b.upbdefs.c") add_library(CMakeProject::b_proto__upbdefs_library ALIAS CMakeProject_b_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_b_proto__upbdefs_library - PROTO_TARGET CMakeProject_b_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/0cdcec13 - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) - # proto_library(@rules_proto_test_repo//:x_proto) add_library(CMakeProject_x_proto INTERFACE) target_sources(CMakeProject_x_proto INTERFACE - "${PROJECT_SOURCE_DIR}/x.proto") -target_link_libraries(CMakeProject_x_proto INTERFACE - "Protobuf_any_proto") + "${PROJECT_SOURCE_DIR}/x.proto") target_include_directories(CMakeProject_x_proto INTERFACE - ${Protobuf_IMPORT_DIRS} - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") +target_link_libraries(CMakeProject_x_proto INTERFACE + "Protobuf_any_proto") add_library(CMakeProject::x_proto ALIAS CMakeProject_x_proto) +# @rules_proto_test_repo//:aspect_upb__a1bf1338 +# genproto upb @rules_proto_test_repo//:x.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/x.upb.h" + "${TEST_BINDIR}/_gen_upb/x.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/x.proto" +DEPENDS + "protobuf::protoc" + "protobuf::protoc_gen_upb" + "${TEST_SRCDIR}/x.proto" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/x.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb__a1bf1338 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/x.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/x.upb.c") +add_library(CMakeProject_aspect_upb__a1bf1338 INTERFACE) +target_sources(CMakeProject_aspect_upb__a1bf1338 INTERFACE + "${TEST_BINDIR}/_gen_upb/x.upb.c" + "${TEST_BINDIR}/_gen_upb/x.upb.h") +target_include_directories(CMakeProject_aspect_upb__a1bf1338 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__a1bf1338 genrule__CMakeProject_aspect_upb__a1bf1338) + +# @rules_proto_test_repo//:aspect_upb_minitable__a1bf1338 +# genproto upb_minitable @rules_proto_test_repo//:x.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/x.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/x.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/x.proto" +DEPENDS + "protobuf::protoc" + "protobuf::protoc_gen_upb_minitable_stage1" + "${TEST_SRCDIR}/x.proto" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/x.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__a1bf1338 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/x.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/x.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__a1bf1338 INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__a1bf1338 INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/x.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/x.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__a1bf1338 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__a1bf1338 genrule__CMakeProject_aspect_upb_minitable__a1bf1338) + # @rules_proto_test_repo//:x_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:x_proto add_library(CMakeProject_x_proto__minitable_library) set_property(TARGET CMakeProject_x_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_x_proto__minitable_library PUBLIC "Protobuf::any_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_x_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_x_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_x_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/x.upb_minitable.c") add_library(CMakeProject::x_proto__minitable_library ALIAS CMakeProject_x_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_x_proto__minitable_library - PROTO_TARGET CMakeProject_x_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/db1b3834 - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" -) - # @rules_proto_test_repo//:x_proto__upb_library +# aspect upb @rules_proto_test_repo//:x_proto add_library(CMakeProject_x_proto__upb_library) set_property(TARGET CMakeProject_x_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_x_proto__upb_library PUBLIC "CMakeProject::x_proto__minitable_library" "Protobuf::any_proto__minitable_library" "Protobuf::any_proto__upb_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_x_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_x_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_x_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/x.upb.c") add_library(CMakeProject::x_proto__upb_library ALIAS CMakeProject_x_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_x_proto__upb_library - PROTO_TARGET CMakeProject_x_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/db1b3834 - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" +# @rules_proto_test_repo//:aspect_upbdefs__a1bf1338 +# genproto upbdefs @rules_proto_test_repo//:x.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/x.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/x.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/x.proto" +DEPENDS + "protobuf::protoc_gen_upbdefs" + "protobuf::protoc" + "${TEST_SRCDIR}/x.proto" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/x.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__a1bf1338 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/x.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/x.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__a1bf1338 INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__a1bf1338 INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/x.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/x.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__a1bf1338 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__a1bf1338 genrule__CMakeProject_aspect_upbdefs__a1bf1338) # @rules_proto_test_repo//:x_proto__upbdefs_library +# aspect upbdefs @rules_proto_test_repo//:x_proto add_library(CMakeProject_x_proto__upbdefs_library) set_property(TARGET CMakeProject_x_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_x_proto__upbdefs_library PUBLIC @@ -521,108 +1069,222 @@ target_link_libraries(CMakeProject_x_proto__upbdefs_library PUBLIC "Protobuf::any_proto__minitable_library" "Protobuf::any_proto__upbdefs_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_x_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_x_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_x_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/x.upbdefs.c") add_library(CMakeProject::x_proto__upbdefs_library ALIAS CMakeProject_x_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_x_proto__upbdefs_library - PROTO_TARGET CMakeProject_x_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/db1b3834 - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" +# @rules_proto_test_repo//:aspect_cpp__a1bf1338 +# genproto cpp @rules_proto_test_repo//:x.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/x.pb.h" + "${TEST_BINDIR}/_gen_cpp/x.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/x.proto" +DEPENDS + "protobuf::protoc" + "${TEST_SRCDIR}/x.proto" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/x.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_cpp__a1bf1338 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/x.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/x.pb.cc") +add_library(CMakeProject_aspect_cpp__a1bf1338 INTERFACE) +target_sources(CMakeProject_aspect_cpp__a1bf1338 INTERFACE + "${TEST_BINDIR}/_gen_cpp/x.pb.cc" + "${TEST_BINDIR}/_gen_cpp/x.pb.h") +target_include_directories(CMakeProject_aspect_cpp__a1bf1338 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__a1bf1338 genrule__CMakeProject_aspect_cpp__a1bf1338) # @rules_proto_test_repo//:x_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:x_proto add_library(CMakeProject_x_proto__cpp_library) set_property(TARGET CMakeProject_x_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_x_proto__cpp_library PUBLIC "Protobuf::any_proto__cpp_library" + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_x_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_x_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_x_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/x.pb.cc") add_library(CMakeProject::x_proto__cpp_library ALIAS CMakeProject_x_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_x_proto__cpp_library - PROTO_TARGET CMakeProject_x_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/db1b3834 - DEPENDS "protobuf::protoc" -) - # cc_proto_library(@rules_proto_test_repo//:x_proto_cc) -add_library(CMakeProject_x_proto_cc INTERFACE) -target_link_libraries(CMakeProject_x_proto_cc INTERFACE - "CMakeProject::x_proto__cpp_library") -target_compile_features(CMakeProject_x_proto_cc INTERFACE cxx_std_17) +add_library(CMakeProject_x_proto_cc) +set_property(TARGET CMakeProject_x_proto_cc PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_x_proto_cc PUBLIC + "CMakeProject::x_proto" + "CMakeProject::x_proto__cpp_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_x_proto_cc PRIVATE + "$") +target_compile_features(CMakeProject_x_proto_cc PUBLIC cxx_std_17) +target_sources(CMakeProject_x_proto_cc PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::x_proto_cc ALIAS CMakeProject_x_proto_cc) # proto_library(@rules_proto_test_repo//:y_proto) add_library(CMakeProject_y_proto INTERFACE) target_sources(CMakeProject_y_proto INTERFACE - "${PROJECT_SOURCE_DIR}/src/subdir/y.proto") + "${PROJECT_SOURCE_DIR}/src/subdir/y.proto") target_include_directories(CMakeProject_y_proto INTERFACE - "${PROJECT_SOURCE_DIR}/src") + "${PROJECT_SOURCE_DIR}/src") add_library(CMakeProject::y_proto ALIAS CMakeProject_y_proto) +# @rules_proto_test_repo//:aspect_cpp__9651e148 +# genproto cpp @rules_proto_test_repo//:src/subdir/y.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp/src/subdir") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/src/subdir/y.pb.h" + "${TEST_BINDIR}/_gen_cpp/src/subdir/y.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp/src" + "${TEST_SRCDIR}/src/subdir/y.proto" +DEPENDS + "${TEST_SRCDIR}/src/subdir/y.proto" + "protobuf::protoc" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/src/subdir/y.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__9651e148 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/src/subdir/y.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/src/subdir/y.pb.cc") +add_library(CMakeProject_aspect_cpp__9651e148 INTERFACE) +target_sources(CMakeProject_aspect_cpp__9651e148 INTERFACE + "${TEST_BINDIR}/_gen_cpp/src/subdir/y.pb.cc" + "${TEST_BINDIR}/_gen_cpp/src/subdir/y.pb.h") +target_include_directories(CMakeProject_aspect_cpp__9651e148 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp/src") +add_dependencies(CMakeProject_aspect_cpp__9651e148 genrule__CMakeProject_aspect_cpp__9651e148) + # @rules_proto_test_repo//:y_proto__cpp_library +# aspect cpp @rules_proto_test_repo//:y_proto add_library(CMakeProject_y_proto__cpp_library) set_property(TARGET CMakeProject_y_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_y_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_y_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_y_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_y_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/src/subdir/y.pb.cc") add_library(CMakeProject::y_proto__cpp_library ALIAS CMakeProject_y_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_y_proto__cpp_library - PROTO_TARGET CMakeProject_y_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/573e9085/src - DEPENDS "protobuf::protoc" +# @rules_proto_test_repo//:aspect_upb__9651e148 +# genproto upb @rules_proto_test_repo//:src/subdir/y.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb/src/subdir") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/src/subdir/y.upb.h" + "${TEST_BINDIR}/_gen_upb/src/subdir/y.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb/src" + "${TEST_SRCDIR}/src/subdir/y.proto" +DEPENDS + "${TEST_SRCDIR}/src/subdir/y.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/src/subdir/y.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb__9651e148 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/src/subdir/y.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/src/subdir/y.upb.c") +add_library(CMakeProject_aspect_upb__9651e148 INTERFACE) +target_sources(CMakeProject_aspect_upb__9651e148 INTERFACE + "${TEST_BINDIR}/_gen_upb/src/subdir/y.upb.c" + "${TEST_BINDIR}/_gen_upb/src/subdir/y.upb.h") +target_include_directories(CMakeProject_aspect_upb__9651e148 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb/src") +add_dependencies(CMakeProject_aspect_upb__9651e148 genrule__CMakeProject_aspect_upb__9651e148) + +# @rules_proto_test_repo//:aspect_upb_minitable__9651e148 +# genproto upb_minitable @rules_proto_test_repo//:src/subdir/y.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable/src/subdir") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable/src" + "${TEST_SRCDIR}/src/subdir/y.proto" +DEPENDS + "${TEST_SRCDIR}/src/subdir/y.proto" + "protobuf::protoc" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/src/subdir/y.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__9651e148 DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__9651e148 INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__9651e148 INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__9651e148 INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/src") +add_dependencies(CMakeProject_aspect_upb_minitable__9651e148 genrule__CMakeProject_aspect_upb_minitable__9651e148) # @rules_proto_test_repo//:y_proto__minitable_library +# aspect upb_minitable @rules_proto_test_repo//:y_proto add_library(CMakeProject_y_proto__minitable_library) set_property(TARGET CMakeProject_y_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_y_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_y_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_y_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_y_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/src/subdir/y.upb_minitable.c") add_library(CMakeProject::y_proto__minitable_library ALIAS CMakeProject_y_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_y_proto__minitable_library - PROTO_TARGET CMakeProject_y_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/573e9085/src - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" -) - # @rules_proto_test_repo//:y_proto__upb_library +# aspect upb @rules_proto_test_repo//:y_proto add_library(CMakeProject_y_proto__upb_library) set_property(TARGET CMakeProject_y_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_y_proto__upb_library PUBLIC "CMakeProject::y_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_y_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_y_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_y_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/src/subdir/y.upb.c") add_library(CMakeProject::y_proto__upb_library ALIAS CMakeProject_y_proto__upb_library) - -btc_protobuf( - TARGET CMakeProject_y_proto__upb_library - PROTO_TARGET CMakeProject_y_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/573e9085/src - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" -) diff --git a/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/config.json b/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/config.json index 679e878be..3c6f4e2e7 100644 --- a/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/config.json +++ b/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/config.json @@ -7,5 +7,8 @@ "//:a_upb_proto", "//:a_upb_proto_reflection", "//:x" + ], + "excludes": [ + "_bindir/bazel_to_cmake_empty_source.cc" ] } diff --git a/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/golden/_srcdir/build_rules.cmake b/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/golden/_srcdir/build_rules.cmake index 9732124ff..4ce3e5e6a 100644 --- a/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/golden/_srcdir/build_rules.cmake +++ b/tools/cmake/bazel_to_cmake/testdata/upb_proto_library/golden/_srcdir/build_rules.cmake @@ -3,126 +3,277 @@ find_package(Protobuf REQUIRED) # proto_library(@upb_proto_library_test_repo//:a_proto) add_library(CMakeProject_a_proto INTERFACE) target_sources(CMakeProject_a_proto INTERFACE - "${PROJECT_SOURCE_DIR}/a.proto") + "${PROJECT_SOURCE_DIR}/a.proto") target_include_directories(CMakeProject_a_proto INTERFACE - "${PROJECT_SOURCE_DIR}") + "${PROJECT_SOURCE_DIR}") add_library(CMakeProject::a_proto ALIAS CMakeProject_a_proto) +# @upb_proto_library_test_repo//:aspect_cpp__9411025a +# genproto cpp @upb_proto_library_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_cpp") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_cpp/a.pb.h" + "${TEST_BINDIR}/_gen_cpp/a.pb.cc" +COMMAND $ + --experimental_allow_proto3_optional + "-I$,$-I>" + "--cpp_out=${PROJECT_BINARY_DIR}/_gen_cpp" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "protobuf::protoc" + "${TEST_SRCDIR}/a.proto" +COMMENT "Running protoc cpp on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_cpp__9411025a DEPENDS + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.h" + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.cc") +add_library(CMakeProject_aspect_cpp__9411025a INTERFACE) +target_sources(CMakeProject_aspect_cpp__9411025a INTERFACE + "${TEST_BINDIR}/_gen_cpp/a.pb.cc" + "${TEST_BINDIR}/_gen_cpp/a.pb.h") +target_include_directories(CMakeProject_aspect_cpp__9411025a INTERFACE + "${PROJECT_BINARY_DIR}/_gen_cpp") +add_dependencies(CMakeProject_aspect_cpp__9411025a genrule__CMakeProject_aspect_cpp__9411025a) + # @upb_proto_library_test_repo//:a_proto__cpp_library +# aspect cpp @upb_proto_library_test_repo//:a_proto add_library(CMakeProject_a_proto__cpp_library) set_property(TARGET CMakeProject_a_proto__cpp_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__cpp_library PUBLIC + "Threads::Threads" + "m" "protobuf::libprotobuf") +target_include_directories(CMakeProject_a_proto__cpp_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__cpp_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__cpp_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_cpp/a.pb.cc") add_library(CMakeProject::a_proto__cpp_library ALIAS CMakeProject_a_proto__cpp_library) -btc_protobuf( - TARGET CMakeProject_a_proto__cpp_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE cpp - GENERATE_EXTENSIONS ".pb.h" ".pb.cc" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/92f46a52 - DEPENDS "protobuf::protoc" -) - # cc_proto_library(@upb_proto_library_test_repo//:a_cc_proto) -add_library(CMakeProject_a_cc_proto INTERFACE) -target_link_libraries(CMakeProject_a_cc_proto INTERFACE - "CMakeProject::a_proto__cpp_library") -target_compile_features(CMakeProject_a_cc_proto INTERFACE cxx_std_17) +add_library(CMakeProject_a_cc_proto) +set_property(TARGET CMakeProject_a_cc_proto PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_a_cc_proto PUBLIC + "CMakeProject::a_proto" + "CMakeProject::a_proto__cpp_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_a_cc_proto PRIVATE + "$") +target_compile_features(CMakeProject_a_cc_proto PUBLIC cxx_std_17) +target_sources(CMakeProject_a_cc_proto PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::a_cc_proto ALIAS CMakeProject_a_cc_proto) +# @upb_proto_library_test_repo//:aspect_upb_minitable__9411025a +# genproto upb_minitable @upb_proto_library_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb_minitable") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.h" + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb_minitable=$ + "-I$,$-I>" + "--upb_minitable_out=${PROJECT_BINARY_DIR}/_gen_upb_minitable" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "protobuf::protoc" + "${TEST_SRCDIR}/a.proto" + "protobuf::protoc_gen_upb_minitable_stage1" +COMMENT "Running protoc upb_minitable on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upb_minitable__9411025a DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.h" + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.c") +add_library(CMakeProject_aspect_upb_minitable__9411025a INTERFACE) +target_sources(CMakeProject_aspect_upb_minitable__9411025a INTERFACE + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.c" + "${TEST_BINDIR}/_gen_upb_minitable/a.upb_minitable.h") +target_include_directories(CMakeProject_aspect_upb_minitable__9411025a INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable") +add_dependencies(CMakeProject_aspect_upb_minitable__9411025a genrule__CMakeProject_aspect_upb_minitable__9411025a) + # @upb_proto_library_test_repo//:a_proto__minitable_library +# aspect upb_minitable @upb_proto_library_test_repo//:a_proto add_library(CMakeProject_a_proto__minitable_library) set_property(TARGET CMakeProject_a_proto__minitable_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__minitable_library PUBLIC + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_a_proto__minitable_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__minitable_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__minitable_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb_minitable/a.upb_minitable.c") add_library(CMakeProject::a_proto__minitable_library ALIAS CMakeProject_a_proto__minitable_library) -btc_protobuf( - TARGET CMakeProject_a_proto__minitable_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE upb_minitable - GENERATE_EXTENSIONS ".upb_minitable.h" ".upb_minitable.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/92f46a52 - PLUGIN protoc-gen-upb_minitable=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb_minitable_stage1" +# @upb_proto_library_test_repo//:aspect_upb__9411025a +# genproto upb @upb_proto_library_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upb") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upb/a.upb.h" + "${TEST_BINDIR}/_gen_upb/a.upb.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upb=$ + "-I$,$-I>" + "--upb_out=${PROJECT_BINARY_DIR}/_gen_upb" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "protobuf::protoc_gen_upb" + "protobuf::protoc" + "${TEST_SRCDIR}/a.proto" +COMMENT "Running protoc upb on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM ) +add_custom_target(genrule_CMakeProject_aspect_upb__9411025a DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.h" + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.c") +add_library(CMakeProject_aspect_upb__9411025a INTERFACE) +target_sources(CMakeProject_aspect_upb__9411025a INTERFACE + "${TEST_BINDIR}/_gen_upb/a.upb.c" + "${TEST_BINDIR}/_gen_upb/a.upb.h") +target_include_directories(CMakeProject_aspect_upb__9411025a INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upb") +add_dependencies(CMakeProject_aspect_upb__9411025a genrule__CMakeProject_aspect_upb__9411025a) # @upb_proto_library_test_repo//:a_proto__upb_library +# aspect upb @upb_proto_library_test_repo//:a_proto add_library(CMakeProject_a_proto__upb_library) set_property(TARGET CMakeProject_a_proto__upb_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__upb_library PUBLIC "CMakeProject::a_proto__minitable_library" + "Threads::Threads" + "m" "protobuf::upb_generated_code_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me") +target_include_directories(CMakeProject_a_proto__upb_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__upb_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__upb_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upb/a.upb.c") add_library(CMakeProject::a_proto__upb_library ALIAS CMakeProject_a_proto__upb_library) -btc_protobuf( - TARGET CMakeProject_a_proto__upb_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE upb - GENERATE_EXTENSIONS ".upb.h" ".upb.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/92f46a52 - PLUGIN protoc-gen-upb=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upb" -) - # upb_c_proto_library(@upb_proto_library_test_repo//:a_upb_proto) -add_library(CMakeProject_a_upb_proto INTERFACE) -target_link_libraries(CMakeProject_a_upb_proto INTERFACE +add_library(CMakeProject_a_upb_proto) +set_property(TARGET CMakeProject_a_upb_proto PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_a_upb_proto PUBLIC + "CMakeProject::a_proto" "CMakeProject::a_proto__minitable_library" - "CMakeProject::a_proto__upb_library") -target_compile_features(CMakeProject_a_upb_proto INTERFACE cxx_std_17) + "CMakeProject::a_proto__upb_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_a_upb_proto PRIVATE + "$") +target_compile_features(CMakeProject_a_upb_proto PUBLIC cxx_std_17) +target_sources(CMakeProject_a_upb_proto PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::a_upb_proto ALIAS CMakeProject_a_upb_proto) +# @upb_proto_library_test_repo//:aspect_upbdefs__9411025a +# genproto upbdefs @upb_proto_library_test_repo//:a.proto +file(MAKE_DIRECTORY "${TEST_BINDIR}/_gen_upbdefs") +add_custom_command( +OUTPUT + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.h" + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.c" +COMMAND $ + --experimental_allow_proto3_optional + --plugin=protoc-gen-upbdefs=$ + "-I$,$-I>" + "--upbdefs_out=${PROJECT_BINARY_DIR}/_gen_upbdefs" + "${TEST_SRCDIR}/a.proto" +DEPENDS + "protobuf::protoc_gen_upbdefs" + "protobuf::protoc" + "${TEST_SRCDIR}/a.proto" +COMMENT "Running protoc upbdefs on ${TEST_SRCDIR}/a.proto" +COMMAND_EXPAND_LISTS +VERBATIM +) +add_custom_target(genrule_CMakeProject_aspect_upbdefs__9411025a DEPENDS + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.h" + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.c") +add_library(CMakeProject_aspect_upbdefs__9411025a INTERFACE) +target_sources(CMakeProject_aspect_upbdefs__9411025a INTERFACE + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.c" + "${TEST_BINDIR}/_gen_upbdefs/a.upbdefs.h") +target_include_directories(CMakeProject_aspect_upbdefs__9411025a INTERFACE + "${PROJECT_BINARY_DIR}/_gen_upbdefs") +add_dependencies(CMakeProject_aspect_upbdefs__9411025a genrule__CMakeProject_aspect_upbdefs__9411025a) + # @upb_proto_library_test_repo//:a_proto__upbdefs_library +# aspect upbdefs @upb_proto_library_test_repo//:a_proto add_library(CMakeProject_a_proto__upbdefs_library) set_property(TARGET CMakeProject_a_proto__upbdefs_library PROPERTY LINKER_LANGUAGE "CXX") target_link_libraries(CMakeProject_a_proto__upbdefs_library PUBLIC "CMakeProject::a_proto__minitable_library" "Protobuf::upb_generated_reflection_support__only_for_generated_code_do_not_use__i_give_permission_to_break_me" - "Protobuf::upb_port") + "Protobuf::upb_port" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_a_proto__upbdefs_library PUBLIC + "$") target_compile_features(CMakeProject_a_proto__upbdefs_library PUBLIC cxx_std_17) +target_sources(CMakeProject_a_proto__upbdefs_library PRIVATE + "${PROJECT_BINARY_DIR}/_gen_upbdefs/a.upbdefs.c") add_library(CMakeProject::a_proto__upbdefs_library ALIAS CMakeProject_a_proto__upbdefs_library) -btc_protobuf( - TARGET CMakeProject_a_proto__upbdefs_library - PROTO_TARGET CMakeProject_a_proto - LANGUAGE upbdefs - GENERATE_EXTENSIONS ".upbdefs.h" ".upbdefs.c" - PROTOC_OPTIONS --experimental_allow_proto3_optional - PROTOC_OUT_DIR ${PROJECT_BINARY_DIR}/92f46a52 - PLUGIN protoc-gen-upbdefs=$ - DEPENDS "protobuf::protoc" "protobuf::protoc_gen_upbdefs" -) - # upb_proto_reflection_library(@upb_proto_library_test_repo//:a_upb_proto_reflection) -add_library(CMakeProject_a_upb_proto_reflection INTERFACE) -target_link_libraries(CMakeProject_a_upb_proto_reflection INTERFACE +add_library(CMakeProject_a_upb_proto_reflection) +set_property(TARGET CMakeProject_a_upb_proto_reflection PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_a_upb_proto_reflection PUBLIC + "CMakeProject::a_proto" "CMakeProject::a_proto__minitable_library" - "CMakeProject::a_proto__upbdefs_library") -target_compile_features(CMakeProject_a_upb_proto_reflection INTERFACE cxx_std_17) + "CMakeProject::a_proto__upbdefs_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_a_upb_proto_reflection PRIVATE + "$") +target_compile_features(CMakeProject_a_upb_proto_reflection PUBLIC cxx_std_17) +target_sources(CMakeProject_a_upb_proto_reflection PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::a_upb_proto_reflection ALIAS CMakeProject_a_upb_proto_reflection) # upb_c_proto_library(@upb_proto_library_test_repo//:abc_upb_proto) -add_library(CMakeProject_abc_upb_proto INTERFACE) -target_link_libraries(CMakeProject_abc_upb_proto INTERFACE +add_library(CMakeProject_abc_upb_proto) +set_property(TARGET CMakeProject_abc_upb_proto PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_abc_upb_proto PUBLIC + "CMakeProject::abc_protos" "CMakeProject::abc_protos__minitable_library" - "CMakeProject::abc_protos__upb_library") -target_compile_features(CMakeProject_abc_upb_proto INTERFACE cxx_std_17) + "CMakeProject::abc_protos__upb_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_abc_upb_proto PRIVATE + "$") +target_compile_features(CMakeProject_abc_upb_proto PUBLIC cxx_std_17) +target_sources(CMakeProject_abc_upb_proto PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::abc_upb_proto ALIAS CMakeProject_abc_upb_proto) # upb_proto_reflection_library(@upb_proto_library_test_repo//:abc_upb_proto_reflection) -add_library(CMakeProject_abc_upb_proto_reflection INTERFACE) -target_link_libraries(CMakeProject_abc_upb_proto_reflection INTERFACE +add_library(CMakeProject_abc_upb_proto_reflection) +set_property(TARGET CMakeProject_abc_upb_proto_reflection PROPERTY LINKER_LANGUAGE "CXX") +target_link_libraries(CMakeProject_abc_upb_proto_reflection PUBLIC + "CMakeProject::abc_protos" "CMakeProject::abc_protos__minitable_library" - "CMakeProject::abc_protos__upbdefs_library") -target_compile_features(CMakeProject_abc_upb_proto_reflection INTERFACE cxx_std_17) + "CMakeProject::abc_protos__upbdefs_library" + "Threads::Threads" + "m") +target_include_directories(CMakeProject_abc_upb_proto_reflection PRIVATE + "$") +target_compile_features(CMakeProject_abc_upb_proto_reflection PUBLIC cxx_std_17) +target_sources(CMakeProject_abc_upb_proto_reflection PRIVATE + "${PROJECT_BINARY_DIR}/bazel_to_cmake_empty_source.cc") add_library(CMakeProject::abc_upb_proto_reflection ALIAS CMakeProject_abc_upb_proto_reflection) # cc_library(@upb_proto_library_test_repo//:x) diff --git a/tools/cmake/bazel_to_cmake/util.py b/tools/cmake/bazel_to_cmake/util.py index bfabc9f7a..66ddd6b08 100644 --- a/tools/cmake/bazel_to_cmake/util.py +++ b/tools/cmake/bazel_to_cmake/util.py @@ -18,13 +18,22 @@ import os import pathlib import re -from typing import Any, Iterable, List, Optional, Tuple, TypeVar +from typing import Any, Collection, Iterable, Iterator, List, Optional, Tuple, TypeVar, Union from .starlark.bazel_glob import glob_pattern_to_regexp -PathLike = TypeVar( - "PathLike", str, pathlib.Path, pathlib.PurePath, pathlib.PurePosixPath -) +PathLike = TypeVar("PathLike", str, pathlib.PurePath) + +PathIterable = Union[ + Iterable[str], Iterable[pathlib.PurePath], Iterable[PathLike] +] + +PathCollection = Union[ + Collection[str], Collection[pathlib.PurePath], Collection[PathLike] +] + + +T = TypeVar("T") def quote_string(x: str) -> str: @@ -52,7 +61,7 @@ def quote_list(y: Iterable[str], separator: str = " ") -> str: return separator.join(quote_string(x) for x in y) -def quote_path_list(y: Iterable[PathLike], separator: str = " ") -> str: +def quote_path_list(y: PathIterable, separator: str = " ") -> str: return separator.join(quote_path(x) for x in y if x) @@ -60,6 +69,13 @@ def quote_unescaped_list(y: Iterable[str], separator: str = " ") -> str: return separator.join(quote_unescaped(x) for x in y) +def exactly_one(x: Iterator[T]) -> T: + v = next(x) + if not v or not all(map(lambda y: y == v, x)): + raise ValueError("There is not exactly 1 file in the collection.") + return v + + # Unfortunately, pathlib.PurePath.is_relative_to is a python3.9 invention. def is_relative_to( leaf: pathlib.PurePath, root: pathlib.PurePath, _use_attr: bool = True @@ -84,10 +100,12 @@ def make_relative_path(p: PathLike, *target) -> Tuple[Any, pathlib.PurePath]: return (None, p) -def partition_by(*args, pattern: str) -> Tuple[List[str], List[str]]: +def partition_by( + inputs: Iterable[PathLike], pattern: str +) -> Tuple[List[str], List[str]]: yes = [] no = [] - for x in args: + for x in inputs: y = str(x) if re.search(pattern, y): yes.append(y) diff --git a/tools/cmake/bazel_to_cmake/variable_substitution.py b/tools/cmake/bazel_to_cmake/variable_substitution.py index dc9c4aa75..f94ce59fd 100644 --- a/tools/cmake/bazel_to_cmake/variable_substitution.py +++ b/tools/cmake/bazel_to_cmake/variable_substitution.py @@ -24,8 +24,8 @@ import shlex from typing import Dict, List, Match, Optional -from .cmake_target import CMakeExecutableTargetProvider -from .cmake_target import CMakeLinkLibrariesProvider +from .cmake_provider import CMakeExecutableTargetProvider +from .cmake_provider import CMakeLinkLibrariesProvider from .cmake_target import CMakeTarget from .evaluation import EvaluationState from .starlark.bazel_target import TargetId diff --git a/tools/cmake/bazel_to_cmake/variable_substitution_test.py b/tools/cmake/bazel_to_cmake/variable_substitution_test.py index 364df5d46..e9edb074a 100644 --- a/tools/cmake/bazel_to_cmake/variable_substitution_test.py +++ b/tools/cmake/bazel_to_cmake/variable_substitution_test.py @@ -21,7 +21,7 @@ import pytest -from .cmake_target import CMakeExecutableTargetProvider +from .cmake_provider import CMakeExecutableTargetProvider from .cmake_target import CMakePackage from .cmake_target import CMakeTarget from .cmake_target import CMakeTargetPair diff --git a/tools/cmake/btc_protobuf.cmake b/tools/cmake/btc_protobuf.cmake index 06e056e2f..8496f0923 100644 --- a/tools/cmake/btc_protobuf.cmake +++ b/tools/cmake/btc_protobuf.cmake @@ -23,10 +23,10 @@ # # btc_protobuf( # TARGET -# Build .proto files included in the target. +# Add generated .proto sources to this target. # # PROTO_TARGET -# Target used to resolve .proto imports. +# Resolve .proto files from the target INTERFACE_SOURCES. # # PROTOS # Proto files @@ -53,67 +53,65 @@ # # DEPENDS # CMake DEPENDS. +# +# VARNAME +# Output generated files to this variable. # ) function(btc_protobuf) include(CMakeParseArguments) - set(_singleargs PROTO_TARGET LANGUAGE PROTOC_OUT_DIR PLUGIN PLUGIN_OPTIONS DEPENDS) + set(_singleargs PROTO_TARGET LANGUAGE PROTOC_OUT_DIR PLUGIN PLUGIN_OPTIONS DEPENDS VARNAME) set(_multiargs PROTOS IMPORT_VARS GENERATE_EXTENSIONS PROTOC_OPTIONS) - cmake_parse_arguments(btc_protobuf "" "${_singleargs}" "${_multiargs}" "${ARGN}") - - if(NOT btc_protobuf_TARGET) - message(SEND_ERROR "Error: btc_protobuf called without a TARGET") - return() - endif() + cmake_parse_arguments(btc "" "${_singleargs}" "${_multiargs}" "${ARGN}") - if(NOT btc_protobuf_LANGUAGE) - set(btc_protobuf_LANGUAGE cpp) + if(NOT btc_LANGUAGE) + set(btc_LANGUAGE cpp) endif() - string(TOLOWER ${btc_protobuf_LANGUAGE} btc_protobuf_LANGUAGE) + string(TOLOWER ${btc_LANGUAGE} btc_LANGUAGE) - if(NOT btc_protobuf_GENERATE_EXTENSIONS) - message(SEND_ERROR "Error: btc_protobuf called without GENERATE_EXTENSIONS for LANGUAGE ${btc_protobuf_LANGUAGE}.") + if(NOT btc_GENERATE_EXTENSIONS) + message(SEND_ERROR "Error: btc_protobuf called without GENERATE_EXTENSIONS for LANGUAGE ${btc_LANGUAGE}.") return() endif() - if(NOT btc_protobuf_PROTO_TARGET) + if(NOT btc_PROTO_TARGET) message(SEND_ERROR "Error: btc_protobuf called without a PROTO_TARGET.") return() endif() - if(NOT btc_protobuf_PROTOC_OUT_DIR) - set(btc_protobuf_PROTOC_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR}) + if(NOT btc_PROTOC_OUT_DIR) + set(btc_PROTOC_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR}) else() - file(MAKE_DIRECTORY ${btc_protobuf_PROTOC_OUT_DIR}) + file(MAKE_DIRECTORY ${btc_PROTOC_OUT_DIR}) endif() # Get the sources from the PROTO_TARGET - if(NOT btc_protobuf_PROTOS) - get_property(_source_list TARGET ${btc_protobuf_PROTO_TARGET} PROPERTY INTERFACE_SOURCES) + if(NOT btc_PROTOS) + get_property(_source_list TARGET ${btc_PROTO_TARGET} PROPERTY INTERFACE_SOURCES) foreach(_file ${_source_list}) if(_file MATCHES "proto$") - list(APPEND btc_protobuf_PROTOS ${_file}) + list(APPEND btc_PROTOS ${_file}) endif() endforeach() - get_property(_source_list TARGET ${btc_protobuf_PROTO_TARGET} PROPERTY SOURCES) + get_property(_source_list TARGET ${btc_PROTO_TARGET} PROPERTY SOURCES) foreach(_file ${_source_list}) if(_file MATCHES "proto$") - list(APPEND btc_protobuf_PROTOS ${_file}) + list(APPEND btc_PROTOS ${_file}) endif() endforeach() endif() - if(NOT btc_protobuf_PROTOS) + if(NOT btc_PROTOS) message(SEND_ERROR "Error: protobuf_generate could not find any .proto files.") return() endif() - list(REMOVE_DUPLICATES btc_protobuf_PROTOS) + list(REMOVE_DUPLICATES btc_PROTOS) # Construct the plugin options. - foreach(_option IN LISTS btc_protobuf_PLUGIN_OPTIONS) + foreach(_option IN LISTS btc_PLUGIN_OPTIONS) # append comma - not using CMake lists and string replacement as users # might have semicolons in options if(_plugin_options) @@ -122,8 +120,8 @@ function(btc_protobuf) set(_plugin_options "${_plugin_options}${_option}") endforeach() - if(btc_protobuf_PLUGIN) - set(_plugin "--plugin=${btc_protobuf_PLUGIN}") + if(btc_PLUGIN) + set(_plugin "--plugin=${btc_PLUGIN}") endif() # Construct transitive includes using generator expressions. @@ -140,55 +138,22 @@ function(btc_protobuf) # using generator expressions. unset(_protobuf_transitive_include) + btc_transitive_includes( + PROTO_TARGET ${btc_PROTO_TARGET} + IMPORT_VARS ${btc_IMPORT_VARS} + VARNAME _protobuf_transitive_include + ) - get_property(_link_libs TARGET ${btc_protobuf_PROTO_TARGET} PROPERTY INTERFACE_LINK_LIBRARIES) - foreach(_tgt ${_link_libs}) - # When using system libs, Protobuf targets may be generated which do not exist. - set(_prop "$") - set(_expr "-I$$-I$>") - list(APPEND _protobuf_transitive_include "$<$:$<$:${_expr}>>") - endforeach() - - list(REMOVE_DUPLICATES _protobuf_transitive_include) - - # Resolve import directories, which will be used to construct - # the includes list for the proto compiler. - unset(_protobuf_imports) - get_property(_inc TARGET ${btc_protobuf_PROTO_TARGET} PROPERTY INTERFACE_INCLUDE_DIRECTORIES) - list(APPEND _protobuf_imports ${_inc}) - - foreach(_var ${btc_protobuf_IMPORT_VARS}) - if(DEFINED ${_var}) - list(APPEND _protobuf_imports ${_var}) - endif() - endforeach() - - list(REMOVE_DUPLICATES _protobuf_imports) + btc_basic_includes( + PROTO_TARGET ${btc_PROTO_TARGET} + VARNAME _protobuf_include_path + ) - # Construct the include paths - unset(_protobuf_include_path) - foreach(_dir ${_protobuf_imports}) - get_filename_component(_abs_path "${_dir}" ABSOLUTE) - list(FIND _protobuf_include_path "${_abs_path}" _contains_already) - if(${_contains_already} EQUAL -1) - list(APPEND _protobuf_include_path "-I" "${_abs_path}") - endif() - endforeach() - - list(FIND _protobuf_imports "${btc_protobuf_PROTOC_OUT_DIR}" _contains_already) - if(${_contains_already} EQUAL -1) - list(APPEND _protobuf_imports "${btc_protobuf_PROTOC_OUT_DIR}") - endif() - - list(PREPEND btc_protobuf_DEPENDS "protobuf::protoc") - list(REMOVE_DUPLICATES btc_protobuf_DEPENDS) - - if(NOT _protobuf_include_path) - set(_protobuf_include_path -I ${PROJECT_SOURCE_DIR} -I ${PROJECT_BINARY_DIR}) - endif() + list(PREPEND btc_DEPENDS "protobuf::protoc") + list(REMOVE_DUPLICATES btc_DEPENDS) set(_generated_srcs_all) - foreach(_proto ${btc_protobuf_PROTOS}) + foreach(_proto ${btc_PROTOS}) get_filename_component(_abs_file ${_proto} ABSOLUTE) get_filename_component(_abs_dir ${_abs_file} DIRECTORY) @@ -214,44 +179,45 @@ function(btc_protobuf) endif() set(_generated_srcs) - foreach(_ext ${btc_protobuf_GENERATE_EXTENSIONS}) - list(APPEND _generated_srcs "${btc_protobuf_PROTOC_OUT_DIR}/${_rel_dir}/${_basename}${_ext}") + foreach(_ext ${btc_GENERATE_EXTENSIONS}) + list(APPEND _generated_srcs "${btc_PROTOC_OUT_DIR}/${_rel_dir}/${_basename}${_ext}") endforeach() list(APPEND _generated_srcs_all ${_generated_srcs}) - set(_comment "Running ${btc_protobuf_LANGUAGE} protocol buffer compiler on ${_proto}") - if(btc_protobuf_PROTOC_OPTIONS) - set(_comment "${_comment}, protoc-options: ${btc_protobuf_PROTOC_OPTIONS}") + set(_comment "Running ${btc_LANGUAGE} protocol buffer compiler on ${_proto}") + if(btc_PROTOC_OPTIONS) + set(_comment "${_comment}, protoc-options: ${btc_PROTOC_OPTIONS}") endif() if(_plugin_options) set(_comment "${_comment}, plugin-options: ${_plugin_options}") endif() - # message(STATUS "btc_protobuf: ${btc_protobuf_VARNAME} ${_generated_srcs}") + # message(STATUS "btc_protobuf: ${btc_VARNAME} ${_generated_srcs}") add_custom_command( OUTPUT ${_generated_srcs} COMMAND protobuf::protoc - ${btc_protobuf_PROTOC_OPTIONS} --${btc_protobuf_LANGUAGE}_out - ${_plugin_options}:${btc_protobuf_PROTOC_OUT_DIR} + ${btc_PROTOC_OPTIONS} --${btc_LANGUAGE}_out + ${_plugin_options}:${btc_PROTOC_OUT_DIR} ${_plugin} ${_protobuf_include_path} "${_protobuf_transitive_include}" ${_abs_file} DEPENDS - ${_abs_file} ${btc_protobuf_DEPENDS} ${btc_protobuf_PROTO_TARGET} + ${_abs_file} ${btc_DEPENDS} ${btc_PROTO_TARGET} COMMENT ${_comment} COMMAND_EXPAND_LISTS VERBATIM ) endforeach() set_source_files_properties(${_generated_srcs_all} PROPERTIES GENERATED TRUE) - target_sources(${btc_protobuf_TARGET} PRIVATE ${_generated_srcs_all}) - set_property( - TARGET ${btc_protobuf_TARGET} - APPEND PROPERTY INCLUDE_DIRECTORIES "${btc_protobuf_PROTOC_OUT_DIR}" ) - set_property( - TARGET ${btc_protobuf_TARGET} - APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${btc_protobuf_PROTOC_OUT_DIR}" ) + + if (btc_TARGET) + target_sources(${btc_TARGET} PRIVATE ${_generated_srcs_all}) + endif() + + if(btc_VARNAME) + set(${btc_VARNAME} "${_generated_srcs_all}" PARENT_SCOPE) + endif() endfunction()