Only generate code for files that are specified, not their imports.

mojo/public/tools/bindings/run_code_generators.py

 #!/usr/bin/env python
 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 #
 # This script accepts the output of version 2 of the mojom parser and uses that
 # data to invoke the code generators.
 
 import argparse
 import imp
 import os
 import sys
 
 
 def _ParseCLIArgs():
   """Parses the command line arguments.
 
   Returns:
     tuple<Namespace, list<str>> The first value of the tuple is a Namespace
     holding the value of the optional args. The second value of the tuple is
     a list of the remaining arguments.
   """
   parser = argparse.ArgumentParser(
       description='Generate bindings from mojom parser output.')
+  parser.add_argument('filenames', nargs='*',
+                      help='Filter on the set of .mojom files for which code '
+                      'will be generated.')
   parser.add_argument('-f', '--file-graph', dest='file_graph',
                       help='Location of the parser output. "-" for stdin. '
                       '(default "-")', default='-')
   parser.add_argument('-p', '--python-sdk-dir', dest='python_sdk_dir',
                       default=None,
                       help='Location of the compiled python bindings')
   parser.add_argument("-o", "--output-dir", dest="output_dir", default=".",
                       help="output directory for generated files")
   parser.add_argument("-g", "--generators", dest="generators_string",
                       metavar="GENERATORS",
                       default="c++,dart,go,javascript,java,python",
                       help="comma-separated list of generators")
   parser.add_argument("-d", "--depth", dest="depth", default=".",
                       help="relative path to the root of the source tree.")
+  parser.add_argument("--no-gen-imports", action="store_true",
+                      help="Generate code only for the files that are "
+                      "specified on the command line. By default, code "
+                      "is generated for all specified files and their "
+                      "transitive imports.")
   parser.add_argument("--generate-type-info", dest="generate_type_info",
                       action="store_true",
                       help="generate mojom type descriptors")
   parser.add_argument("--no-generate-type-info", dest="generate_type_info",
                       action="store_false",
                       help="do not generate mojom type descriptors")
   parser.set_defaults(generate_type_info=True)
 
   return parser.parse_known_args()
 
@@ skipping 103 matching lines @@
 
   if args.file_graph == '-':
     fp = sys.stdin
   else:
     fp = open(args.file_graph)
 
   mojom_file_graph = ReadMojomFileGraphFromFile(fp)
   modules = mojom_translator.TranslateFileGraph(mojom_file_graph)
 
   generator_modules = LoadGenerators(args.generators_string)
+  filenames = set(os.path.basename(filename) for filename in args.filenames)
 
   for _, module in modules.iteritems():
+    # If filenames are specified on the command line, only generate code for
+    # the specified mojom files.
+    # TODO(azani): This is not as robust as we would like since files with the
+    # same name but different paths or files resolved through links might not
+    # be correctly identified by module.name.
+    if args.no_gen_imports and filenames and module.name not in filenames:
+      continue
     FixModulePath(module, os.path.abspath(args.depth))
     for generator_module in generator_modules:
       generator = generator_module.Generator(module, args.output_dir)
 
       # Look at unparsed args for generator-specific args.
       filtered_args = []
       if hasattr(generator_module, 'GENERATOR_PREFIX'):
         prefix = '--' + generator_module.GENERATOR_PREFIX + '_'
         filtered_args = [arg for arg in remaining_args
                          if arg.startswith(prefix)]
       if args.generate_type_info:
         filtered_args.append("--generate_type_info")
 
       generator.GenerateFiles(filtered_args)
 
 
 if __name__ == "__main__":
   sys.exit(main())