Protobuf schema change detected

Signed-off-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: nektos/act

.bazelbsp/.bazelproject

@@ -0,0 +1,10 @@
+# This project view file may be overwritten by the Bazel plugin.
+# To use it as default, place it in the Bazel module or workspace root directory.
+# For more options, see project view file documentation: https://www.jetbrains.com/help/idea/bazel-project-view.html
+
+derive_targets_from_directories: true
+directories: .
+
+# Uncomment these lines to make indexing quicker:
+# import_depth: 0
+# import_ijars: true

.bazelbsp/BUILD

@@ -0,0 +1,5 @@
+filegroup(
+    name = "aspects",
+    srcs = glob(["**"]),
+    visibility = ["//visibility:public"],
+)

.bazelbsp/WORKSPACE

@@ -0,0 +1,181 @@
+# Copyright 2019-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+
+load("//aspects:extensions.bzl", "EXTENSIONS", "TOOLCHAINS")
+load("//aspects:utils/utils.bzl", "ALL_DEPS", "COMPILE_DEPS", "PRIVATE_COMPILE_DEPS", "RUNTIME_DEPS", "abs", "collect_targets_from_attrs", "create_struct", "file_location", "get_aspect_ids", "update_sync_output_groups")
+load("//aspects:rules/java/java_info.bzl", "java_info_in_target", "java_info_reference")
+
+def create_all_extension_info(target, ctx, output_groups, dep_targets):
+    all_info = [create_extension_info(target = target, ctx = ctx, output_groups = output_groups, dep_targets = dep_targets) for create_extension_info in EXTENSIONS]
+    return [(info, exported_properties) for info, exported_properties in all_info if info != None]
+
+COMPILE = 0
+RUNTIME = 1
+
+def make_dep(dep, dependency_type):
+    return struct(
+        id = str(dep.bsp_info.id),
+        dependency_type = dependency_type,
+    )
+
+def make_deps(deps, dependency_type):
+    return [make_dep(dep, dependency_type) for dep in deps]
+
+def _is_proto_library_wrapper(target, ctx):
+    if not ctx.rule.kind.endswith("proto_library") or ctx.rule.kind == "proto_library":
+        return False
+
+    deps = collect_targets_from_attrs(ctx.rule.attr, ["deps"])
+    return len(deps) == 1 and deps[0].bsp_info and deps[0].bsp_info.kind == "proto_library"
+
+def _get_forwarded_deps(target, ctx):
+    if _is_proto_library_wrapper(target, ctx):
+        return collect_targets_from_attrs(ctx.rule.attr, ["deps"])
+    return []
+
+def _is_analysis_test(target):
+    """Returns if the target is an analysis test.
+
+    Rules created with analysis_test=True cannot create write actions, so the
+    aspect should skip them.
+    """
+    return AnalysisTestResultInfo in target
+
+def files_to_list(source):
+    if not hasattr(source, "files"):
+        return []
+    return source.files.to_list()
+
+def _bsp_target_info_aspect_impl(target, ctx):
+    if target.label.name.endswith(".semanticdb") or _is_analysis_test(target):
+        return []
+
+    rule_attrs = ctx.rule.attr
+    rule_kind = ctx.rule.kind
+
+    direct_dep_targets = collect_targets_from_attrs(rule_attrs, COMPILE_DEPS)
+    private_direct_dep_targets = collect_targets_from_attrs(rule_attrs, PRIVATE_COMPILE_DEPS)
+    direct_deps = make_deps(direct_dep_targets, COMPILE)
+
+    exported_deps_from_deps = []
+    if ${isPropagateExportsFromDepsEnabled}:
+        for dep in direct_dep_targets:
+            exported_deps_from_deps = exported_deps_from_deps + dep.bsp_info.export_deps
+
+    compile_deps = direct_deps + exported_deps_from_deps
+
+    runtime_dep_targets = collect_targets_from_attrs(rule_attrs, RUNTIME_DEPS)
+    runtime_deps = make_deps(runtime_dep_targets, RUNTIME)
+
+    all_deps = depset(compile_deps + runtime_deps).to_list()
+
+    # Propagate my own exports
+    export_deps = []
+    direct_exports = []
+    if java_info_in_target(target):
+        direct_exports = collect_targets_from_attrs(rule_attrs, ["exports"])
+        export_deps.extend(make_deps(direct_exports, COMPILE))
+        for export in direct_exports:
+            export_deps.extend(export.bsp_info.export_deps)
+        export_deps = depset(export_deps).to_list()
+
+    forwarded_deps = _get_forwarded_deps(target, ctx) + direct_exports
+
+    dep_targets = direct_dep_targets + private_direct_dep_targets + runtime_dep_targets + direct_exports
+    output_groups = dict()
+    for dep in dep_targets:
+        for k, v in dep.bsp_info.output_groups.items():
+            output_groups[k] = output_groups[k] + [v] if k in output_groups else [v]
+
+    for k, v in output_groups.items():
+        output_groups[k] = depset(transitive = v)
+
+    srcs_attr = getattr(ctx.rule.attr, "srcs", [])
+    sources = []
+    generated_sources = []
+
+    if type(srcs_attr) == "list":
+        all_sources = [
+            file_location(f)
+            for t in srcs_attr
+            for f in files_to_list(t)
+            if not f.is_directory
+        ]
+
+        sources = [
+            s
+            for s in all_sources
+            if s.is_source
+        ]
+
+        generated_sources = [
+            s
+            for s in all_sources
+            if not s.is_source
+        ]
+
+    resources_attr = getattr(ctx.rule.attr, "resources", [])
+    resources = []
+
+    if type(resources_attr) == "list":
+        resources = [
+            file_location(f)
+            for t in resources_attr
+            for f in files_to_list(t)
+        ]
+
+    aspect_ids = get_aspect_ids(ctx, target)
+
+    default_info = target[DefaultInfo]
+    executable = default_info and default_info.files_to_run.executable != None
+
+    env = getattr(rule_attrs, "env", {})
+    if type(env) == "Target":
+        env = str(env.label)
+
+    info = dict(
+        id = str(target.label),
+        kind = rule_kind,
+        tags = rule_attrs.tags,
+        dependencies = list(all_deps),
+        sources = sources,
+        generated_sources = generated_sources,
+        resources = resources,
+        env = env,
+        env_inherit = getattr(rule_attrs, "env_inherit", []),
+        executable = executable,
+    )
+
+    exported_properties = dict(
+        id = target.label,
+        kind = rule_kind,
+        export_deps = export_deps,
+        output_groups = output_groups,
+    )
+
+    all_extension_info = create_all_extension_info(target, ctx, output_groups, dep_targets)
+    for (extension_info, extension_exported_properties) in all_extension_info:
+        info.update(extension_info)
+        if extension_exported_properties != None:
+            exported_properties.update(extension_exported_properties)
+
+    file_name = target.label.name
+    file_name = file_name + "-" + str(abs(hash(file_name)))
+    if aspect_ids:
+        file_name = file_name + "-" + str(abs(hash(".".join(aspect_ids))))
+    file_name = "bsp.%s.bsp-info.textproto" % file_name
+    info_file = ctx.actions.declare_file(file_name)
+    ctx.actions.write(info_file, proto.encode_text(create_struct(**info)))
+    update_sync_output_groups(output_groups, "bsp-target-info", depset([info_file]))
+
+    return struct(
+        bsp_info = struct(**exported_properties),
+        output_groups = output_groups,
+    )
+
+bsp_target_info_aspect = aspect(
+    implementation = _bsp_target_info_aspect_impl,
+    required_aspect_providers = [java_info_reference()],
+    attr_aspects = ALL_DEPS,
+    toolchains = TOOLCHAINS,
+    fragments = ["cpp"]
+)

