Remove swift_library and tests, lives in the apple rules repo now.

RELNOTES: The swift_library rule that is distributed with Bazel has been deleted. Users who wish to compile Swift should use the rules in https://github.com/bazelbuild/rules_apple instead.
PiperOrigin-RevId: 168032330

1 files changed, 0 insertions, 501 deletions

diff --git a/tools/build_defs/apple/swift.bzl b/tools/build_defs/apple/swift.bzl
deleted file mode 100644
index a8f1a16908..0000000000
--- a/tools/build_defs/apple/swift.bzl
+++ /dev/null
@@ -1,501 +0,0 @@
-# Copyright 2016 The Bazel Authors. All rights reserved.
-#
-# 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.
-
-"""Skylark rules for Swift.
-
-NOTE: This file is deprecated and will be removed soon. If you depend on it,
-please start using the version from the rules_apple repository
-(https://github.com/bazelbuild/rules_apple) instead.
-"""
-
-load("shared",
-     "xcrun_action",
-     "XCRUNWRAPPER_LABEL",
-     "module_cache_path",
-     "label_scoped_path")
-
-def _parent_dirs(dirs):
-  """Returns a depset of parent directories for each directory in dirs."""
-  return depset([f.rpartition("/")[0] for f in dirs])
-
-
-def _framework_names(dirs):
-  """Returns the framework name for each directory in dir."""
-  return depset([f.rpartition("/")[2].partition(".")[0] for f in dirs])
-
-
-def _intersperse(separator, iterable):
-  """Inserts separator before each item in iterable."""
-  result = []
-  for x in iterable:
-    result.append(separator)
-    result.append(x)
-
-  return result
-
-
-def _swift_target(cpu, platform, sdk_version):
-  """Returns a target triplet for Swift compiler."""
-  platform_string = str(platform.platform_type)
-  if platform_string not in ["ios", "watchos", "tvos"]:
-    fail("Platform '%s' is not supported" % platform_string)
-
-  return "%s-apple-%s%s" % (cpu, platform_string, sdk_version)
-
-
-def _swift_compilation_mode_flags(ctx):
-  """Returns additional swiftc flags for the current compilation mode."""
-  mode = ctx.var["COMPILATION_MODE"]
-
-  flags = []
-  if mode == "dbg" or mode == "fastbuild":
-    # TODO(dmishe): Find a way to test -serialize-debugging-options
-    flags += [
-        "-Onone", "-DDEBUG", "-enable-testing", "-Xfrontend",
-        "-serialize-debugging-options"
-    ]
-  elif mode == "opt":
-    flags += ["-O", "-DNDEBUG"]
-
-  if mode == "dbg" or ctx.fragments.objc.generate_dsym:
-    flags.append("-g")
-
-  return flags
-
-
-def _clang_compilation_mode_flags(ctx):
-  """Returns additional clang flags for the current compilation mode."""
-
-  # In general, every compilation mode flag from native objc_ rules should be
-  # passed, but -g seems to break Clang module compilation. Since this flag does
-  # not make much sense for module compilation and only touches headers,
-  # it's ok to omit.
-  native_clang_flags = ctx.fragments.objc.copts_for_current_compilation_mode
-
-  return [x for x in native_clang_flags if x != "-g"]
-
-
-def _swift_bitcode_flags(ctx):
-  """Returns bitcode flags based on selected mode."""
-  mode = str(ctx.fragments.apple.bitcode_mode)
-  if mode == "embedded":
-    return ["-embed-bitcode"]
-  elif mode == "embedded_markers":
-    return ["-embed-bitcode-marker"]
-
-  return []
-
-
-def swift_module_name(label):
-  """Returns a module name for the given label."""
-  return label.package.lstrip("//").replace("/", "_") + "_" + label.name
-
-
-def _swift_lib_dir(ctx):
-  """Returns the location of swift runtime directory to link against."""
-  platform_str = ctx.fragments.apple.single_arch_platform.name_in_plist.lower()
-
-  toolchain_name = "XcodeDefault"
-  if hasattr(ctx.fragments.apple, "xcode_toolchain"):
-    toolchain = ctx.fragments.apple.xcode_toolchain
-
-    # We cannot use non Xcode-packaged toolchains, and the only one non-default
-    # toolchain known to exist (as of Xcode 8.1) is this one.
-    if toolchain == "com.apple.dt.toolchain.Swift_2_3":
-      toolchain_name = "Swift_2.3"
-
-  return "{0}/Toolchains/{1}.xctoolchain/usr/lib/swift/{2}".format(
-      apple_common.apple_toolchain().developer_dir(), toolchain_name, platform_str)
-
-
-def _swift_linkopts(ctx):
-  """Returns additional linker arguments for the given rule context."""
-  return depset(["-L" + _swift_lib_dir(ctx)])
-
-
-def _swift_xcrun_args(ctx):
-  """Returns additional arguments that should be passed to xcrun."""
-  if ctx.fragments.apple.xcode_toolchain:
-    return ["--toolchain", ctx.fragments.apple.xcode_toolchain]
-
-  return []
-
-
-def _swift_parsing_flags(ctx):
-  """Returns additional parsing flags for swiftc."""
-  srcs = ctx.files.srcs
-
-  # swiftc has two different parsing modes: script and library.
-  # The difference is that in script mode top-level expressions are allowed.
-  # This mode is triggered when the file compiled is called main.swift.
-  # Additionally, script mode is used when there's just one file in the
-  # compilation. we would like to avoid that and therefore force library mode
-  # when there's only one source and it's not called main.
-  if len(srcs) == 1 and srcs[0].basename != "main.swift":
-    return ["-parse-as-library"]
-  return []
-
-
-def _is_valid_swift_module_name(string):
-  """Returns True if the string is a valid Swift module name."""
-  if not string:
-    return False
-
-  for char in string:
-    # Check that the character is in [a-zA-Z0-9_]
-    if not (char.isalnum() or char == "_"):
-      return False
-
-  return True
-
-
-def _validate_rule_and_deps(ctx):
-  """Validates the target and its dependencies."""
-
-  name_error_str = ("Error in target '%s', Swift target and its dependencies' "+
-                    "names can only contain characters in [a-zA-Z0-9_].")
-
-  # Validate the name of the target
-  if not _is_valid_swift_module_name(ctx.label.name):
-    fail(name_error_str % ctx.label)
-
-  # Validate names of the dependencies
-  for dep in ctx.attr.deps:
-    if not _is_valid_swift_module_name(dep.label.name):
-      fail(name_error_str % dep.label)
-
-
-def swiftc_inputs(ctx):
-  """Determine the list of inputs required for the compile action.
-
-  Args:
-    ctx: rule context.
-
-  Returns:
-    A list of files needed by swiftc.
-  """
-  swift_providers = [x.swift for x in ctx.attr.deps if hasattr(x, "swift")]
-  objc_providers = [x.objc for x in ctx.attr.deps if hasattr(x, "objc")]
-
-  dep_modules = []
-  for swift in swift_providers:
-    dep_modules += swift.transitive_modules
-
-  objc_files = depset()
-  for objc in objc_providers:
-    objc_files += objc.header
-    objc_files += objc.module_map
-    objc_files += depset(objc.static_framework_file)
-    objc_files += depset(objc.dynamic_framework_file)
-
-  return ctx.files.srcs + dep_modules + list(objc_files)
-
-
-def swiftc_args(ctx):
-  """Returns an almost compelete array of arguments to be passed to swiftc.
-
-  This macro is intended to be used by the swift_library rule implementation
-  below but it also may be used by other rules outside this file. It has no
-  side effects and does not modify ctx. It expects ctx to contain the same
-  fragments and attributes as swift_library (you're encouraged to depend on
-  SWIFT_LIBRARY_ATTRS in your rule definition).
-
-  Args:
-    ctx: rule context
-
-  Returns:
-    A list of command line arguments for swiftc. The returned arguments
-    include everything except the arguments generation of which would require
-    adding new files or actions.
-  """
-
-  apple_fragment = ctx.fragments.apple
-
-  cpu = apple_fragment.single_arch_cpu
-  platform = apple_fragment.single_arch_platform
-
-  target_os = apple_fragment.minimum_os_for_platform_type(
-      platform.platform_type)
-  target = _swift_target(cpu, platform, target_os)
-  apple_toolchain = apple_common.apple_toolchain()
-
-  module_name = ctx.attr.module_name or swift_module_name(ctx.label)
-
-  # A list of paths to pass with -F flag.
-  framework_dirs = depset([
-      apple_toolchain.platform_developer_framework_dir(apple_fragment)])
-
-  # Collect transitive dependecies.
-  dep_modules = []
-  swiftc_defines = ctx.attr.defines
-
-  swift_providers = [x.swift for x in ctx.attr.deps if hasattr(x, "swift")]
-  objc_providers = [x.objc for x in ctx.attr.deps if hasattr(x, "objc")]
-
-  for swift in swift_providers:
-    dep_modules += swift.transitive_modules
-    swiftc_defines += swift.transitive_defines
-
-  objc_includes = depset()     # Everything that needs to be included with -I
-  objc_module_maps = depset()  # Module maps for dependent targets
-  objc_defines = depset()
-  static_frameworks = depset()
-  for objc in objc_providers:
-    objc_includes += objc.include
-    objc_module_maps += objc.module_map
-
-    static_frameworks += _framework_names(objc.framework_dir)
-    framework_dirs += _parent_dirs(objc.framework_dir)
-    framework_dirs += _parent_dirs(objc.dynamic_framework_dir)
-
-    # objc_library#copts is not propagated to its dependencies and so it is not
-    # collected here. In theory this may lead to un-importable targets (since
-    # their module cannot be compiled by clang), but did not occur in practice.
-    objc_defines += objc.define
-
-  srcs_args = [f.path for f in ctx.files.srcs]
-
-  # Include each swift module's parent directory for imports to work.
-  include_dirs = depset([x.dirname for x in dep_modules])
-
-  # Include the genfiles root so full-path imports can work for generated protos.
-  include_dirs += depset([ctx.genfiles_dir.path])
-
-  include_args = ["-I%s" % d for d in include_dirs + objc_includes]
-  framework_args = ["-F%s" % x for x in framework_dirs]
-  define_args = ["-D%s" % x for x in swiftc_defines]
-
-  # Disable the LC_LINKER_OPTION load commands for static frameworks automatic
-  # linking. This is needed to correctly deduplicate static frameworks from also
-  # being linked into test binaries where it is also linked into the app binary.
-  autolink_args =_intersperse(
-      "-Xfrontend",
-      _intersperse("-disable-autolink-framework", static_frameworks))
-
-  clang_args = _intersperse(
-      "-Xcc",
-
-      # Add the current directory to clang's search path.
-      # This instance of clang is spawned by swiftc to compile module maps and
-      # is not passed the current directory as a search path by default.
-      ["-iquote", "."]
-
-      # Pass DEFINE or copt values from objc configuration and rules to clang
-      + ["-D" + x for x in objc_defines] + ctx.fragments.objc.copts
-      + _clang_compilation_mode_flags(ctx)
-
-      # Load module maps explicitly instead of letting Clang discover them on
-      # search paths. This is needed to avoid a case where Clang may load the
-      # same header both in modular and non-modular contexts, leading to
-      # duplicate definitions in the same file.
-      # https://llvm.org/bugs/show_bug.cgi?id=19501
-      + ["-fmodule-map-file=%s" % x.path for x in objc_module_maps])
-
-  args = [
-      "-emit-object",
-      "-module-name",
-      module_name,
-      "-target",
-      target,
-      "-sdk",
-      apple_toolchain.sdk_dir(),
-      "-module-cache-path",
-      module_cache_path(ctx),
-  ]
-
-  if ctx.configuration.coverage_enabled:
-    args.extend(["-profile-generate", "-profile-coverage-mapping"])
-
-  args.extend(_swift_compilation_mode_flags(ctx))
-  args.extend(_swift_bitcode_flags(ctx))
-  args.extend(_swift_parsing_flags(ctx))
-  args.extend(srcs_args)
-  args.extend(include_args)
-  args.extend(framework_args)
-  args.extend(clang_args)
-  args.extend(define_args)
-  args.extend(autolink_args)
-  args.extend(ctx.fragments.swift.copts())
-  args.extend(ctx.attr.copts)
-
-  return args
-
-
-def _swift_library_impl(ctx):
-  """Implementation for swift_library Skylark rule."""
-  print("This file is deprecated and will be removed soon. Please start " +
-        "using the version from the rules_apple repository " +
-        "(https://github.com/bazelbuild/rules_apple) instead.")
-
-  _validate_rule_and_deps(ctx)
-
-  # Collect transitive dependecies.
-  dep_modules = []
-  dep_libs = []
-  swiftc_defines = ctx.attr.defines
-
-  swift_providers = [x.swift for x in ctx.attr.deps if hasattr(x, "swift")]
-  objc_providers = [x.objc for x in ctx.attr.deps if hasattr(x, "objc")]
-
-  for swift in swift_providers:
-    dep_libs += swift.transitive_libs
-    dep_modules += swift.transitive_modules
-    swiftc_defines += swift.transitive_defines
-
-  # A unique path for rule's outputs.
-  objs_outputs_path = label_scoped_path(ctx, "_objs/")
-
-  module_name = ctx.attr.module_name or swift_module_name(ctx.label)
-  output_lib = ctx.new_file(objs_outputs_path + module_name + ".a")
-  output_module = ctx.new_file(objs_outputs_path + module_name + ".swiftmodule")
-
-  # These filenames are guaranteed to be unique, no need to scope.
-  output_header = ctx.new_file(ctx.label.name + "-Swift.h")
-  swiftc_output_map_file = ctx.new_file(ctx.label.name + ".output_file_map.json")
-
-  swiftc_output_map = struct()  # Maps output types to paths.
-  output_objs = []  # Object file outputs, used in archive action.
-  swiftc_outputs = []  # Other swiftc outputs that aren't processed further.
-
-  # Check if the user enabled Whole Module Optimization (WMO)
-  # This is highly experimental and tracked in b/29465250
-  has_wmo = ("-wmo" in ctx.attr.copts) or ("-whole-module-optimization" in ctx.attr.copts)
-
-  for source in ctx.files.srcs:
-    basename = source.basename
-    output_map_entry = {}
-
-    # Output an object file
-    obj = ctx.new_file(objs_outputs_path + basename + ".o")
-    output_objs.append(obj)
-    output_map_entry["object"] = obj.path
-
-    # Output a partial module file, unless WMO is enabled in which case only
-    # the final, complete module will be generated.
-    if not has_wmo:
-      partial_module = ctx.new_file(objs_outputs_path + basename +
-                                    ".partial_swiftmodule")
-      swiftc_outputs.append(partial_module)
-      output_map_entry["swiftmodule"] = partial_module.path
-
-    swiftc_output_map += struct(**{source.path: struct(**output_map_entry)})
-
-  # Write down the intermediate outputs map for this compilation, to be used
-  # with -output-file-map flag.
-  # It's a JSON file that maps each source input (.swift) to its outputs
-  # (.o, .bc, .d, ...)
-  # Example:
-  #   {'foo.swift':
-  #       {'object': 'foo.o', 'bitcode': 'foo.bc', 'dependencies': 'foo.d'}}
-  # There's currently no documentation on this option, however all of the keys
-  # are listed here https://github.com/apple/swift/blob/swift-2.2.1-RELEASE/include/swift/Driver/Types.def
-  ctx.file_action(output=swiftc_output_map_file, content=swiftc_output_map.to_json())
-
-  args = _swift_xcrun_args(ctx) + ["swiftc"] + swiftc_args(ctx)
-  args += [
-      "-I" + output_module.dirname,
-      "-emit-module-path",
-      output_module.path,
-      "-emit-objc-header-path",
-      output_header.path,
-      "-output-file-map",
-      swiftc_output_map_file.path,
-  ]
-
-  if has_wmo:
-    # WMO has two modes: threaded and not. We want the threaded mode because it
-    # will use the output map we generate. This leads to a better debug
-    # experience in lldb and Xcode.
-    # TODO(b/32571265): 12 has been chosen as the best option for a Mac Pro,
-    # we should get an interface in Bazel to get core count.
-    args.extend(["-num-threads", "12"])
-
-  xcrun_action(
-      ctx,
-      inputs=swiftc_inputs(ctx) + [swiftc_output_map_file],
-      outputs=[output_module, output_header] + output_objs + swiftc_outputs,
-      mnemonic="SwiftCompile",
-      arguments=args,
-      use_default_shell_env=False,
-      progress_message=("Compiling Swift module %s (%d files)" %
-                        (ctx.label.name, len(ctx.files.srcs))))
-
-  xcrun_action(ctx,
-               inputs=output_objs,
-               outputs=(output_lib,),
-               mnemonic="SwiftArchive",
-               arguments=[
-                   "libtool", "-static", "-o", output_lib.path
-               ] + [x.path for x in output_objs],
-               progress_message=("Archiving Swift objects %s" % ctx.label.name))
-
-  # This tells the linker to write a reference to .swiftmodule as an AST symbol
-  # in the final binary.
-  # With dSYM enabled, this results in a __DWARF,__swift_ast section added to
-  # the dSYM binary, from where LLDB is able deserialize module information.
-  # Without dSYM, LLDB will follow the AST references, however there is a bug
-  # where it follows only the first one https://bugs.swift.org/browse/SR-2637
-  # This means that dSYM is required for debugging until that is resolved.
-  extra_linker_args = ["-Xlinker -add_ast_path -Xlinker " + output_module.path]
-
-  objc_provider = apple_common.new_objc_provider(
-      library=depset([output_lib] + dep_libs),
-      header=depset([output_header]),
-      providers=objc_providers,
-      linkopt=_swift_linkopts(ctx) + extra_linker_args,
-      link_inputs=depset([output_module]),
-      uses_swift=True,)
-
-  return struct(
-      swift=struct(
-          transitive_libs=[output_lib] + dep_libs,
-          transitive_modules=[output_module] + dep_modules,
-          transitive_defines=swiftc_defines),
-      objc=objc_provider,
-      files=depset([output_lib, output_module, output_header]))
-
-SWIFT_LIBRARY_ATTRS = {
-    "srcs": attr.label_list(allow_files = [".swift"], allow_empty=False),
-    "deps": attr.label_list(providers=[["swift"], ["objc"]]),
-    "module_name": attr.string(mandatory=False),
-    "defines": attr.string_list(mandatory=False, allow_empty=True),
-    "copts": attr.string_list(mandatory=False, allow_empty=True),
-    "_xcrunwrapper": attr.label(
-        executable=True,
-        cfg="host",
-        default=Label(XCRUNWRAPPER_LABEL))
-}
-
-swift_library = rule(
-    _swift_library_impl,
-    attrs = SWIFT_LIBRARY_ATTRS,
-    fragments = ["apple", "objc", "swift"],
-    output_to_genfiles=True,
-)
-"""
-Builds a Swift module.
-
-A module is a pair of static library (.a) + module header (.swiftmodule).
-Dependant targets can import this module as "import RuleName".
-
-Args:
-  srcs: Swift sources that comprise this module.
-  deps: Other Swift modules.
-  module_name: Optional. Sets the Swift module name for this target. By default
-      the module name is the target path with all special symbols replaced
-      by "_", e.g. //foo:bar can be imported as "foo_bar".
-  copts: A list of flags passed to swiftc command line.
-  defines: Each VALUE in this attribute is passed as -DVALUE to the compiler for
-      this and dependent targets.
-"""