Support for Swift language and Clang modules for ninja generator.

pylib/gyp/xcode_emulation.py

 # Copyright (c) 2012 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.
 
 """
 This module contains classes that help to emulate xcodebuild behavior on top of
 other build systems, such as make and ninja.
 """
 
 import copy
@@ skipping 284 matching lines @@
     Chromium.app/Contents/Resources. Only valid for bundles."""
     assert self._IsBundle()
     if self.isIOS:
       return self.GetBundleContentsFolderPath()
     return os.path.join(self.GetBundleContentsFolderPath(), 'Resources')
 
   def GetBundlePlistPath(self):
     """Returns the qualified path to the bundle's plist file. E.g.
     Chromium.app/Contents/Info.plist. Only valid for bundles."""
     assert self._IsBundle()
-    if self.spec['type'] in ('executable', 'loadable_module'):
+    if self.isIOS or self.spec['type'] in ('executable', 'loadable_module'):
       return os.path.join(self.GetBundleContentsFolderPath(), 'Info.plist')
     else:
       return os.path.join(self.GetBundleContentsFolderPath(),
                           'Resources', 'Info.plist')
 
   def GetProductType(self):
     """Returns the PRODUCT_TYPE of this target."""
     if self._IsIosAppExtension():
       assert self._IsBundle(), ('ios_app_extension flag requires mac_bundle '
           '(target %s)' % self.spec['target_name'])
@@ skipping 157 matching lines @@
     self.configname = configname
     cflags = []
 
     sdk_root = self._SdkPath()
     if 'SDKROOT' in self._Settings() and sdk_root:
       cflags.append('-isysroot %s' % sdk_root)
 
     if self._Test('CLANG_WARN_CONSTANT_CONVERSION', 'YES', default='NO'):
       cflags.append('-Wconstant-conversion')
 
+    if self._AreModulesEnabled():
+      cflags.append('-fmodules')
+      self._Appendf(cflags,
+                    'CLANG_MODULE_CACHE_PATH',
+                    '-fmodules-cache-path=\'%s\'',
+                    self._GetDefaultClangModuleCachePath())
+      if self._IsModuleDefined():
+        cflags.append('-Xclang -fmodule-implementation-of -Xclang ' +

[Nico, 2015/06/10 01:09:18]

-Xclang flags are considered clang-internal flags and aren't stable. Isn't there
some driver-level flag for this? If not, should there be one? (Does xcode do
this?)

[efimovmichael, 2015/07/22 14:46:05]

I tried to copy all flags, which Xcode uses itself(6.3.1 version).
Some of them are probably internal to Xcode's version of clang and don't have
any documentation.
But I tested all flags used in this patch on both versions of clang: Xcode's
version and Chromium version(last one) and everything looks fine.
As for this flag, I found a reference to it's name in some public correspondence
here:
http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20140721/111034.html
I think, this flag is an alternative to the -fmodule-name flag from the official
clang documentation. 
Both of them deny importing module within Objective-C sources of this module(and
they probably do something else). As I see it, Apple's clang team were unhappy
with implementation of '-fmodule-name' and added their own. I tried using both
of them, they work on both Xcode's clang and Chromium's clang).
However, these flags produce different errors(when I'm trying to write @import
to my module inside my module), so they actually trigger different logic inside
clang.
In short, we can replace '-fmodule-implementation-of' with '-fmodule-name' but
we'll move away from Xcode's original compilation process.

+                      self._GetProductModuleName())
+      cflags.append('-F.')
+
     if self._Test('GCC_CHAR_IS_UNSIGNED_CHAR', 'YES', default='NO'):
       cflags.append('-funsigned-char')
 
     if self._Test('GCC_CW_ASM_SYNTAX', 'YES', default='YES'):
       cflags.append('-fasm-blocks')
 
     if 'GCC_DYNAMIC_NO_PIC' in self._Settings():
       if self._Settings()['GCC_DYNAMIC_NO_PIC'] == 'YES':
         cflags.append('-mdynamic-no-pic')
     else:
@@ skipping 75 matching lines @@
 
     cflags += self._Settings().get('WARNING_CFLAGS', [])
 
     if sdk_root:
       framework_root = sdk_root
     else:
       framework_root = ''
     config = self.spec['configurations'][self.configname]
     framework_dirs = config.get('mac_framework_dirs', [])
     for directory in framework_dirs:
-      cflags.append('-F' + directory.replace('$(SDKROOT)', framework_root))
+      cflags.append('-F' + os.path.normpath(
+          directory.replace('$(SDKROOT)', framework_root)))
 
     self.configname = None
     return cflags
 
+  def AreModulesEnabled(self, configname):
+    self.configname = configname
+    res = self._AreModulesEnabled()
+    self.configname = None
+    return res
+
+  def _AreModulesEnabled(self):
+    res = self._Test('CLANG_ENABLE_MODULES', 'YES', default='NO')
+    return res
+
+  def IsModuleDefined(self, configname):
+    self.configname = configname
+    res = self._IsModuleDefined()
+    self.configname = None
+    return res
+
+  def _IsModuleDefined(self):
+    res = self._Test('DEFINES_MODULE', 'YES', default='NO')
+    return res
+
+  def GetProductModuleName(self, configname):
+    self.configname = configname
+    swift_module_name = self._GetProductModuleName()
+    self.configname = None
+    return swift_module_name
+
+  def _GetProductModuleName(self):
+    default_module_name = self.spec['target_name'].replace('-', '_')
+    return self._Settings().get(
+        'PRODUCT_MODULE_NAME', default_module_name)
+
+  def GetSwiftHeaderPath(self, configname, gyp_path_to_build_path, arch=None):
+    self.configname = configname
+    swift_header_path = self._GetSwiftHeaderPath(gyp_path_to_build_path, arch)
+    self.configname = None
+    return swift_header_path
+
+  def _GetSwiftHeaderPath(self, gyp_path_to_build_path, arch):
+    swift_header_name = self._Settings().get(
+        'SWIFT_OBJC_INTERFACE_HEADER_NAME',
+        self._GetProductModuleName() + '-Swift.h')
+    # SWIFT_OBJC_INTERFACE_HEADER_NAME must just a file name without path
+    assert(not os.path.dirname(swift_header_name))
+    if arch:
+      swift_header_name = re.sub(r'\.h$', '.' + arch + '.h', swift_header_name)
+    swift_header_path = os.path.join('$!INTERMEDIATE_DIR', swift_header_name)
+    swift_header_path = gyp_path_to_build_path(swift_header_path)
+    return swift_header_path
+
+  def GetSwiftLibsPath(self, configname):
+    developer_dir = subprocess.check_output(['xcode-select', '-p']).strip()
+    base_toolchain_path = os.path.join(
+        developer_dir, 'Toolchains/XcodeDefault.xctoolchain')
+    base_toolchain_path = os.path.normpath(base_toolchain_path)
+
+    sdk_path_basename = os.path.basename(self._SdkPath(configname))
+    if sdk_path_basename.lower().startswith('iphonesimulator'):
+      platform = 'iphonesimulator'
+    elif sdk_path_basename.lower().startswith('iphoneos'):
+      platform = 'iphoneos'
+    elif sdk_path_basename.lower().startswith('macosx'):
+      platform = 'macosx'
+    else:
+      assert(False)
+
+    swift_toolchain_path = os.path.join(
+        base_toolchain_path, 'usr/lib/swift', platform)
+    assert(os.path.exists(swift_toolchain_path))
+    return swift_toolchain_path
+
+  def _GetDefaultClangModuleCachePath(self):
+    return os.path.join(os.path.expanduser('~'),
+                        'Library/Developer/Xcode/DerivedData/ModuleCache')
+
+  def _GetSwiftCommonFlags(self, gyp_path_to_build_path, arch):
+    assert(arch)
+
+    swift_flags = []
+    swift_flags.append('-enable-objc-interop')
+
+    if self._IsModuleDefined():
+      swift_flags.append('-import-underlying-module')
+
+    self._Appendf(swift_flags, 'IPHONEOS_DEPLOYMENT_TARGET',
+                  '-target ' + arch + '-apple-ios%s')
+    self._Appendf(swift_flags, 'MACOSX_DEPLOYMENT_TARGET',
+                  '-target ' + arch + '-apple-macosx%s')
+
+    swift_flags.append('-sdk ' + self._SdkPath())
+
+    swift_flags.append('-g')
+
+    swift_flags.append('-parse-as-library')
+
+    self._Appendf(swift_flags,
+                  'CLANG_MODULE_CACHE_PATH',
+                  '-module-cache-path \'%s\'',
+                  self._GetDefaultClangModuleCachePath())
+
+    swift_flags.append('-module-name ' + self._GetProductModuleName())
+
+    if self._Settings().get('SWIFT_OBJC_BRIDGING_HEADER'):
+      import_header = self._Settings().get('SWIFT_OBJC_BRIDGING_HEADER')
+      import_header = gyp_path_to_build_path(import_header)
+      swift_flags.append('-import-objc-header \'' + import_header + '\'')
+
+    config = self.spec['configurations'][self.configname]
+    framework_dirs = config.get('mac_framework_dirs', [])
+    sdk_root = self._SdkPath()
+    for directory in framework_dirs:
+      swift_flags.append('-F ' + os.path.normpath(
+          directory.replace('$(SDKROOT)', sdk_root)))
+
+    swift_flags.append('-F .')
+    swift_flags.append('-I .')
+
+    return swift_flags
+
+  def GetBundleFrameworksFolderPath(self):
+    return os.path.join(self.GetBundleContentsFolderPath(), 'Frameworks')
+
+  def GetBundlePublicHeadersFolderPath(self):
+    return os.path.join(self.GetBundleContentsFolderPath(), 'Headers')
+
+  def GetBundlePrivateHeadersFolderPath(self):
+    return os.path.join(self.GetBundleContentsFolderPath(), 'PrivateHeaders')
+
+  def GetBundleModulesFolderPath(self):
+    return os.path.join(self.GetBundleContentsFolderPath(), 'Modules')
+
+  def GetSwiftCompileFlags(self, configname, gyp_path_to_build_path, arch):
+    self.configname = configname
+
+    swift_flags = self._GetSwiftCommonFlags(gyp_path_to_build_path, arch)
+
+    self._Appendf(swift_flags, 'SWIFT_OPTIMIZATION_LEVEL', '%s', '-O')
+
+    self.configname = None
+    return swift_flags
+
+  def GetSwiftMergeFlags(self, configname, gyp_path_to_build_path, arch):
+    self.configname = configname
+
+    swift_flags = self._GetSwiftCommonFlags(gyp_path_to_build_path, arch)
+
+    self.configname = None
+    return swift_flags
+
+  def GetSwiftLdflags(self, configname, arch_module_path):
+    ldflags = []
+    ldflags.append('-Xlinker -add_ast_path -Xlinker ' + arch_module_path)
+    ldflags.append('-L' + self.GetSwiftLibsPath(configname))
+    return ldflags
+
   def GetCflagsC(self, configname):
     """Returns flags that need to be added to .c, and .m compilations."""
     self.configname = configname
     cflags_c = []
     if self._Settings().get('GCC_C_LANGUAGE_STANDARD', '') == 'ansi':
       cflags_c.append('-ansi')
     else:
       self._Appendf(cflags_c, 'GCC_C_LANGUAGE_STANDARD', '-std=%s')
     cflags_c += self._Settings().get('OTHER_CFLAGS', [])
     self.configname = None
@@ skipping 202 matching lines @@
       ldflags.append('-isysroot ' + self._SdkPath())
 
     for library_path in self._Settings().get('LIBRARY_SEARCH_PATHS', []):
       ldflags.append('-L' + gyp_to_build_path(library_path))
 
     if 'ORDER_FILE' in self._Settings():
       ldflags.append('-Wl,-order_file ' +
                      '-Wl,' + gyp_to_build_path(
                                   self._Settings()['ORDER_FILE']))
 
+    if 'BUNDLE_LOADER' in self._Settings():
+      bundle_loader_path = gyp_to_build_path(self._Settings()['BUNDLE_LOADER'])
+      ldflags.append('-bundle_loader ' + bundle_loader_path)
+
     if arch is not None:
       archs = [arch]
     else:
       assert self.configname
       archs = self.GetActiveArchs(self.configname)
     if len(archs) != 1:
       # TODO: Supporting fat binaries will be annoying.
       self._WarnUnimplemented('ARCHS')
       archs = ['i386']
     ldflags.append('-arch ' + archs[0])
 
     # Xcode adds the product directory by default.
     ldflags.append('-L' + product_dir)
 
     install_name = self.GetInstallName()
     if install_name and self.spec['type'] != 'loadable_module':
       ldflags.append('-install_name ' + install_name.replace(' ', r'\ '))
 
     for rpath in self._Settings().get('LD_RUNPATH_SEARCH_PATHS', []):
-      ldflags.append('-Wl,-rpath,' + rpath)
+      ldflags.append('-Xlinker -rpath -Xlinker ' + rpath)
 
     sdk_root = self._SdkPath()
     if not sdk_root:
       sdk_root = ''
     config = self.spec['configurations'][self.configname]
     framework_dirs = config.get('mac_framework_dirs', [])
     for directory in framework_dirs:
-      ldflags.append('-F' + directory.replace('$(SDKROOT)', sdk_root))
+      ldflags.append('-F' + os.path.normpath(
+          directory.replace('$(SDKROOT)', sdk_root)))
+
+    ldflags.append('-F.')
 
     is_extension = self._IsIosAppExtension() or self._IsIosWatchKitExtension()
     if sdk_root and is_extension:
       # Adds the link flags for extensions. These flags are common for all
       # extensions and provide loader and main function.
       # These flags reflect the compilation options used by xcode to compile
       # extensions.
       ldflags.append('-lpkstart')
       ldflags.append(sdk_root +
           '/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit')
@@ skipping 562 matching lines @@
         'INFOPLIST_PREPROCESSOR_DEFINITIONS', default=''))
   else:
     defines = []
 
   dest_plist = os.path.join(product_dir, xcode_settings.GetBundlePlistPath())
   extra_env = xcode_settings.GetPerTargetSettings()
 
   return info_plist, dest_plist, defines, extra_env
 
 
+def IsSwiftSupported():
+  xcode_version, _ = XcodeVersion()
+  return xcode_version >= '0600'
+
+
 def _GetXcodeEnv(xcode_settings, built_products_dir, srcroot, configuration,
                 additional_settings=None):
   """Return the environment variables that Xcode would set. See
   http://developer.apple.com/library/mac/#documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html#//apple_ref/doc/uid/TP40003931-CH3-SW153
   for a full list.
 
   Args:
       xcode_settings: An XcodeSettings object. If this is None, this function
           returns an empty dict.
       built_products_dir: Absolute path to the built products dir.
@@ skipping 175 matching lines @@
       if toolset == 'target':
         iphoneos_config_dict['xcode_settings']['SDKROOT'] = 'iphoneos'
   return targets
 
 def CloneConfigurationForDeviceAndEmulator(target_dicts):
   """If |target_dicts| contains any iOS targets, automatically create -iphoneos
   targets for iOS device builds."""
   if _HasIOSTarget(target_dicts):
     return _AddIOSDeviceConfigurations(target_dicts)
   return target_dicts