Xcode has some issues with generated sources/headers and compiling sources. ...

pylib/gyp/generator/xcode.py

 #!/usr/bin/python
 
 # Copyright (c) 2009 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 filecmp
 import gyp.common
 import gyp.xcodeproj_file
 import errno
@@ skipping 56 matching lines @@
   'mac_bundle',
   'mac_bundle_resources',
   'xcode_create_dependents_test_runner',
 ]
 
 # We want to let any rules apply to files that are resources also.
 generator_extra_sources_for_rules = [
   'mac_bundle_resources',
 ]
 
+
+def CreateXCConfigurationList(configuration_names):
+  xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
+  for configuration_name in configuration_names:
+    xcbc = gyp.xcodeproj_file.XCBuildConfiguration({
+        'name': configuration_name})
+    xccl.AppendProperty('buildConfigurations', xcbc)
+  xccl.SetProperty('defaultConfigurationName', configuration_names[0])
+  return xccl
+
+
 class XcodeProject(object):
   def __init__(self, gyp_path, path, build_file_dict):
     self.gyp_path = gyp_path
     self.path = path
     self.project = gyp.xcodeproj_file.PBXProject(path=path)
     projectDirPath = gyp.common.RelativePath(
                          os.path.dirname(os.path.abspath(self.gyp_path)),
                          os.path.dirname(path) or '.')
     self.project.SetProperty('projectDirPath', projectDirPath)
     self.project_file = \
@@ skipping 22 matching lines @@
       xcbcs = xccl.GetProperty('buildConfigurations')
       for xcbc in xcbcs:
         name = xcbc.GetProperty('name')
         if name not in configurations:
           configurations.append(name)
 
     # Replace the XCConfigurationList attached to the PBXProject object with
     # a new one specifying all of the configuration names used by the various
     # targets.
     try:
-      xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
-      for configuration in configurations:
-        xcbc = gyp.xcodeproj_file.XCBuildConfiguration({'name': configuration})
-        xccl.AppendProperty('buildConfigurations', xcbc)
-      xccl.SetProperty('defaultConfigurationName', configurations[0])
+      xccl = CreateXCConfigurationList(configurations)
       self.project.SetProperty('buildConfigurationList', xccl)
     except:
       import sys
       sys.stderr.write("Problem with gyp file %s\n" % self.gyp_path)
       raise
 
     # The need for this setting is explained above where _intermediate_var is
     # defined.  The comments below about wanting to avoid project-wide build
     # settings apply here too, but this needs to be set on a project-wide basis
     # so that files relative to the _intermediate_var setting can be displayed
@@ skipping 19 matching lines @@
     # tree view for UI display.
     for xck, xcv in self.build_file_dict.get('xcode_settings', {}).iteritems():
       xccl.SetBuildSetting(xck, xcv)
 
     # Sort the targets based on how they appeared in the input.
     # TODO(mark): Like a lot of other things here, this assumes internal
     # knowledge of PBXProject - in this case, of its "targets" property.
 
     # ordinary_targets are ordinary targets that are already in the project
     # file. run_test_targets are the targets that run unittests and should be
-    # used for the Run All Tests target.
+    # used for the Run All Tests target.  support_targets are the action/rule
+    # targets used by GYP file targets, just kept for the assert check.
     ordinary_targets = []
     run_test_targets = []
+    support_targets = []
 
     # targets is full list of targets in the project.
     targets = []
 
     # does the it define it's own "all"?
     has_custom_all = False
 
     # targets_for_all is the list of ordinary_targets that should be listed
     # in this project's "All" target.  It includes each non_runtest_target
     # that does not have suppress_wildcard set.
     targets_for_all = []
 
     for target in self.build_file_dict['targets']:
       target_name = target['target_name']
       toolset = target['toolset']
       qualified_target = gyp.common.QualifiedTarget(self.gyp_path, target_name,
                                                     toolset)
       xcode_target = xcode_targets[qualified_target]
       # Make sure that the target being added to the sorted list is already in
       # the unsorted list.
       assert xcode_target in self.project._properties['targets']
       targets.append(xcode_target)
       ordinary_targets.append(xcode_target)
+      if xcode_target.support_target:
+        support_targets.append(xcode_target.support_target)
+        targets.append(xcode_target.support_target)
 
       if not int(target.get('suppress_wildcard', False)):
         targets_for_all.append(xcode_target)
 
       if target_name.lower() == 'all':
         has_custom_all = True;
 
       # If this target has a 'run_as' attribute, or is a test, add its
       # target to the targets, and (if it's a test) add it the to the
       # test targets.
       is_test = int(target.get('test', 0))
       if target.get('run_as') or is_test:
         # Make a target to run something.  It should have one
         # dependency, the parent xcode target.
