clang/gn/win: Stop running the compiler through `ninja -t msvc -e environment.foo`

build/toolchain/win/BUILD.gn

 # Copyright (c) 2013 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.
 
 import("//build/config/sanitizers/sanitizers.gni")
 import("//build/config/win/visual_studio_version.gni")
 import("//build/toolchain/goma.gni")
 import("//build/toolchain/toolchain.gni")
 
 # Should only be running on Windows.
@@ skipping 44 matching lines @@
 #  environment: File name of environment file.
 template("msvc_toolchain") {
   if (defined(invoker.concurrent_links)) {
     concurrent_links = invoker.concurrent_links
   }
 
   env = invoker.environment
 
   cl = invoker.cl
 
+  # If possible, pass system includes as flags to the compiler.  When that's
+  # not possible, load a full environment file (containing %INCLUDE% and
+  # %PATH%) -- e.g. 32-bit msvs builds require %PATH% to be set and just passing
+  # in a list of include directories isn't enough.
+  if (defined(invoker.sys_include_flags)) {
+    env_wrapper = ""
+    sys_include_flags = "${invoker.sys_include_flags} "  # Note trailing space.
+  } else {
+    assert(!is_clang)  # clang-cl doesn't need this env hoop, so omit it there.

[scottmg, 2016/02/26 03:32:03]

Should this be invoker.is_clang?

[Nico, 2016/02/26 15:16:26]

Oh, good catch, thanks, done! That's what I get for tweaking Windows CLs on my
Mac -- would've taken me a while to figure this out this morning without this
comment :-)

+    env_wrapper = "ninja -t msvc -e $env -- "  # Note trailing space.
+    sys_include_flags = ""
+  }
+
   toolchain(target_name) {
     # Make these apply to all tools below.
     lib_switch = ""
     lib_dir_switch = "/LIBPATH:"
 
     # Object files go in this directory.
     object_subdir = "{{target_out_dir}}/{{label_name}}"
 
     tool("cc") {
       rspfile = "{{output}}.rsp"
       precompiled_header_type = "msvc"
       pdbname = "{{target_out_dir}}/{{label_name}}_c.pdb"
-      command = "ninja -t msvc -e $env -- $cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
+      command = "$env_wrapper$cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
       depsformat = "msvc"
       description = "CC {{output}}"
       outputs = [
         "$object_subdir/{{source_name_part}}.obj",
       ]
-      rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
+      rspfile_content = "$sys_include_flags{{defines}} {{include_dirs}} {{cflags}} {{cflags_c}}"
     }
 
     tool("cxx") {
       rspfile = "{{output}}.rsp"
       precompiled_header_type = "msvc"
 
       # The PDB name needs to be different between C and C++ compiled files.
       pdbname = "{{target_out_dir}}/{{label_name}}_cc.pdb"
-      command = "ninja -t msvc -e $env -- $cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
+      command = "$env_wrapper$cl /nologo /showIncludes /FC @$rspfile /c {{source}} /Fo{{output}} /Fd$pdbname"
       depsformat = "msvc"
       description = "CXX {{output}}"
       outputs = [
         "$object_subdir/{{source_name_part}}.obj",
       ]
-      rspfile_content = "{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}}"
+      rspfile_content = "$sys_include_flags{{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}}"
     }
 
     tool("rc") {
       command = "$python_path gyp-win-tool rc-wrapper $env rc.exe {{defines}} {{include_dirs}} /fo{{output}} {{source}}"
       outputs = [
         "$object_subdir/{{source_name_part}}.res",
       ]
       description = "RC {{output}}"
     }
 
@@ skipping 123 matching lines @@
                                "is_clang",
                                "is_component_build",
                              ])
 
       # This value needs to be passed through unchanged.
       host_toolchain = host_toolchain
     }
   }
 }
 
+if (is_clang) {
+  sys_include_prefix = "-isystem="
+} else {
+  # MSVC doesn't have the concept of system headers.
+  sys_include_prefix = "/I"
+}
+
 if (host_os == "win") {
   clang_cl = "clang-cl.exe"
 } else {
   clang_cl = "clang-cl"
 }
 
 # 32-bit toolchains. Only define these when the target architecture is 32-bit
 # since we don't do any 32-bit cross compiles when targeting 64-bit (the
 # build does generate some 64-bit stuff from 32-bit target builds).
 if (target_cpu == "x86") {
   x86_toolchain_data = exec_script("setup_toolchain.py",
                                    [
                                      visual_studio_path,
                                      gyp_win_tool_path,
                                      windows_sdk_path,
                                      visual_studio_runtime_dirs,
                                      "x86",
+                                     "${sys_include_prefix}",
                                    ],
                                    "scope")
 
   msvc_toolchain("x86") {
     environment = "environment.x86"
     toolchain_cpu = "x86"
     cl = "${goma_prefix}\"${x86_toolchain_data.vc_bin_dir}/cl.exe\""
     is_clang = false
   }
 
   msvc_toolchain("clang_x86") {
     environment = "environment.x86"
     toolchain_cpu = "x86"
     prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
                          root_build_dir)
     cl = "${goma_prefix}$prefix/${clang_cl}"
     toolchain_os = "win"
     is_clang = true
+    sys_include_flags = "${x86_toolchain_data.include_flags}"
   }
 }
 
 # 64-bit toolchains.
 x64_toolchain_data = exec_script("setup_toolchain.py",
                                  [
                                    visual_studio_path,
                                    gyp_win_tool_path,
                                    windows_sdk_path,
                                    visual_studio_runtime_dirs,
                                    "x64",
+                                   "${sys_include_prefix}",
                                  ],
                                  "scope")
 
 template("win_x64_toolchains") {
   # TODO(mcgrathr): These assignments are only required because of
   # crbug.com/395883.  Drop them if that ever gets fixed in GN.
   concurrent_links = invoker.concurrent_links
   goma_prefix = invoker.goma_prefix
   x64_toolchain_data = invoker.x64_toolchain_data
   clang_cl = invoker.clang_cl
 
   msvc_toolchain(target_name) {
     environment = "environment.x64"
     toolchain_cpu = "x64"
     cl = "${goma_prefix}\"${x64_toolchain_data.vc_bin_dir}/cl.exe\""
     is_clang = false
 
     forward_variables_from(invoker, [ "is_component_build" ])
   }
 
   msvc_toolchain("clang_" + target_name) {
     environment = "environment.x64"
     toolchain_cpu = "x64"
     prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
                          root_build_dir)
     cl = "${goma_prefix}$prefix/${clang_cl}"
     toolchain_os = "win"
     is_clang = true
+    sys_include_flags = "${x64_toolchain_data.include_flags}"
 
     forward_variables_from(invoker, [ "is_component_build" ])
   }
 }
 
 win_x64_toolchains("x64") {
   # TODO(mcgrathr): These assignments are only required because of
   # crbug.com/395883.  Drop them if that ever gets fixed in GN.
   concurrent_links = concurrent_links
   goma_prefix = goma_prefix
@@ skipping 34 matching lines @@
 
   msvc_toolchain("winrt_x64") {
     environment = "environment.winrt_x64"
     cl = "${goma_prefix}\"${vc_bin_dir}/cl.exe\""
     is_clang = false
 
     toolchain_cpu = "x64"
     toolchain_os = current_os
   }
 }