Support for Swift language and Clang modules for ninja generator.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import collections
 import copy
 import hashlib
 import json
 import multiprocessing
 import os.path
@@ skipping 122 matching lines @@
     # File representing the completion of actions/rules/copies, if any.
     self.actions_stamp = None
     # Path to the output of the link step, if any.
     self.binary = None
     # Path to the file representing the completion of building the bundle,
     # if any.
     self.bundle = None
     # On Windows, incremental linking requires linking against all the .objs
     # that compose a .lib (rather than the .lib itself). That list is stored
     # here.
+
+    # Path to the file representing completion of building module, if any.
+    self.module_stamp = None
+
     self.component_objs = None
     # Windows only. The import .lib is the output of a build step, but
     # because dependents only link against the lib (not both the lib and the
     # dll) we keep track of the import library here.
     self.import_lib = None
 
   def Linkable(self):
     """Return true if this is a target that can be linked against."""
     return self.type in ('static_library', 'shared_library')
 
@@ skipping 142 matching lines @@
     if path.startswith('$!'):
       expanded = self.ExpandSpecial(path)
       if self.flavor == 'win':
         expanded = os.path.normpath(expanded)
       return expanded
     if '$|' in path:
       path = self.ExpandSpecial(path)
     assert '$' not in path, path
     return os.path.normpath(os.path.join(self.build_to_base, path))
 
+  def GypPathToNinjaWithToolchain(self, path):
+    return self.GypPathToNinja(path, self.GetToolchainEnv())
+
   def GypPathToUniqueOutput(self, path, qualified=True):
     """Translate a gyp path to a ninja path for writing output.
 
     If qualified is True, qualify the resulting filename with the name
     of the target.  This is necessary when e.g. compiling the same
     path twice for two separate output targets.
 
     See the above discourse on path conversions."""
 
     path = self.ExpandSpecial(path)
@@ skipping 54 matching lines @@
     self.name = spec['target_name']
     self.toolset = spec['toolset']
     config = spec['configurations'][config_name]
     self.target = Target(spec['type'])
     self.is_standalone_static_library = bool(
         spec.get('standalone_static_library', 0))
     # Track if this target contains any C++ files, to decide if gcc or g++
     # should be used for linking.
     self.uses_cpp = False
 
+    # Track if there are any swift sources
+    self.uses_swift = False
+
     self.is_mac_bundle = gyp.xcode_emulation.IsMacBundle(self.flavor, spec)
     self.xcode_settings = self.msvs_settings = None
     if self.flavor == 'mac':
       self.xcode_settings = gyp.xcode_emulation.XcodeSettings(spec)
     if self.flavor == 'win':
       self.msvs_settings = gyp.msvs_emulation.MsvsSettings(spec,
                                                            generator_flags)
       arch = self.msvs_settings.GetArch(config_name)
       self.ninja.variable('arch', self.win_env[arch])
       self.ninja.variable('cc', '$cl_' + arch)
@@ skipping 12 matching lines @@
                            'w')))
             for arch in self.archs)
 
     # Compute predepends for all rules.
     # actions_depends is the dependencies this target depends on before running
     # any of its action/rule/copy steps.
     # compile_depends is the dependencies this target depends on before running
     # any of its compile steps.
     actions_depends = []
     compile_depends = []
+    module_depends = []
     # TODO(evan): it is rather confusing which things are lists and which
     # are strings.  Fix these.
     if 'dependencies' in spec:
       for dep in spec['dependencies']:
         if dep in self.target_outputs:
           target = self.target_outputs[dep]
           actions_depends.append(target.PreActionInput(self.flavor))
           compile_depends.append(target.PreCompileInput())
+          module_depends.append(target.module_stamp)
       actions_depends = filter(None, actions_depends)
       compile_depends = filter(None, compile_depends)
