Check for and disallow rules the process the output of other rules

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 2172 matching lines @@
     extra_sources_for_rules: a list of keys to scan for rule matches in
         addition to 'sources'.
   """
 
   # Dicts to map between values found in rules' 'rule_name' and 'extension'
   # keys and the rule dicts themselves.
   rule_names = {}
   rule_extensions = {}
 
   rules = target_dict.get('rules', [])
+
+  # Gather the outputs for all rules with process_outputs_as_sources so we can
+  # validate that they're not chained below.
+  processed_outputs = []
+  for rule in rules:
+    if rule.get('process_outputs_as_sources', False):
+      for output in rule['outputs']:
+        processed_outputs.append((rule, output))

[Evan Martin, 2012/05/18 22:53:36]

Why not a map of output extension => other stuff, so the below bit of code is a
single lookup?

+
   for rule in rules:
     # Make sure that there's no conflict among rule names and extensions.
     rule_name = rule['rule_name']
     if rule_name in rule_names:
       raise KeyError, 'rule %s exists in duplicate, target %s' % \
                       (rule_name, target)
     rule_names[rule_name] = rule
 
     rule_extension = rule['extension']
     if rule_extension in rule_extensions:
       raise KeyError, ('extension %s associated with multiple rules, ' +
                        'target %s rules %s and %s') % \
                       (rule_extension, target,
                        rule_extensions[rule_extension]['rule_name'],
                        rule_name)
     rule_extensions[rule_extension] = rule
 
+    # Make sure rules aren't chained (i.e. the output of one rule with
+    # process_outputs_as_sources is the input for another rule). Some
+    # generators can't reasonably support this.
+    for other, output in processed_outputs:
+      if other == rule:
+        continue
+      if output.endswith('.' + rule_extension):
+        raise KeyError, ('target %s contains "%s" rule that would handle '
+                         'the output of other rule %s (processing %s)' %
+                         (target, rule_extension, other['rule_name'], output))
+
     # Make sure rule_sources isn't already there.  It's going to be
     # created below if needed.
     if 'rule_sources' in rule:
       raise KeyError, \
             'rule_sources must not exist in input, target %s rule %s' % \
             (target, rule_name)
     extension = rule['extension']
 
     rule_sources = []
     source_keys = ['sources']
@@ skipping 261 matching lines @@
     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]