Error on multiple files with same basenames in target.

pylib/gyp/input.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.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
@@ skipping 2087 matching lines @@
   VALID_TARGET_TYPES = ('executable', 'loadable_module',
                         'static_library', 'shared_library',
                         'none')
   target_type = target_dict.get('type', None)
   if target_type not in VALID_TARGET_TYPES:
     raise Exception("Target %s has an invalid target type '%s'.  "
                     "Must be one of %s." %
                     (target, target_type, '/'.join(VALID_TARGET_TYPES)))
 
 
+def ValidateSourcesInTarget(target, target_dict, build_file):
+  # TODO: Check if MSVC allows this for non-static_library targets.
+  if target_dict.get('type', None) != 'static_library':
+    return
+  sources = target_dict.get('sources', [])
+  basenames = {}
+  for source in sources:
+    name, ext = os.path.splitext(source)
+    is_compiled_file = ext in ['.c', '.cc', '.m', '.mm', '.s', '.S']

[scottmg, 2012/04/05 23:12:49]

+= .cpp? (or is there a canonical list like this somewhere?)

+    if not is_compiled_file:
+      continue
+    basename = os.path.basename(name)  # Don't include extension.
+    basenames.setdefault(basename, []).append(source)
+
+  error = ''
+  for basename, files in basenames.iteritems():
+    if len(files) > 1:
+      error += '  %s: %s\n' % (basename, ' '.join(files))
+
+  if error:
+    print ('static library %s has several files with the same basename:\n' %
+           target + error + 'Some build systems, e.g. MSVC08, '
+           'cannot handle that.')
+    raise KeyError, 'Duplicate basenames in sources section, see list above'
+
+
 def ValidateRulesInTarget(target, target_dict, extra_sources_for_rules):
   """Ensures that the rules sections in target_dict are valid and consistent,
   and determines which sources they apply to.
 
   Arguments:
     target: string, name of target.
     target_dict: dict, target spec containing "rules" and "sources" lists.
     extra_sources_for_rules: a list of keys to scan for rule matches in
         addition to 'sources'.
   """
@@ skipping 37 matching lines @@
         (source_root, source_extension) = os.path.splitext(source)
         if source_extension.startswith('.'):
           source_extension = source_extension[1:]
         if source_extension == extension:
           rule_sources.append(source)
 
     if len(rule_sources) > 0:
       rule['rule_sources'] = rule_sources
 
 
-def ValidateActionsInTarget(target, target_dict, build_file):
-  '''Validates the inputs to the actions in a target.'''
-  target_name = target_dict.get('target_name')
-  actions = target_dict.get('actions', [])
-  for action in actions:
-    action_name = action.get('action_name')
-    if not action_name:
-      raise Exception("Anonymous action in target %s.  "
-                      "An action must have an 'action_name' field." %
-                      target_name)
-    inputs = action.get('inputs', [])
-    action_command = action.get('action')
-    if action_command and not action_command[0]:
-      raise Exception("Empty action as command in target %s." % target_name)
-
-
 def ValidateRunAsInTarget(target, target_dict, build_file):
   target_name = target_dict.get('target_name')
   run_as = target_dict.get('run_as')
   if not run_as:
     return
   if not isinstance(run_as, dict):
     raise Exception("The 'run_as' in target %s from file %s should be a "
                     "dictionary." %
                     (target_name, build_file))
   action = run_as.get('action')
@@ skipping 10 matching lines @@
     raise Exception("The 'working_directory' for 'run_as' in target %s "
                     "in file %s should be a string." %
                     (target_name, build_file))
   environment = run_as.get('environment')
   if environment and not isinstance(environment, dict):
     raise Exception("The 'environment' for 'run_as' in target %s "
                     "in file %s should be a dictionary." %
                     (target_name, build_file))
 
 
+def ValidateActionsInTarget(target, target_dict, build_file):
+  '''Validates the inputs to the actions in a target.'''
+  target_name = target_dict.get('target_name')
+  actions = target_dict.get('actions', [])
+  for action in actions:
+    action_name = action.get('action_name')
+    if not action_name:
+      raise Exception("Anonymous action in target %s.  "
+                      "An action must have an 'action_name' field." %
+                      target_name)
+    inputs = action.get('inputs', [])
+    action_command = action.get('action')
+    if action_command and not action_command[0]:
+      raise Exception("Empty action as command in target %s." % target_name)
+
+
 def TurnIntIntoStrInDict(the_dict):
   """Given dict the_dict, recursively converts all integers into strings.
   """
   # Use items instead of iteritems because there's no need to try to look at
   # reinserted keys and their associated values.
   for k, v in the_dict.items():
     if isinstance(v, int):
       v = str(v)
       the_dict[k] = v
     elif isinstance(v, dict):
@@ skipping 165 matching lines @@
     ProcessListFiltersInDict(target, target_dict)
 
   # Make sure that the rules make sense, and build up rule_sources lists as
   # needed.  Not all generators will need to use the rule_sources lists, but
   # some may, and it seems best to build the list in a common spot.
   # Also validate actions and run_as elements in targets.
   for target in flat_list:
     target_dict = targets[target]
     build_file = gyp.common.BuildFile(target)
     ValidateTargetType(target, target_dict)
+    ValidateSourcesInTarget(target, target_dict, build_file)
     ValidateRulesInTarget(target, target_dict, extra_sources_for_rules)
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]