+        xccl = CreateXCConfigurationList(configurations)
         run_target = gyp.xcodeproj_file.PBXAggregateTarget({
-              'name':        'Run ' + target_name,
-              'productName': xcode_target.GetProperty('productName'),
+              'name':                   'Run ' + target_name,
+              'productName':            xcode_target.GetProperty('productName'),
+              'buildConfigurationList': xccl,
             },
             parent=self.project)
         run_target.AddDependency(xcode_target)
 
         # The test runner target has a build phase that executes the
         # test, if this has the 'test' attribute.  If the 'run_as' tag
         # doesn't exist (meaning that this must be a test), then we
         # define a default test command line.
         command = target.get('run_as', {
           'action': ['${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}']
@@ skipping 40 matching lines @@
 
         # Add the run target to the project file.
         targets.append(run_target)
         if is_test:
           run_test_targets.append(run_target)
           xcode_target.test_runner = run_target
 
 
     # Make sure that the list of targets being replaced is the same length as
     # the one replacing it, but allow for the added test runner targets.
-    assert len(self.project._properties['targets']) == len(ordinary_targets)
+    assert len(self.project._properties['targets']) == \
+      len(ordinary_targets) + len(support_targets)
 
     self.project._properties['targets'] = targets
 
     # Get rid of unnecessary levels of depth in groups like the Source group.
     self.project.RootGroupsTakeOverOnlyChildren(True)
 
     # Sort the groups nicely.  Do this after sorting the targets, because the
     # Products group is sorted based on the order of the targets.
     self.project.SortGroups()
 
     # Create an "All" target if there's more than one target in this project
     # file and the project didn't define its own "All" target.  Put a generated
     # "All" target first so that people opening up the project for the first
     # time will build everything by default.
     if len(targets_for_all) > 1 and not has_custom_all:
-      xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
-      for configuration in configurations:
-        xcbc = gyp.xcodeproj_file.XCBuildConfiguration({'name': configuration})
-        xccl.AppendProperty('buildConfigurations', xcbc)
-      xccl.SetProperty('defaultConfigurationName', configurations[0])
-
+      xccl = CreateXCConfigurationList(configurations)
       all_target = gyp.xcodeproj_file.PBXAggregateTarget(
           {
             'buildConfigurationList': xccl,
             'name':                   'All',
           },
           parent=self.project)
 
       for target in targets_for_all:
         all_target.AddDependency(target)
 
       # TODO(mark): This is evil because it relies on internal knowledge of
       # PBXProject._properties.  It's important to get the "All" target first,
       # though.
       self.project._properties['targets'].insert(0, all_target)
 
     # The same, but for run_test_targets.
     if len(run_test_targets) > 1:
-      xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
-      for configuration in configurations:
-        xcbc = gyp.xcodeproj_file.XCBuildConfiguration({'name': configuration})
-        xccl.AppendProperty('buildConfigurations', xcbc)
-      xccl.SetProperty('defaultConfigurationName', configurations[0])
+      xccl = CreateXCConfigurationList(configurations)
       run_all_tests_target = gyp.xcodeproj_file.PBXAggregateTarget(
           {
             'buildConfigurationList': xccl,
             'name':                   'Run All Tests',
           },
           parent=self.project)
       for run_test_target in run_test_targets:
         run_all_tests_target.AddDependency(run_test_target)
 
       # Insert after the "All" target, which must exist if there is more than
@@ skipping 254 matching lines @@
           qualified_target)
     configuration_names = [spec['default_configuration']]
     for configuration_name in sorted(spec['configurations'].keys()):
       if configuration_name not in configuration_names:
         configuration_names.append(configuration_name)
     xcp = xcode_projects[build_file]
     pbxp = xcp.project
 
     # Set up the configurations for the target according to the list of names
     # supplied.
-    xccl = gyp.xcodeproj_file.XCConfigurationList({'buildConfigurations': []})
-    for configuration_name in configuration_names:
-      xcbc = gyp.xcodeproj_file.XCBuildConfiguration({
-          'name': configuration_name})
-      xccl.AppendProperty('buildConfigurations', xcbc)
-    xccl.SetProperty('defaultConfigurationName', configuration_names[0])
+    xccl = CreateXCConfigurationList(configuration_names)
 
     # Create an XCTarget subclass object for the target.  We use the type
     # with "+bundle" appended if the target has "mac_bundle" set.
     _types = {
       'executable':             'com.apple.product-type.tool',
       'loadable_module':        'com.apple.product-type.library.dynamic',
       'shared_library':         'com.apple.product-type.library.dynamic',
       'static_library':         'com.apple.product-type.library.static',
       'executable+bundle':      'com.apple.product-type.application',
       'loadable_module+bundle': 'com.apple.product-type.bundle',
@@ skipping 14 matching lines @@
       xctarget_type = gyp.xcodeproj_file.PBXNativeTarget
       try:
         target_properties['productType'] = _types[type_bundle_key]
       except KeyError, e:
         gyp.common.ExceptionAppend(e, "-- unknown product type while "
                                    "writing target %s" % target_name)
         raise
     else:
       xctarget_type = gyp.xcodeproj_file.PBXAggregateTarget
 
-    if 'product_name' in spec:
-      target_properties['productName'] = spec['product_name']
+    target_product_name = spec.get('product_name', None)
+    if target_product_name:
+      target_properties['productName'] = target_product_name
 
     xct = xctarget_type(target_properties, parent=pbxp,
                         force_extension=spec.get('product_extension', None))
     pbxp.AppendProperty('targets', xct)
     xcode_targets[qualified_target] = xct
     xcode_target_to_target_dict[xct] = spec
 
     # Xcode does not have a distinct type for loadable_modules that are pure
     # BSD targets (ie-unbundled). It uses the same setup as a shared_library
     # but the mach-o type is explictly set in the settings.  So before we do
     # anything else, for this one case, we stuff in that one setting.  This
     # would allow the other data in the spec to change it if need be.
     if type == 'loadable_module' and not is_bundle:
       xccl.SetBuildSetting('MACH_O_TYPE', 'mh_bundle')
 
+    spec_actions = spec.get('actions', [])
+    spec_rules = spec.get('rules', [])
+
+    # Xcode has some "issues" with checking dependencies for the "Compile
+    # sources" step with any source files/headers generated by actions/rules.
+    # To work around this, if a target is building anything directly (not
+    # type "none"), then a second target as used to run the GYP actions/rules
+    # and is made a dependency of this target.  This way the work is done
+    # before the dependency checks for what should be recompiled.
+    support_xct = None
+    if type != 'none' and (spec_actions or spec_rules):
+      support_xccl = CreateXCConfigurationList(configuration_names);
+      support_target_properties = {
+        'buildConfigurationList': support_xccl,
+        'name':                   target_name + ' Support',
+      }
+      if target_product_name:
+        support_target_properties['productName'] = \
+            target_product_name + ' Support'
+      support_xct = \
+          gyp.xcodeproj_file.PBXAggregateTarget(support_target_properties,
+                                                parent=pbxp)
+      pbxp.AppendProperty('targets', support_xct)
+      xct.AddDependency(support_xct)
+    # Hang the support target off the main target so it can be tested/found
+    # by the generator during Finalize.
+    xct.support_target = support_xct
+
     prebuild_index = 0
 
     # Add custom shell script phases for "actions" sections.
-    for action in spec.get('actions', []):
+    for action in spec_actions:
       # There's no need to write anything into the script to ensure that the
       # output directories already exist, because Xcode will look at the
       # declared outputs and automatically ensure that they exist for us.
 
       # Do we have a message to print when this action runs?
       message = action.get('message')
       if message:
         message = 'echo note: ' + gyp.common.EncodePOSIXShellArgument(message)
       else:
         message = ''
@@ skipping 15 matching lines @@
       # exits signalling an error.
       script += 'exec ' + action_string_sh + '\nexit 1\n'
       ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
             'inputPaths': action['inputs'],
             'name': 'Action "' + action['action_name'] + '"',
             'outputPaths': action['outputs'],
             'shellScript': script,
             'showEnvVarsInLog': 0,
           })
 