+      module_depends = filter(None, module_depends)
+      if (self.flavor == 'mac' and
+          self.xcode_settings.AreModulesEnabled(config_name)):
+        compile_depends += module_depends
+
       actions_depends = self.WriteCollapsedDependencies('actions_depends',
                                                         actions_depends)
       compile_depends = self.WriteCollapsedDependencies('compile_depends',
                                                         compile_depends)
       self.target.preaction_stamp = actions_depends
       self.target.precompile_stamp = compile_depends
 
     # Write out actions, rules, and copies.  These must happen before we
     # compile any sources, so compute a list of predependencies for sources
     # while we do it.
     extra_sources = []
     mac_bundle_depends = []
     self.target.actions_stamp = self.WriteActionsRulesCopies(
         spec, extra_sources, actions_depends, mac_bundle_depends)
 
     # If we have actions/rules/copies, we depend directly on those, but
     # otherwise we depend on dependent target's actions/rules/copies etc.
     # We never need to explicitly depend on previous target's link steps,
     # because no compile ever depends on them.
     compile_depends_stamp = (self.target.actions_stamp or compile_depends)
 
+    if self.flavor == 'mac':
+      # Module should be written before compilaton, because Swift compiler
+      # use it
+      module_stamp = self.WriteModule(self.ninja, compile_depends_stamp,
+                                      config_name, spec)
+      if module_stamp:
+        compile_depends_stamp = module_stamp
+
     # Write out the compilation steps, if any.
     link_deps = []
     sources = extra_sources + spec.get('sources', [])
     if sources:
       if self.flavor == 'mac' and len(self.archs) > 1:
         # Write subninja file containing compile and link commands scoped to
         # a single arch if a fat binary is being built.
         for arch in self.archs:
           self.ninja.subninja(self._SubninjaNameForArch(arch))
 
@@ skipping 396 matching lines @@
           [partial_info_plist, info_plist])
 
     keys = self.xcode_settings.GetExtraPlistItems(self.config_name)
     keys = QuoteShellArgument(json.dumps(keys), self.flavor)
     isBinary = self.xcode_settings.IsBinaryOutputFormat(self.config_name)
     self.ninja.build(out, 'copy_infoplist', info_plist,
                      variables=[('env', env), ('keys', keys),
                                 ('binary', isBinary)])
     bundle_depends.append(out)
 
