ninja windows: Support magic idl build rules

pylib/gyp/generator/ninja.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.
 
 import copy
 import gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.MSVSVersion
 import gyp.system_test
@@ skipping 366 matching lines @@
 
     if self.name != output and self.toolset == 'target':
       # Write a short name to build this target.  This benefits both the
       # "build chrome" case as well as the gyp tests, which expect to be
       # able to run actions and build libraries by their short name.
       self.ninja.build(self.name, 'phony', output)
 
     assert self.target.FinalOutput(), output
     return self.target
 
+  def _IdlRule(self, source, prebuild, outputs):
+    """Handle the implicit VS .idl rule for one source file. Fills |outputs|
+    with files that are generated."""

[Nico, 2012/04/05 18:02:24]

assert self.flavor == 'win'

it would be nice if more of this could be in msvs_emulation, but i can't think
of a great way to split it up. (since msvs_emulation is only used by ninja, my
concern is mostly keeping win-only things out of this file as much as possible.)

[scottmg, 2012/04/05 18:14:26]

Done.
Yeah. I had it in there wholesale before, but it seemed to have to pass in too
much (functions, etc.) so felt not usefully separated.

I believe there will be something similar required for .rc files so I will keep
it in mind for refactoring when I get there.

+    outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
+        source, self.config_name)
+    outdir = self.GypPathToNinja(outdir)
+    def fix_path(path, rel=None):
+      path = os.path.join(outdir, path)
+      dirname, basename = os.path.split(source)
+      root, ext = os.path.splitext(basename)
+      path = self.ExpandRuleVariables(
+          path, root, dirname, source, ext, basename)
+      if rel:
+        path = os.path.relpath(path, rel)
+      return path
+    vars = [(name, fix_path(value, outdir)) for name, value in vars]
+    output = [fix_path(p) for p in output]
+    vars.append(('outdir', outdir))
+    vars.append(('idlflags', flags))
+    input = self.GypPathToNinja(source)
+    self.ninja.build(output, 'idl', input,
+        variables=vars, order_only=prebuild)
+    outputs.extend(output)
+
+  def WriteWinIdlFiles(self, spec, prebuild):
+    """Writes rules to match MSVS's implicit idl handling."""
+    if self.msvs_settings.HasExplicitIdlRules(spec):
+      return []
+    outputs = []
+    for source in filter(lambda x: x.endswith('.idl'), spec['sources']):
+      self._IdlRule(source, prebuild, outputs)
+    return outputs
+
   def WriteActionsRulesCopies(self, spec, extra_sources, prebuild,
                               mac_bundle_depends):
     """Write out the Actions, Rules, and Copies steps.  Return a path
     representing the outputs of these steps."""
     outputs = []
     extra_mac_bundle_resources = []
 
     if 'actions' in spec:
       outputs += self.WriteActions(spec['actions'], extra_sources, prebuild,
                                    extra_mac_bundle_resources)
     if 'rules' in spec:
       outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,
                                  extra_mac_bundle_resources)
     if 'copies' in spec:
       outputs += self.WriteCopies(spec['copies'], prebuild)
 
+    if 'sources' in spec and self.flavor == 'win':
+      outputs += self.WriteWinIdlFiles(spec, prebuild)
+
     stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)
 
     if self.is_mac_bundle:
       mac_bundle_resources = spec.get('mac_bundle_resources', []) + \
                              extra_mac_bundle_resources
       self.WriteMacBundleResources(mac_bundle_resources, mac_bundle_depends)
       self.WriteMacInfoPlist(mac_bundle_depends)
 
     return stamp
 
@@ skipping 238 matching lines @@
       ext = ext[1:]
       if ext in ('cc', 'cpp', 'cxx'):
         command = 'cxx'
       elif ext in ('c', 's', 'S'):
         command = 'cc'
       elif self.flavor == 'mac' and ext == 'm':
         command = 'objc'
       elif self.flavor == 'mac' and ext == 'mm':
         command = 'objcxx'
       else:
-        # TODO: should we assert here on unexpected extensions?
+        # Ignore unhandled extensions.
         continue
       input = self.GypPathToNinja(source)
       output = self.GypPathToUniqueOutput(filename + self.obj_ext)
       implicit = precompiled_header.GetObjDependencies([input], [output])
       self.ninja.build(output, command, input,
                        implicit=[gch for _, _, gch in implicit],
                        order_only=predepends)
       outputs.append(output)
 
     self.WritePchTargets(pch_commands)
@@ skipping 505 matching lines @@
     master_ninja.rule(
       'cxx',
       description='CXX $out',
       command=('cmd /s /c "$cxx /nologo /showIncludes '
                '@$out.rsp '
                '$cflags_pch_cc /c $in /Fo$out /Fd$pdbname '
                '| ninja-deplist-helper -q -f cl -o $out.dl"'),
       deplist='$out.dl',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_cc')
+    master_ninja.rule(
+      'idl',
+      description='IDL $in',
+      command=('python gyp-win-tool midl-wrapper $outdir '
+               '$tlb $h $dlldata $iid $proxy $in '
+               '$idlflags'))
 
   if flavor != 'mac' and flavor != 'win':
     master_ninja.rule(
       'alink',
       description='AR $out',
       command='rm -f $out && $ar rcsT $out $in')
     master_ninja.rule(
       'solink',
       description='SOLINK $out',
       command=('$ld -shared $ldflags -o $out -Wl,-soname=$soname '
@@ skipping 155 matching lines @@
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)