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 216 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': module_map_path }
+    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 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)
+
+    self.uses_swift = True
+
+    if not arch:
+      arch = self.archs[0]
+
+    # Writing compile flags
+    swift_compile_flags = self.xcode_settings.GetSwiftCompileFlags(
+        config_name, self.GypPathToNinja, arch)
+    self.WriteVariableList(ninja_file, 'swift_compile_flags',
+                           map(self.ExpandSpecial, swift_compile_flags))
+    ninja_file.newline()
+
+    # 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)
+
+      compile_input = [source]
+      for another_source in swift_sources:
+        if source != another_source:
+          compile_input.append(another_source)
+
+      variables = {'out_obj': obj_path, 'out_module': src_module_path}
+      ninja_file.build([obj_path, src_module_path], 'swift', compile_input,
+                       variables=variables,
+                       order_only=predepends)
+
+      link_deps.append(obj_path)
+      partial_modules.append(src_module_path)
+
+    ninja_file.newline()
+
+    # Writing Swift merge flags
+    swift_merge_flags = self.xcode_settings.GetSwiftMergeFlags(
+        config_name, self.GypPathToNinja, arch)
+    self.WriteVariableList(ninja_file, 'swift_merge_flags',
+                           map(self.ExpandSpecial, swift_merge_flags))
+    ninja_file.newline()
+
+
+    # Writing header for first arch without arch extension,
+    # for it to be used by Objc sources
+    header_arch = None if arch == self.archs[0] else arch
+    header_path = self.xcode_settings.GetSwiftHeaderPath(
+        config_name, self.GypPathToNinja, header_arch)
+    module_path = self._GetSwiftModulePath(config_name, spec, arch)
+    variables = {'out_module': module_path, 'out_header': header_path}
+    ninja_file.build([module_path, header_path], 'swiftmerge',
+                     partial_modules, variables=variables)
+    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': module_map_path }
+      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')
+    if not gyp.xcode_emulation.IsSwiftSupported() or not is_final:
+      return None
+
+    # Copying all needed Swift dylibs right into the bundle
+    app_frameworks_path = (
+        self.xcode_settings.GetBundleFrameworksFolderPath())
+    swift_libs_path = self.xcode_settings.GetSwiftLibsPath(self.config_name)
+    variables = {'swift_libs_path': swift_libs_path}
+    self.ninja.build(app_frameworks_path, 'copyswiftlibs', self.target.binary,
+                     variables=variables)
+    return app_frameworks_path
+
   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')
@@ skipping 101 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 143 matching lines @@
 
     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)
       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_obj',
+      command=('$swift -frontend -c -primary-file $in $swift_compile_flags '
+               '-emit-module-path $out_module '
+               '-o $out_obj'))
+    master_ninja.rule(
+      'swiftmerge',
+      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 $swift_libs_path $out $in'))
+    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)