+  def _AddSwiftModuleExt(self, module):
+    return module + '.swiftmodule'
+
+  def _GetSwiftModulePath(self, config_name, spec, arch=None):
+    module_path = self._AddSwiftModuleExt(
+        self.xcode_settings.GetProductModuleName(config_name))
+    if self._IsFramework(spec):
+      module_path = os.path.join(
+          self.xcode_settings.GetBundleModulesFolderPath(), module_path)
+    if arch:
+      # Fixing path for armv7, since Xcode expects it to have 'arm' name instead
+      if arch == 'armv7':
+        arch = 'arm'
+      module_path = os.path.join(module_path, self._AddSwiftModuleExt(arch))
+    return module_path
+
+  def WriteFrameworkHeaders(self, ninja_file, headers, headers_dir):
+    outputs = []
+    for header in headers:
+      out_path = os.path.join(headers_dir, os.path.basename(header))
+      outputs.append(out_path)
+      self.ninja.build(out_path, 'mac_tool', header,
+                       variables=[('mactool_cmd', 'copy-bundle-resource'), \
+                                  ('binary', False)])
+    return outputs
+
+  def _GetModuleMapFilePath(self):
+    return os.path.join(self.xcode_settings.GetBundleModulesFolderPath(),
+                        'module.modulemap')
+
+  def _IsFramework(self, spec):
+    is_framework = (spec['type'] == 'shared_library') and self.is_mac_bundle
+    return is_framework
+
+  def WriteModule(self, ninja_file, predepends, config_name, spec):
+    """Write build rules to build Clang module."""
+    if not self.xcode_settings.IsModuleDefined(config_name):
+      return None
+    if not self._IsFramework(spec):
+      # There are no any actions by Xcode for non-framework targets
+      return None
+
+    assert self.xcode_settings.AreModulesEnabled(config_name)
+
+    ninja_file.newline()
+
+    module_inputs = []
+    # Copying headers to framework
+    public_headers = map(self.GypPathToNinja,
+                         list(spec.get('mac_framework_headers', [])))
+    module_inputs += self.WriteFrameworkHeaders(
+        ninja_file, public_headers,
+        self.xcode_settings.GetBundlePublicHeadersFolderPath())
+
+    private_headers = map(self.GypPathToNinja,
+                          list(spec.get('mac_framework_private_headers', [])))
+    module_inputs += self.WriteFrameworkHeaders(
+        ninja_file, private_headers,
+        self.xcode_settings.GetBundlePrivateHeadersFolderPath())
+
+    module_name = self.xcode_settings.GetProductModuleName(config_name)
+    umbrella_header = None
+    for header in public_headers:
+      filename, _ = os.path.splitext(os.path.basename(header))
+      if filename == module_name:
+        umbrella_header = header
+        break
+
+    assert umbrella_header
+
+    # Building module map file in the /Modules folder
+    module_map_path = self._GetModuleMapFilePath()
+    variables = {
+        'module_name': module_name,
+        'umbrella_header': os.path.basename(umbrella_header),
+        'map_file': QuoteShellArgument(module_map_path, self.flavor)
+    }
+    module_map_stamp = self.GypPathToUniqueOutput('modulemap.stamp')
+    self.ninja.build(module_map_stamp, 'modulemap', [umbrella_header],
+                     variables=variables)
+    module_inputs.append(module_map_stamp)
+
+    # Resulting module stamp
+    module_stamp = self.GypPathToUniqueOutput('module.stamp')
+    self.ninja.build(module_stamp, 'stamp', module_inputs,
+                     order_only=predepends)
+    self.target.module_stamp = module_stamp
+    ninja_file.newline()
+    return module_stamp
+
+  def _as_list(self, input):
+      if input is None:
+          return []
+      if isinstance(input, list):
+          return input
+      return [input]
+
+  def WriteSwiftSourcesForArch(self, ninja_file, config_name, sources,
+                               predepends, spec, arch=None):
+    assert self.flavor == 'mac'
+
+    # Collecting all Swift sources
+    swift_sources = []
+    for source in sources:
+      filename, ext = os.path.splitext(source)
+      ext = ext[1:]
+      if ext == 'swift':
+        swift_sources.append(self.GypPathToNinja(source))
+    if not swift_sources:
+      return ([], None)
+
+    if not gyp.xcode_emulation.IsSwiftSupported():
+      raise Exception('You are trying to build Swift files '
+                      'with unsupported Xcode version.')
+    self.uses_swift = True
+
+    if not arch:
+      arch = self.archs[0]
+
+    # Writing compile flags
+    swift_compile_flags = self.xcode_settings.GetSwiftCompileFlags(
+        config_name, self.GypPathToNinjaWithToolchain, arch)
+    self.WriteVariableList(ninja_file, 'swift_compile_flags',
+                           map(self.ExpandSpecial, swift_compile_flags))
+    ninja_file.newline()
+
+    single_rule = self.xcode_settings.IsSwiftWMOEnabled(config_name)
+
+    # Writing per-file rules
+    link_deps = []
+    partial_modules = []
+    for source in swift_sources:
+      filename, ext = os.path.splitext(os.path.basename(source))
+      obj_path = self.GypPathToUniqueOutput(filename + self.obj_ext)
+      obj_path = AddArch(obj_path, arch)
+      src_module_path = self.GypPathToUniqueOutput(
+          self._AddSwiftModuleExt(filename))
+      src_module_path = AddArch(src_module_path, arch)
+
+      link_deps.append(obj_path)
+      partial_modules.append(src_module_path)
+
+      if not single_rule:
+        compile_input = [source]
+        for another_source in swift_sources:
+          if source != another_source:
+            compile_input.append(another_source)
+
+        variables = {
+          'out_obj': QuoteShellArgument(obj_path, self.flavor),
+          'out_module': QuoteShellArgument(src_module_path, self.flavor)
+        }
+        ninja_file.build([obj_path, src_module_path], 'swift_perfile',
+                         compile_input, variables=variables,
+                         order_only=predepends)
+
+    module_predepends = self._as_list(predepends)
+
+    # Writing header for first arch without arch extension.
+    # Obj sources will use it when referencing to <Module>-Swift.h file
+    common_header_path = self.xcode_settings.GetSwiftHeaderPath(
+        config_name, self.GypPathToNinja)
+    if arch == self.archs[0]:
+      header_path = common_header_path
+    else:
+      header_path = self.xcode_settings.GetSwiftHeaderPath(
+          config_name, self.GypPathToNinja, arch)
+      module_predepends.append(common_header_path)
+
+    module_path = self._GetSwiftModulePath(config_name, spec, arch)
+
+    if single_rule:
+      out_objects = ''
+      for obj in link_deps:
+        out_objects += ' -o ' + obj
+      variables = {
+        'out_module': QuoteShellArgument(module_path, self.flavor),
+        'out_header': QuoteShellArgument(header_path, self.flavor),
+        'out_objects': QuoteShellArgument(out_objects, self.flavor),
+        'num_threads': str(multiprocessing.cpu_count())
+      }
+      ninja_file.build(link_deps + [module_path, header_path], 'swift',
+                       swift_sources, variables=variables,
+                       order_only=module_predepends)
+    else:
+      # Writing Swift merge flags
+      ninja_file.newline()
+      swift_merge_flags = self.xcode_settings.GetSwiftMergeFlags(
+          config_name, self.GypPathToNinjaWithToolchain, arch)
+      self.WriteVariableList(ninja_file, 'swift_merge_flags',
+                             map(self.ExpandSpecial, swift_merge_flags))
+      # Writing merge rule
+      ninja_file.newline()
+      variables = {
+        'out_module': QuoteShellArgument(module_path, self.flavor),
+        'out_header': QuoteShellArgument(header_path, self.flavor),
+      }
+      ninja_file.build([module_path, header_path], 'swift_merge',
+                       partial_modules, variables=variables,
+                       order_only=module_predepends)
+      ninja_file.newline()
+
+    return (link_deps, module_path)
+
+  def WriteSwiftModule(self, ninja_file, config_name, spec):
+    """Write build rules to build Swift module data"""
+    if not self.uses_swift:
+      return
+
+    assert self.xcode_settings.AreModulesEnabled(config_name)
+
+    ninja_file.newline()
+
+    module_inputs = []
+    map_depends = []
+    for arch in self.archs:
+      swift_module_path = self._GetSwiftModulePath(config_name, spec, arch)
+      module_inputs.append(swift_module_path)
+      map_depends.append(swift_module_path)
+
+    if self._IsFramework(spec):
+      assert self.xcode_settings.IsModuleDefined(config_name)
+
+      # Copying Swift header to framework
+      swift_header = self.xcode_settings.GetSwiftHeaderPath(
+          config_name, self.GypPathToNinja)
+      module_inputs += self.WriteFrameworkHeaders(
+          ninja_file, [swift_header],
+          self.xcode_settings.GetBundlePublicHeadersFolderPath())
+
+      # Appending Swift info to the module map file in the /Modules folder
+      module_name = self.xcode_settings.GetProductModuleName(config_name)
+      module_map_path = self._GetModuleMapFilePath()
+      variables = {
+          'module_name': module_name,
+          'swift_header': os.path.basename(swift_header),
+          'map_file': QuoteShellArgument(module_map_path, self.flavor)
+      }
+      module_map_stamp = self.GypPathToUniqueOutput('swiftmodulemap.stamp')
+      self.ninja.build(module_map_stamp, 'swiftmodulemap', [swift_header],
+                       order_only=map_depends, variables=variables)
+      module_inputs.append(module_map_stamp)
+
+    # Resulting Swift actions stamp
+    module_stamp = self.GypPathToUniqueOutput('swift_module.stamp')
+    self.ninja.build(module_stamp, 'stamp', module_inputs)
+    self.target.module_stamp = module_stamp
+    ninja_file.newline()
+
+  def AppendSwiftLinkerOptions(self, ldflags, implicit_deps, config_name, spec,
+                               arch):
+    if not self.uses_swift:
+      return
+    if arch is None:
+      arch = self.archs[0]
+    module_path = self._GetSwiftModulePath(config_name, spec, arch)
+    ldflags += self.xcode_settings.GetSwiftLdflags(config_name, module_path)
+    implicit_deps.add(module_path)
+
+  def CopySwiftLibsToBundle(self, spec):
+    is_final = spec['type'] in ('executable', 'loadable_module')
+    # We should try to copy swift libs even if the target does not have
+    # swift files itself, because some of the dependent libs can have it.
+    if not gyp.xcode_emulation.IsSwiftSupported() or not is_final:
+      return None
+
+    if not self.target.binary:
+      return None
+
+    # Copying all needed Swift dylibs right into the bundle
+    app_frameworks_path = (
+        self.xcode_settings.GetBundleFrameworksFolderPath())
+    codesign_key = self.xcode_settings.GetCodeSignIdentityKey(
+        self.config_name) or ''
+    variables = {
+      'platform': self.xcode_settings.GetPlatform(self.config_name),
+      'dst_path': QuoteShellArgument(app_frameworks_path, self.flavor),
+      'codesign_key': codesign_key}
+    swift_libs_stamp = QuoteShellArgument(
+        self.GypPathToUniqueOutput('copyswiftlibs.stamp'), self.flavor)
+    self.ninja.build(swift_libs_stamp, 'copyswiftlibs', self.target.binary,
+                     variables=variables)
+    return swift_libs_stamp
+
   def WriteSources(self, ninja_file, config_name, config, sources, predepends,
                    precompiled_header, spec):
     """Write build rules to compile all of |sources|."""
     if self.toolset == 'host':
       self.ninja.variable('ar', '$ar_host')
       self.ninja.variable('cc', '$cc_host')
       self.ninja.variable('cxx', '$cxx_host')
       self.ninja.variable('ld', '$ld_host')
       self.ninja.variable('ldxx', '$ldxx_host')
       self.ninja.variable('nm', '$nm_host')
       self.ninja.variable('readelf', '$readelf_host')
 
     if self.flavor != 'mac' or len(self.archs) == 1:
       return self.WriteSourcesForArch(
           self.ninja, config_name, config, sources, predepends,
           precompiled_header, spec)
     else:
       return dict((arch, self.WriteSourcesForArch(
             self.arch_subninjas[arch], config_name, config, sources, predepends,
             precompiled_header, spec, arch=arch))
           for arch in self.archs)
 
   def WriteSourcesForArch(self, ninja_file, config_name, config, sources,
                           predepends, precompiled_header, spec, arch=None):
     """Write build rules to compile all of |sources|."""
 
     extra_defines = []
     if self.flavor == 'mac':
