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 builds require %PATH% to be set and just passing

[scottmg, 2016/02/25 22:56:37]

"%PATH%" in the first instance.

[scottmg, 2016/02/25 22:56:37]

"32-bit cl.exe builds..."

[Nico, 2016/02/26 03:00:44]

Done.

[Nico, 2016/02/26 03:00:44]

Done.

+  # in a list of include directories isn't enough.
+  if (defined(invoker.sys_include_flags)) {

[scottmg, 2016/02/25 22:56:37]

I think this would be more clear as is_clang.

[Nico, 2016/02/26 03:00:44]

Hm, but then if we ever get rid of the 32-bit build and move the 64-bit msvs
build (if it's still around then) to this system too, then we have to change two
lines instead of just one…I kind of like that this doesn't duplicate the logic. 
I added an `assert(!is_clang)` to the else block, how's that? (Just hitting *
while the cursor is on sys_include_flags finds quickly where this is set.)

If you really do want is_clang I'll change it though, of course :-)

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

Wow, I feel like we'll add a 128-bit build before that happens... :)
assert sgtm.

+    env_wrapper = ""
+    sys_include_flags = "${invoker.sys_include_flags} "  # Note trailing space.
+  } else {
+    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
   }
 }