-      # TODO(mark): this assumes too much knowledge of the internals of
-      # xcodeproj_file; some of these smarts should move into xcodeproj_file
-      # itself.
-      xct._properties['buildPhases'].insert(prebuild_index, ssbp)
-      prebuild_index = prebuild_index + 1
+      if support_xct:
+        support_xct.AppendProperty('buildPhases', ssbp)
+      else:
+        # TODO(mark): this assumes too much knowledge of the internals of
+        # xcodeproj_file; some of these smarts should move into xcodeproj_file
+        # itself.
+        xct._properties['buildPhases'].insert(prebuild_index, ssbp)
+        prebuild_index = prebuild_index + 1
 
       # TODO(mark): Should verify that at most one of these is specified.
       if int(action.get('process_outputs_as_sources', False)):
         for output in action['outputs']:
           AddSourceToTarget(output, pbxp, xct)
 
       if int(action.get('process_outputs_as_mac_bundle_resources', False)):
         for output in action['outputs']:
           AddResourceToTarget(output, pbxp, xct)
 
@@ skipping 32 matching lines @@
     #         compile.  The rule action script would need to touch the dummy.
     # 6584839 I need a way to declare additional inputs to a custom rule.
     #         A possible workaround is a shell script phase prior to
     #         compilation that touches a rule's primary input files if any
     #         would-be additional inputs are newer than the output.  Modifying
     #         the source tree - even just modification times - feels dirty.
     # 6564240 Xcode "custom script" build rules always dump all environment
     #         variables.  This is a low-prioroty problem and is not a
     #         show-stopper.
     rules_by_ext = {}