-      cflags = self.xcode_settings.GetCflags(config_name, arch=arch)
+      cflags = self.xcode_settings.GetCflags(config_name,
+          self.GypPathToNinjaWithToolchain, arch=arch)
       cflags_c = self.xcode_settings.GetCflagsC(config_name)
       cflags_cc = self.xcode_settings.GetCflagsCC(config_name)
       cflags_objc = ['$cflags_c'] + \
                     self.xcode_settings.GetCflagsObjC(config_name)
       cflags_objcc = ['$cflags_cc'] + \
                      self.xcode_settings.GetCflagsObjCC(config_name)
     elif self.flavor == 'win':
       asmflags = self.msvs_settings.GetAsmflags(config_name)
       cflags = self.msvs_settings.GetCflags(config_name)
       cflags_c = self.msvs_settings.GetCflagsC(config_name)
@@ skipping 72 matching lines @@
                            map(self.ExpandSpecial, cflags_cc))
     if self.flavor == 'mac':
       self.WriteVariableList(ninja_file, 'cflags_objc',
                              map(self.ExpandSpecial, cflags_objc))
       self.WriteVariableList(ninja_file, 'cflags_objcc',
                              map(self.ExpandSpecial, cflags_objcc))
     self.WriteVariableList(ninja_file, 'arflags',
                            map(self.ExpandSpecial, arflags))
     ninja_file.newline()
     outputs = []
