Adds new GN template go_binary

mojo/go/rules.gni

Index: mojo/go/rules.gni
diff --git a/mojo/go/rules.gni b/mojo/go/rules.gni
index 60714f0f088381de992ef2900567d747a55395de..f860f440e2441daf69cac1fdccf5b1f22a56bd7a 100644
--- a/mojo/go/rules.gni
+++ b/mojo/go/rules.gni
@@ -91,6 +91,65 @@ template("go_test_binary") {
   }
 }
 
+template("go_application") {

[rogulenko, 2015/10/01 18:48:07]

My high level question is how are you going to use it?
If you just want to simulate a normal 'go build ...' command, then you don't
need half of the stuff here: you don't need the static_library, the copy target
and the cgo stuff. I'm not sure if you need android. Also it would be nice to
get rid of the build_dir trick since the current version of the go tool supports
the -o flag.

[rudominer, 2015/10/02 16:36:00]

I plan to use this to build the new version of the Mojom compiler
which is written in Go. This application needs to link against
the Mojo Go bindings because it will serialize the compiler's
intermediate representation to a Mojo message. This means that
I do need to use cgo and depend on the target
//mojo/public/platform/native:system.
(As an aside it should be possible to
refactor the Go bindings so that the native code is not
necessary for doing serialization. But that is a different
project.)

Here is what my invocation looks like:

go_binary("mojom_parser") {
  sources = [
    "parser_main.go",
  ]
  inputs = [
    "generated/mojom_files/mojom_files.mojom.go",
    <some files elided from the list here>
    "parser/parsing.go",
  ]
  deps = [
    "//mojo/public/platform/native:system",
  ]
}


you don't need the static_library, the copy target
I got rid of Android support.

Also it would be nice to
The current version of the go compiler checked into Mojo's third-party does not
yet support the -o flag. I have added a TODO to update the go compiler and then
simplify the rules in this file. I will do that in a follow up CL.

+  assert(is_android || is_linux)
+  assert(defined(invoker.sources))
+  assert(defined(invoker.deps))
+  assert(defined(invoker.static_library_sources))
+  assert(go_build_tool != "")
+
+  static_library_name = target_name + "_static_library"
+  static_library(static_library_name) {
+    complete_static_lib = true
+    sources = invoker.static_library_sources
+    deps = invoker.deps
+  }
+
+  go_binary_name = target_name + "_go"
+  action(go_binary_name) {
+    deps = invoker.deps + [ ":${static_library_name}" ]
+    script = "//mojo/go/go.py"
+    inputs = invoker.sources
+    outputs = [
+      "${target_out_dir}/${target_name}",
+    ]
+
+    # Since go build does not permit specifying an output directory or output
+    # binary name, we create a temporary build directory, and the python
+    # script will later identify the output, copy it to the target location,
+    # and clean up the temporary build directory.
+    build_dir = "${target_out_dir}/${target_name}_build"
+    args = []
+    if (is_android) {
+      args += [ "--android" ]
+    }
+    args += [
+      "--",
+      "${go_build_tool}",
+      rebase_path(build_dir, root_build_dir),
+      rebase_path(target_out_dir, root_build_dir) + "/${target_name}",
+      rebase_path("//", root_build_dir),
+      rebase_path(root_out_dir, root_build_dir),
+      "-I" + rebase_path("//"),
+      "-L" + rebase_path(target_out_dir) + " -l" + static_library_name + "",
+      "build",
+    ]
+    args += rebase_path(invoker.sources, build_dir)
+  }
+
+  copy(target_name) {
+    deps = [
+      ":${go_binary_name}",
+    ]
+    sources = [
+      "${target_out_dir}/${go_binary_name}",
+    ]
+    outputs = [
+      "${root_out_dir}/${target_name}",
+    ]
+  }
+}
+
 template("go_mojo_application") {
   assert(is_android || is_linux)
   assert(defined(invoker.sources))