depot/third_party/tvl/nix/buildGo/README.md

buildGo.nix

This is an alternative Nix build system for Go. It supports building Go libraries and programs, and even automatically generating Protobuf & gRPC libraries.

Note: This will probably end up being folded into Nixery.

Background

Most language-specific Nix tooling outsources the build to existing language-specific build tooling, which essentially means that Nix ends up being a wrapper around all sorts of external build systems.

However, systems like Bazel take an alternative approach in which the compiler is invoked directly and the composition of programs and libraries stays within a single homogeneous build system.

Users don't need to learn per-language build systems and especially for companies with large monorepo-setups (like Google) this has huge productivity impact.

This project is an attempt to prove that Nix can be used in a similar style to build software directly, rather than shelling out to other build systems.

Example

Given a program layout like this:

.
├── lib          <-- some library component
│   ├── bar.go
│   └── foo.go
├── api.proto    <-- gRPC API definition
├── main.go      <-- program implementation
└── default.nix  <-- build instructions

The contents of default.nix could look like this:

{ buildGo }:

let
  api = buildGo.grpc {
    name  = "someapi";
    proto = ./api.proto;
  };

  lib = buildGo.package {
    name = "somelib";
    srcs = [
      ./lib/bar.go
      ./lib/foo.go
    ];
  };
in buildGo.program {
  name = "my-program";
  deps = [ api lib ];

  srcs = [
    ./main.go
  ];
}

(If you don't know how to read Nix, check out nix-1p)

Usage

buildGo exposes five different functions:

• buildGo.program: Build a Go binary out of the specified source files.

  parameter	type	use	required?
  name	string	Name of the program (and resulting executable)	yes
  srcs	list<path>	List of paths to source files	yes
  deps	list<drv>	List of dependencies (i.e. other Go libraries)	no
  x_defs	attrs<string, string>	Attribute set of linker vars (i.e. -X-flags)	no

• buildGo.package: Build a Go library out of the specified source files.

  parameter	type	use	required?
  name	string	Name of the library	yes
  srcs	list<path>	List of paths to source files	yes
  deps	list<drv>	List of dependencies (i.e. other Go libraries)	no
  path	string	Go import path for the resulting library	no

• buildGo.external: Build an externally defined Go library or program.

  This function performs analysis on the supplied source code (which can use the standard Go tooling layout) and creates a tree of all the packages contained within.

  This exists for compatibility with external libraries that were not defined using buildGo.

  parameter	type	use	required?
  path	string	Go import path for the resulting package	yes
  src	path	Path to the source directory	yes
  deps	list<drv>	List of dependencies (i.e. other Go packages)	no

  For some examples of how buildGo.external is used, check out proto.nix.

• buildGo.proto: Build a Go library out of the specified Protobuf definition.

  parameter	type	use	required?
  name	string	Name for the resulting library	yes
  proto	path	Path to the Protobuf definition file	yes
  path	string	Import path for the resulting Go library	no
  extraDeps	list<drv>	Additional Go dependencies to add to the library	no

• buildGo.grpc: Build a Go library out of the specified gRPC definition.

  The parameters are identical to buildGo.proto.

Current status

This project is work-in-progress. Crucially it is lacking the following features:

• feature flag parity with Bazel's Go rules
• documentation building
• test execution

There are still some open questions around how to structure some of those features in Nix.