+
+    if self.flavor == 'mac':
+      swift_outputs, swift_module = self.WriteSwiftSourcesForArch(
+          ninja_file, config_name, sources, predepends, spec, arch)
+      outputs += swift_outputs
+      predepends = swift_module or predepends
+
     has_rc_source = False
     for source in sources:
       filename, ext = os.path.splitext(source)
       ext = ext[1:]
       obj_ext = self.obj_ext
       if ext in ('cc', 'cpp', 'cxx'):
         command = 'cxx'
         self.uses_cpp = True
       elif ext == 'c' or (ext == 'S' and self.flavor != 'win'):
         command = 'cc'
@@ skipping 141 matching lines @@
     if arch is None and not self.is_mac_bundle:
       self.AppendPostbuildVariable(extra_bindings, spec, output, output)
 
     is_executable = spec['type'] == 'executable'
     # The ldflags config key is not used on mac or win. On those platforms
     # linker flags are set via xcode_settings and msvs_settings, respectively.
     env_ldflags = os.environ.get('LDFLAGS', '').split()
     if self.flavor == 'mac':
       ldflags = self.xcode_settings.GetLdflags(config_name,
           self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
-          self.GypPathToNinja, arch)
+          self.GypPathToNinjaWithToolchain, arch)
       ldflags = env_ldflags + ldflags