.bazelbsp/aspects/BUILD

@@ -0,0 +1,129 @@
+load("//aspects:utils/utils.bzl", "create_file_location", "create_struct", "file_location")
+
+ANDROID_SDK_TOOLCHAIN_TYPE = ${toolchainType}
+
+def extract_android_info(target, ctx, dep_targets, **kwargs):
+    if ANDROID_SDK_TOOLCHAIN_TYPE not in ctx.toolchains:
+        return None, None
+    android_sdk_toolchain = ctx.toolchains[ANDROID_SDK_TOOLCHAIN_TYPE]
+
+    if android_sdk_toolchain == None:
+        return None, None
+    android_sdk_info = android_sdk_toolchain.android_sdk_info
+    if android_sdk_info == None:
+        return None, None
+    android_jar = file_location(android_sdk_info.android_jar)
+    if android_jar == None:
+        return None, None
+
+    manifest = None
+    if hasattr(ctx.rule.attr, "manifest") and ctx.rule.attr.manifest:
+        if type(ctx.rule.attr.manifest) == "depset":
+            manifest_targets = ctx.rule.attr.manifest.to_list()
+            if manifest_targets:
+                manifest_target = manifest_targets[0]
+        elif type(ctx.rule.attr.manifest) == "list" and ctx.rule.attr.manifest:
+            manifest_target = ctx.rule.attr.manifest[0]
+        else:
+            manifest_target = ctx.rule.attr.manifest
+        if type(manifest_target) == "Target":
+            manifest_files = manifest_target.files.to_list()
+            if manifest_files:
+                manifest = file_location(manifest_files[0])
+        else:
+            manifest = file_location(manifest_target)
+
+    manifest_overrides = {}
+    if hasattr(ctx.rule.attr, "manifest_values"):
+        for key, value in ctx.rule.attr.manifest_values.items():
+            if key != None and value != None:
+                manifest_overrides[key] = value
+
+    resource_directories_set = {}
+    if hasattr(ctx.rule.attr, "resource_files"):
+        for resource in ctx.rule.attr.resource_files:
+            for resource_file in resource.files.to_list():
+                resource_file_location = file_location(resource_file)
+                resource_source_dir_relative_path = android_common.resource_source_directory(resource_file)
+                if resource_source_dir_relative_path == None:
+                    continue
+                resource_source_dir_location = \
+                    set_relative_path(resource_file_location, resource_source_dir_relative_path)
+
+                # Add to set
+                resource_directories_set[resource_source_dir_location] = None
+
+    resource_java_package = None
+    if hasattr(ctx.rule.attr, "custom_package"):
+        resource_java_package = ctx.rule.attr.custom_package
+
+    assets_directories = []
+    if hasattr(ctx.rule.attr, "assets") and ctx.rule.attr.assets and \
+       hasattr(ctx.rule.attr, "assets_dir") and ctx.rule.attr.assets_dir:
+        first_asset_files = ctx.rule.attr.assets[0].files.to_list()
+        if first_asset_files:
+            first_asset = first_asset_files[0]
+            first_asset_location = file_location(first_asset)
+            asset_folder_relative_path = ctx.label.package + "/" + ctx.rule.attr.assets_dir
+            asset_folder_location = set_relative_path(first_asset_location, asset_folder_relative_path)
+            assets_directories.append(asset_folder_location)
+
+    aidl_binary_jar = None
+    aidl_source_jar = None
+    apk = None
+    if AndroidIdeInfo in target:
+        android_ide_info = target[AndroidIdeInfo]
+        if android_ide_info.idl_class_jar:
+            aidl_binary_jar = file_location(android_ide_info.idl_class_jar)
+        if android_ide_info.idl_source_jar:
+            aidl_source_jar = file_location(android_ide_info.idl_source_jar)
+        if android_ide_info.signed_apk:
+            apk = file_location(android_ide_info.signed_apk)
+
+    android_target_info = create_struct(
+        android_jar = android_jar,
+        manifest = manifest,
+        manifest_overrides = manifest_overrides,
+        resource_directories = resource_directories_set.keys(),
+        resource_java_package = resource_java_package,
+        assets_directories = assets_directories,
+        aidl_binary_jar = aidl_binary_jar,
+        aidl_source_jar = aidl_source_jar,
+        apk = apk,
+    )
+
+    return dict(android_target_info = android_target_info), None
+
+def set_relative_path(location, new_relative_path):
+    return create_file_location(
+        relative_path = new_relative_path,
+        is_source = location.is_source,
+        is_external = location.is_external,
+        root_execution_path_fragment = location.root_execution_path_fragment,
+    )
+
+def extract_android_aar_import_info(target, ctx, dep_targets, **kwargs):
+    if ctx.rule.kind != "aar_import":
+        return None, None
+
+    if AndroidManifestInfo not in target:
+        return None, None
+    manifest = file_location(target[AndroidManifestInfo].manifest)
+
+    resource_folder = None
+    r_txt = None
+    if AndroidResourcesInfo in target:
+        direct_android_resources = target[AndroidResourcesInfo].direct_android_resources.to_list()
+        if direct_android_resources:
+            direct_android_resource = direct_android_resources[0]
+            resource_files = direct_android_resource.resources
+            if resource_files:
+                resource_folder = file_location(resource_files[0])
+            r_txt = file_location(direct_android_resource.r_txt)
+
+    android_aar_import_info = create_struct(
+        manifest = manifest,
+        resource_folder = resource_folder,
+        r_txt = r_txt,
+    )
+    return dict(android_aar_import_info = android_aar_import_info), None