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 141 matching lines @@
     if 'IPHONEOS_DEPLOYMENT_TARGET' in self._Settings():
       # TODO: Implement this better?
       sdk_path_basename = os.path.basename(self._SdkPath())
       if sdk_path_basename.lower().startswith('iphonesimulator'):
         self._Appendf(lst, 'IPHONEOS_DEPLOYMENT_TARGET',
                       '-mios-simulator-version-min=%s')
       else:
         self._Appendf(lst, 'IPHONEOS_DEPLOYMENT_TARGET',
                       '-miphoneos-version-min=%s')
 
-  def GetCflags(self, configname, arch=None):
+  def GetCflags(self, configname, gyp_to_build_path, arch=None):
     """Returns flags that need to be added to .c, .cc, .m, and .mm
     compilations."""
     # This functions (and the similar ones below) do not offer complete
     # emulation of all xcode_settings keys. They're implemented on demand.
 
     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')
+      module_cache_path = self._Settings().get(
+          'CLANG_MODULE_CACHE_PATH', self._GetDefaultClangModuleCachePath())
+      if arch:
+        module_cache_path = os.path.join(module_cache_path, arch)
+      cflags.append('-fmodules-cache-path=\'%s\'' % module_cache_path)
+      if self._IsModuleDefined():
+        cflags.append('-Xclang -fmodule-implementation-of -Xclang ' +
+                      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' + gyp_to_build_path(directory))
 
     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 IsSwiftWMOEnabled(self, configname):
+    self.configname = configname
+    res = self._IsSwiftWMOEnabled()
+    self.configname = None
+    return res
+
+  def _IsSwiftWMOEnabled(self):
+    return self._Test('SWIFT_OPTIMIZATION_LEVEL', '-Owholemodule', default='-O')
+
+  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 _GetCommonLibsPath(self):
+    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)
+
+    libs_path = os.path.join(base_toolchain_path, 'usr', 'lib')
+    assert os.path.exists(libs_path)
+    return libs_path
+
+  def GetPlatform(self, configname):
+    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, 'Unexpected platform'
+
+    return platform
+
+  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' + gyp_path_to_build_path(directory))
+
+    swift_flags.append('-F.')
+
+    swift_flags.append('-I.')
+    for i in config.get('include_dirs', []):
+        swift_flags.append('-I' + gyp_path_to_build_path(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)
+
+    if self._IsSwiftWMOEnabled():
+      swift_flags.append('-O')
+    else:
+      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 = []
+    platform = self.GetPlatform(configname)
+    libs_path = self._GetCommonLibsPath()
+    if self.isIOS:
+      # Some crazy hack by Xcode for iOS7 Swift support
+      arclib_path = os.path.join(
+          libs_path, 'arc', 'libarclite_' + platform + '.a')
+      assert os.path.isfile(arclib_path)
+      ldflags.append('-Xlinker -force_load -Xlinker ' + arclib_path)
+
+    swift_libs_path = os.path.join(libs_path, 'swift', platform)
+    assert os.path.isdir(swift_libs_path)
+    ldflags.append('-Xlinker -add_ast_path -Xlinker ' + arch_module_path)
+    ldflags.append('-L' + swift_libs_path)
+    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' + gyp_to_build_path(directory))
+
+    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')
       if XcodeVersion() < '0900':
         ldflags.append(sdk_root +
@@ skipping 144 matching lines @@
       print 'Warning: Some codesign keys not implemented, ignoring: %s' % (
           ', '.join(sorted(unimpl)))
 
     return ['%s code-sign-bundle "%s" "%s" "%s" "%s"' % (
         os.path.join('${TARGET_BUILD_DIR}', 'gyp-mac-tool'), key,
         settings.get('CODE_SIGN_RESOURCE_RULES_PATH', ''),
         settings.get('CODE_SIGN_ENTITLEMENTS', ''),
         settings.get('PROVISIONING_PROFILE', ''))
     ]
 
+  def GetCodeSignIdentityKey(self, configname):
+    if not self.isIOS:
+      return None
+
+    settings = self.xcode_settings[configname]
+    return self._GetIOSCodeSignIdentityKey(settings)
+
   def _GetIOSCodeSignIdentityKey(self, settings):
     identity = settings.get('CODE_SIGN_IDENTITY')
     if not identity:
       return None
     if identity not in XcodeSettings._codesigning_key_cache:
       output = subprocess.check_output(
           ['security', 'find-identity', '-p', 'codesigning', '-v'])
       for line in output.splitlines():
         if identity in line:
           fingerprint = line.split()[1]
@@ skipping 399 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()
+  # Xcode actually supports Swift since 0600,
+  # but here is least version supported by this script.
+  # You should not try compiling Swift with Xcode less than 6.3 at all.
+  return xcode_version >= '0630'
+
+
 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