-    for rule in spec.get('rules', []):
+    for rule in spec_rules:
       rules_by_ext[rule['extension']] = rule
 
       # First, some definitions:
       #
       # A "rule source" is a file that was listed in a target's "sources"
       # list and will have a rule applied to it on the basis of matching the
       # rule's "extensions" attribute.  Rule sources are direct inputs to
       # rules.
       #
       # Rule definitions may specify additional inputs in their "inputs"
@@ skipping 197 matching lines @@
 fi
 exec "${DEVELOPER_BIN_DIR}/make" -f "${PROJECT_FILE_PATH}/%s" -j "${JOB_COUNT}"
 exit 1
 """ % makefile_name
         ssbp = gyp.xcodeproj_file.PBXShellScriptBuildPhase({
               'name': 'Rule "' + rule['rule_name'] + '"',
               'shellScript': script,
               'showEnvVarsInLog': 0,
             })
 
-        # TODO(mark): this assumes too much knowledge of the internals of
-        # xcodeproj_file; some of these smarts should move into xcodeproj_file
-        # itself.
-        xct._properties['buildPhases'].insert(prebuild_index, ssbp)
-        prebuild_index = prebuild_index + 1
+        if support_xct:
+          support_xct.AppendProperty('buildPhases', ssbp)
+        else:
+          # TODO(mark): this assumes too much knowledge of the internals of
+          # xcodeproj_file; some of these smarts should move into xcodeproj_file
+          # itself.
+          xct._properties['buildPhases'].insert(prebuild_index, ssbp)
+          prebuild_index = prebuild_index + 1
 
       # Extra rule inputs also go into the project file.  Concrete outputs were
       # already added when they were computed.
       for group in ['inputs', 'inputs_excluded']:
         for item in rule.get(group, []):
           pbxp.AddOrGetFileInRootGroup(item)
 
     # Add "sources".
     for source in spec.get('sources', []):
       (source_root, source_extension) = posixpath.splitext(source)
@@ skipping 65 matching lines @@
     # libraries.  On some systems, ld is finicky and even requires the
     # libraries to be ordered in such a way that unresolved symbols in
     # earlier-listed libraries may only be resolved by later-listed libraries.
     # The Mac linker doesn't work that way, but other platforms do, and so
     # their linker invocations need to be constructed in this way.  There's
     # no compelling reason for Xcode's linker invocations to differ.
 
     if 'dependencies' in spec:
       for dependency in spec['dependencies']:
         xct.AddDependency(xcode_targets[dependency])
+        # The support project also gets the dependencies (in case they are
+        # needed for the actions/rules to work).
+        if support_xct:
+          support_xct.AddDependency(xcode_targets[dependency])
 
     if 'libraries' in spec:
       for library in spec['libraries']:
         xct.FrameworksPhase().AddFile(library)
         # Add the library's directory to LIBRARY_SEARCH_PATHS if necessary.
         # I wish Xcode handled this automatically.
         # TODO(mark): this logic isn't right.  There are certain directories
         # that are always searched, we should check to see if the library is
         # in one of those directories, and if not, we should do the
         # AppendBuildSetting thing.
@@ skipping 30 matching lines @@
 
   for build_file in build_files:
     xcode_projects[build_file].Finalize1(xcode_targets, serialize_all_tests)
 
   for build_file in build_files:
     xcode_projects[build_file].Finalize2(xcode_targets,
                                          xcode_target_to_target_dict)
 
   for build_file in build_files:
     xcode_projects[build_file].Write()