Add -freeosmemory=true flag & invoke FreeOSMemory periodically (lower memory consumption)

To try this change out:

1. `git checkout sg/mem` to the exact commit.
2. `go install github.com/sourcegraph/go-langserver`
3. Open some Go code and hover over a symbol, then make an edit, then hover, repeat... (each edit and hover triggers type-checking again).
4. You can also set `"go.languageServerFlags": ["-freeosmemory=false"]` in VS Code settings to try without this change (to compare memory usage).

With `code github.com/docker/docker/cmd/dockerd/docker.go`, and making 10 edits/hovers, the change is:

| Real Before | Real After | Real Change | Go Before | Go After | Go Change |
|-------------|------------|-------------|-----------|----------|-----------|
| 7.61GB      | 4.12GB     | -45.86%     | 3.92GB    | 3.33GB   | -15.05%   |

Where `Real` means real memory reported by OS X Activity Monitor, and `Go` means memory reported by Go as being in use.

TL;DR: 46% less memory consumption for users running with the vscode-go extension.

Author: Stephen Gutekanst

main.go

@@ -9,6 +9,8 @@ import (
 	"net"
 	"net/http"
 	"os"
+	"runtime/debug"
+	"time"
 
 	"github.com/sourcegraph/go-langserver/langserver"
 	"github.com/sourcegraph/jsonrpc2"
@@ -23,6 +25,7 @@ var (
 	logfile      = flag.String("logfile", "", "also log to this file (in addition to stderr)")
 	printVersion = flag.Bool("version", false, "print version and exit")
 	pprof        = flag.String("pprof", ":6060", "start a pprof http server (https://golang.org/pkg/net/http/pprof/)")
+	freeosmemory = flag.Bool("freeosmemory", true, "aggressively free memory back to the OS")
 )
 
 // version is the version field we report back. If you are releasing a new version:
@@ -43,6 +46,10 @@ func main() {
 		}()
 	}
 
+	if *freeosmemory {
+		go freeOSMemory()
+	}
+
 	if err := run(); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)
@@ -117,3 +124,41 @@ func (stdrwc) Close() error {
 	}
 	return os.Stdout.Close()
 }
+
+// freeOSMemory should be called in a goroutine, it invokes
+// runtime/debug.FreeOSMemory() more aggressively than the runtime default of
+// 5 minutes after GC.
+//
+// There is a long-standing known issue with Go in which memory is not returned
+// to the OS aggressively enough[1], which coincidently harms our application
+// quite a lot because we perform so many short-burst heap allocations during
+// the type-checking phase.
+//
+// This function should only be invoked in editor mode, not in sourcegraph.com
+// mode, because users running the language server as part of their editor
+// generally expect much lower memory usage. In contrast, on sourcegraph.com we
+// can give our servers plenty of RAM and allow Go to consume as much as it
+// wants. Go does reuse the memory not free'd to the OS, and as such enabling
+// this does _technically_ make our application perform less optimally -- but
+// in practice this has no observable effect in editor mode.
+//
+// The end effect of performing this is that repeating "hover over code" -> "make an edit"
+// 10 times inside a large package like github.com/docker/docker/cmd/dockerd:
+//
+//
+// 	| Real Before | Real After | Real Change | Go Before | Go After | Go Change |
+// 	|-------------|------------|-------------|-----------|----------|-----------|
+// 	| 7.61GB      | 4.12GB     | -45.86%     | 3.92GB    | 3.33GB   | -15.05%   |
+//
+// Where `Real` means real memory reported by OS X Activity Monitor, and `Go`
+// means memory reported by Go as being in use.
+//
+// TL;DR: 46% less memory consumption for users running with the vscode-go extension.
+//
+// [1] https://github.com/golang/go/issues/14735#issuecomment-194470114
+func freeOSMemory() {
+	for {
+		time.Sleep(1 * time.Second)
+		debug.FreeOSMemory()
+	}
+}