+      self.AppendSwiftLinkerOptions(
+          ldflags, implicit_deps, config_name, spec, arch)
     elif self.flavor == 'win':
       manifest_base_name = self.GypPathToUniqueOutput(
           self.ComputeOutputFileName(spec))
       ldflags, intermediate_manifest, manifest_files = \
           self.msvs_settings.GetLdflags(config_name, self.GypPathToNinja,
                                         self.ExpandSpecial, manifest_base_name,
                                         output, is_executable,
                                         self.toplevel_build)
       ldflags = env_ldflags + ldflags
       self.WriteVariableList(ninja_file, 'manifests', manifest_files)
@@ skipping 89 matching lines @@
 
     if len(solibs):
       extra_bindings.append(('solibs', gyp.common.EncodePOSIXShellList(solibs)))
 
     ninja_file.build(output, command + command_suffix, link_deps,
                      implicit=list(implicit_deps),
                      variables=extra_bindings)
     return linked_binary
 
   def WriteTarget(self, spec, config_name, config, link_deps, compile_deps):
+    self.WriteSwiftModule(self.ninja, config_name, spec)
     extra_link_deps = any(self.target_outputs.get(dep).Linkable()
                           for dep in spec.get('dependencies', [])
                           if dep in self.target_outputs)
     if spec['type'] == 'none' or (not link_deps and not extra_link_deps):
       # TODO(evan): don't call this function for 'none' target types, as
       # it doesn't do anything, and we fake out a 'binary' with a stamp file.
       self.target.binary = compile_deps
       self.target.type = 'none'
     elif spec['type'] == 'static_library':
       self.target.binary = self.ComputeOutput(spec)
@@ skipping 32 matching lines @@
           self.ninja.build(self.target.binary, 'alink', inputs,
                            # FIXME: test proving order_only=compile_deps isn't
                            # needed.
                            variables=variables)
     else:
       self.target.binary = self.WriteLink(spec, config_name, config, link_deps)
     return self.target.binary
 
   def WriteMacBundle(self, spec, mac_bundle_depends, is_empty):
     assert self.is_mac_bundle
+
+    swift_frameworks = self.CopySwiftLibsToBundle(spec)
+    if swift_frameworks:
+      mac_bundle_depends.append(swift_frameworks)
+
+    if self.target.module_stamp:
+      mac_bundle_depends.append(self.target.module_stamp)
+
     package_framework = spec['type'] in ('shared_library', 'loadable_module')
     output = self.ComputeMacBundleOutput()
     if is_empty:
       output += '.stamp'
     variables = []
     self.AppendPostbuildVariable(variables, spec, output, self.target.binary,
                                  is_command_start=not package_framework)
     if package_framework and not is_empty:
       variables.append(('version', self.xcode_settings.GetFrameworkVersion()))
       self.ninja.build(output, 'package_framework', mac_bundle_depends,
@@ skipping 602 matching lines @@
     master_ninja.variable('ldxx', CommandWithWrapper('LINK', wrappers, ldxx))
     master_ninja.variable('ar', GetEnvironFallback(['AR_target', 'AR'], ar))
     if flavor != 'mac':
       # Mac does not use readelf/nm for .TOC generation, so avoiding polluting
       # the master ninja with extra unused variables.
       master_ninja.variable(
           'nm', GetEnvironFallback(['NM_target', 'NM'], nm))
       master_ninja.variable(
           'readelf', GetEnvironFallback(['READELF_target', 'READELF'], readelf))
 
+  if flavor == 'mac' and gyp.xcode_emulation.IsSwiftSupported():
+    master_ninja.variable(
+        'swift', subprocess.check_output(['xcrun', '-f', 'swift']))
+
   if generator_supports_multiple_toolsets:
     if not cc_host:
       cc_host = cc
     if not cxx_host:
       cxx_host = cxx
 
     master_ninja.variable('ar_host', GetEnvironFallback(['AR_host'], ar_host))
     master_ninja.variable('nm_host', GetEnvironFallback(['NM_host'], nm_host))
     master_ninja.variable('readelf_host',
                           GetEnvironFallback(['READELF_host'], readelf_host))
@@ skipping 164 matching lines @@
       depfile='$out.d',
       deps=deps)
     master_ninja.rule(
       'objcxx',
       description='OBJCXX $out',
       command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_objcc '
                '$cflags_pch_objcc -c $in -o $out'),
       depfile='$out.d',
       deps=deps)
     master_ninja.rule(
+      'swift',
+      description='SWIFT $out_module',
+      command=('$swift -frontend -c $in $swift_compile_flags '
+               '-emit-module-path $out_module '
+               '-emit-objc-header-path $out_header '
+               '-num-threads $num_threads '
+               '$out_objects'))
+    master_ninja.rule(
+      'swift_perfile',
+      description='SWIFT $out_obj',
+      command=('$swift -frontend -c -primary-file $in $swift_compile_flags '
+               '-emit-module-path $out_module '
+               '-o $out_obj'))
+    master_ninja.rule(
+      'swift_merge',
+      description='SWIFT MERGE $out_module',
+      command=('$swift -frontend -emit-module $in $swift_merge_flags '
+               '-emit-objc-header-path $out_header '
+               '-o $out_module'))
+    master_ninja.rule(
+      'copyswiftlibs',
+      description='COPY SWIFT LIBS $out',
+      command=('./gyp-mac-tool copy-swift-libs $in $platform $dst_path '
+               '"$codesign_key" $out'))
+    master_ninja.rule(
+      'modulemap',
+      description='MODULE MAP $map_file',
+      command=('./gyp-mac-tool build-module-map-file '
+               '$module_name $umbrella_header $map_file $out'))
+    master_ninja.rule(
+      'swiftmodulemap',
+      description='SWIFT MODULE MAP $map_file',
+      command=('./gyp-mac-tool append-swift-to-module-map-file '
+               '$module_name $swift_header $map_file $out'))
+    master_ninja.rule(
       'alink',
       description='LIBTOOL-STATIC $out, POSTBUILDS',
       command='rm -f $out && '
               './gyp-mac-tool filter-libtool libtool $libtool_flags '
               '-static -o $out $in'
               '$postbuilds')
     master_ninja.rule(
       'lipo',
       description='LIPO $out, POSTBUILDS',
       command='rm -f $out && lipo -create $in -output $out$postbuilds')
@@ skipping 263 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)