diff --git a/utils/vscode/src/lsp/LICENSE b/utils/vscode/src/lsp/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/utils/vscode/src/lsp/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/utils/vscode/src/lsp/README.md b/utils/vscode/src/lsp/README.md
new file mode 100644
index 0000000..c78f183
--- /dev/null
+++ b/utils/vscode/src/lsp/README.md
@@ -0,0 +1,5 @@
+This directory contains code forked from https://github.com/golang/tools/tree/master/internal/lsp.
+
+This code has been modified to remove unneeded features and dependencies.
+
+Submitted on behalf of a third-party: The Go Authors
diff --git a/utils/vscode/src/lsp/jsonrpc2/handler.go b/utils/vscode/src/lsp/jsonrpc2/handler.go
new file mode 100644
index 0000000..20d4841
--- /dev/null
+++ b/utils/vscode/src/lsp/jsonrpc2/handler.go
@@ -0,0 +1,134 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package jsonrpc2
+
+import (
+	"context"
+)
+
+// Handler is the interface used to hook into the message handling of an rpc
+// connection.
+type Handler interface {
+	// Deliver is invoked to handle incoming requests.
+	// If the request returns false from IsNotify then the Handler must eventually
+	// call Reply on the Conn with the supplied request.
+	// Handlers are called synchronously, they should pass the work off to a go
+	// routine if they are going to take a long time.
+	// If Deliver returns true all subsequent handlers will be invoked with
+	// delivered set to true, and should not attempt to deliver the message.
+	Deliver(ctx context.Context, r *Request, delivered bool) bool
+
+	// Cancel is invoked for cancelled outgoing requests.
+	// It is okay to use the connection to send notifications, but the context will
+	// be in the cancelled state, so you must do it with the background context
+	// instead.
+	// If Cancel returns true all subsequent handlers will be invoked with
+	// cancelled set to true, and should not attempt to cancel the message.
+	Cancel(ctx context.Context, conn *Conn, id ID, cancelled bool) bool
+
+	// Log is invoked for all messages flowing through a Conn.
+	// direction indicates if the message being received or sent
+	// id is the message id, if not set it was a notification
+	// elapsed is the time between a call being seen and the response, and is
+	// negative for anything that is not a response.
+	// method is the method name specified in the message
+	// payload is the parameters for a call or notification, and the result for a
+	// response
+
+	// Request is called near the start of processing any request.
+	Request(ctx context.Context, conn *Conn, direction Direction, r *WireRequest) context.Context
+	// Response is called near the start of processing any response.
+	Response(ctx context.Context, conn *Conn, direction Direction, r *WireResponse) context.Context
+	// Done is called when any request is fully processed.
+	// For calls, this means the response has also been processed, for notifies
+	// this is as soon as the message has been written to the stream.
+	// If err is set, it implies the request failed.
+	Done(ctx context.Context, err error)
+	// Read is called with a count each time some data is read from the stream.
+	// The read calls are delayed until after the data has been interpreted so
+	// that it can be attributed to a request/response.
+	Read(ctx context.Context, bytes int64) context.Context
+	// Wrote is called each time some data is written to the stream.
+	Wrote(ctx context.Context, bytes int64) context.Context
+	// Error is called with errors that cannot be delivered through the normal
+	// mechanisms, for instance a failure to process a notify cannot be delivered
+	// back to the other party.
+	Error(ctx context.Context, err error)
+}
+
+// Direction is used to indicate to a logger whether the logged message was being
+// sent or received.
+type Direction bool
+
+const (
+	// Send indicates the message is outgoing.
+	Send = Direction(true)
+	// Receive indicates the message is incoming.
+	Receive = Direction(false)
+)
+
+func (d Direction) String() string {
+	switch d {
+	case Send:
+		return "send"
+	case Receive:
+		return "receive"
+	default:
+		panic("unreachable")
+	}
+}
+
+type EmptyHandler struct{}
+
+func (EmptyHandler) Deliver(ctx context.Context, r *Request, delivered bool) bool {
+	return false
+}
+
+func (EmptyHandler) Cancel(ctx context.Context, conn *Conn, id ID, cancelled bool) bool {
+	return false
+}
+
+func (EmptyHandler) Request(ctx context.Context, conn *Conn, direction Direction, r *WireRequest) context.Context {
+	return ctx
+}
+
+func (EmptyHandler) Response(ctx context.Context, conn *Conn, direction Direction, r *WireResponse) context.Context {
+	return ctx
+}
+
+func (EmptyHandler) Done(ctx context.Context, err error) {
+}
+
+func (EmptyHandler) Read(ctx context.Context, bytes int64) context.Context {
+	return ctx
+}
+
+func (EmptyHandler) Wrote(ctx context.Context, bytes int64) context.Context {
+	return ctx
+}
+
+func (EmptyHandler) Error(ctx context.Context, err error) {}
+
+type defaultHandler struct{ EmptyHandler }
+
+func (defaultHandler) Deliver(ctx context.Context, r *Request, delivered bool) bool {
+	if delivered {
+		return false
+	}
+	if !r.IsNotify() {
+		r.Reply(ctx, nil, NewErrorf(CodeMethodNotFound, "method %q not found", r.Method))
+	}
+	return true
+}
diff --git a/utils/vscode/src/lsp/jsonrpc2/jsonrpc2.go b/utils/vscode/src/lsp/jsonrpc2/jsonrpc2.go
new file mode 100644
index 0000000..b8436d2
--- /dev/null
+++ b/utils/vscode/src/lsp/jsonrpc2/jsonrpc2.go
@@ -0,0 +1,416 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package jsonrpc2 is a minimal implementation of the JSON RPC 2 spec.
+// https://www.jsonrpc.org/specification
+// It is intended to be compatible with other implementations at the wire level.
+package jsonrpc2
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"sync/atomic"
+)
+
+// Conn is a JSON RPC 2 client server connection.
+// Conn is bidirectional; it does not have a designated server or client end.
+type Conn struct {
+	seq        int64 // must only be accessed using atomic operations
+	handlers   []Handler
+	stream     Stream
+	err        error
+	pendingMu  sync.Mutex // protects the pending map
+	pending    map[ID]chan *WireResponse
+	handlingMu sync.Mutex // protects the handling map
+	handling   map[ID]*Request
+}
+
+type requestState int
+
+const (
+	requestWaiting = requestState(iota)
+	requestSerial
+	requestParallel
+	requestReplied
+	requestDone
+)
+
+// Request is sent to a server to represent a Call or Notify operaton.
+type Request struct {
+	conn        *Conn
+	cancel      context.CancelFunc
+	state       requestState
+	nextRequest chan struct{}
+
+	// The Wire values of the request.
+	WireRequest
+}
+
+// NewErrorf builds a Error struct for the supplied message and code.
+// If args is not empty, message and args will be passed to Sprintf.
+func NewErrorf(code int64, format string, args ...interface{}) *Error {
+	return &Error{
+		Code:    code,
+		Message: fmt.Sprintf(format, args...),
+	}
+}
+
+// NewConn creates a new connection object around the supplied stream.
+// You must call Run for the connection to be active.
+func NewConn(s Stream) *Conn {
+	conn := &Conn{
+		handlers: []Handler{defaultHandler{}},
+		stream:   s,
+		pending:  make(map[ID]chan *WireResponse),
+		handling: make(map[ID]*Request),
+	}
+	return conn
+}
+
+// AddHandler adds a new handler to the set the connection will invoke.
+// Handlers are invoked in the reverse order of how they were added, this
+// allows the most recent addition to be the first one to attempt to handle a
+// message.
+func (c *Conn) AddHandler(handler Handler) {
+	// prepend the new handlers so we use them first
+	c.handlers = append([]Handler{handler}, c.handlers...)
+}
+
+// Cancel cancels a pending Call on the server side.
+// The call is identified by its id.
+// JSON RPC 2 does not specify a cancel message, so cancellation support is not
+// directly wired in. This method allows a higher level protocol to choose how
+// to propagate the cancel.
+func (c *Conn) Cancel(id ID) {
+	c.handlingMu.Lock()
+	handling, found := c.handling[id]
+	c.handlingMu.Unlock()
+	if found {
+		handling.cancel()
+	}
+}
+
+// Notify is called to send a notification request over the connection.
+// It will return as soon as the notification has been sent, as no response is
+// possible.
+func (c *Conn) Notify(ctx context.Context, method string, params interface{}) (err error) {
+	jsonParams, err := marshalToRaw(params)
+	if err != nil {
+		return fmt.Errorf("marshalling notify parameters: %v", err)
+	}
+	request := &WireRequest{
+		Method: method,
+		Params: jsonParams,
+	}
+	data, err := json.Marshal(request)
+	if err != nil {
+		return fmt.Errorf("marshalling notify request: %v", err)
+	}
+	for _, h := range c.handlers {
+		ctx = h.Request(ctx, c, Send, request)
+	}
+	defer func() {
+		for _, h := range c.handlers {
+			h.Done(ctx, err)
+		}
+	}()
+	n, err := c.stream.Write(ctx, data)
+	for _, h := range c.handlers {
+		ctx = h.Wrote(ctx, n)
+	}
+	return err
+}
+
+// Call sends a request over the connection and then waits for a response.
+// If the response is not an error, it will be decoded into result.
+// result must be of a type you an pass to json.Unmarshal.
+func (c *Conn) Call(ctx context.Context, method string, params, result interface{}) (err error) {
+	// generate a new request identifier
+	id := ID{Number: atomic.AddInt64(&c.seq, 1)}
+	jsonParams, err := marshalToRaw(params)
+	if err != nil {
+		return fmt.Errorf("marshalling call parameters: %v", err)
+	}
+	request := &WireRequest{
+		ID:     &id,
+		Method: method,
+		Params: jsonParams,
+	}
+	// marshal the request now it is complete
+	data, err := json.Marshal(request)
+	if err != nil {
+		return fmt.Errorf("marshalling call request: %v", err)
+	}
+	for _, h := range c.handlers {
+		ctx = h.Request(ctx, c, Send, request)
+	}
+	// we have to add ourselves to the pending map before we send, otherwise we
+	// are racing the response
+	rchan := make(chan *WireResponse)
+	c.pendingMu.Lock()
+	c.pending[id] = rchan
+	c.pendingMu.Unlock()
+	defer func() {
+		// clean up the pending response handler on the way out
+		c.pendingMu.Lock()
+		delete(c.pending, id)
+		c.pendingMu.Unlock()
+		for _, h := range c.handlers {
+			h.Done(ctx, err)
+		}
+	}()
+	// now we are ready to send
+	n, err := c.stream.Write(ctx, data)
+	for _, h := range c.handlers {
+		ctx = h.Wrote(ctx, n)
+	}
+	if err != nil {
+		// sending failed, we will never get a response, so don't leave it pending
+		return err
+	}
+	// now wait for the response
+	select {
+	case response := <-rchan:
+		for _, h := range c.handlers {
+			ctx = h.Response(ctx, c, Receive, response)
+		}
+		// is it an error response?
+		if response.Error != nil {
+			return response.Error
+		}
+		if result == nil || response.Result == nil {
+			return nil
+		}
+		if err := json.Unmarshal(*response.Result, result); err != nil {
+			return fmt.Errorf("unmarshalling result: %v", err)
+		}
+		return nil
+	case <-ctx.Done():
+		// allow the handler to propagate the cancel
+		cancelled := false
+		for _, h := range c.handlers {
+			if h.Cancel(ctx, c, id, cancelled) {
+				cancelled = true
+			}
+		}
+		return ctx.Err()
+	}
+}
+
+// Conn returns the connection that created this request.
+func (r *Request) Conn() *Conn { return r.conn }
+
+// IsNotify returns true if this request is a notification.
+func (r *Request) IsNotify() bool {
+	return r.ID == nil
+}
+
+// Parallel indicates that the system is now allowed to process other requests
+// in parallel with this one.
+// It is safe to call any number of times, but must only be called from the
+// request handling go routine.
+// It is implied by both reply and by the handler returning.
+func (r *Request) Parallel() {
+	if r.state >= requestParallel {
+		return
+	}
+	r.state = requestParallel
+	close(r.nextRequest)
+}
+
+// Reply sends a reply to the given request.
+// It is an error to call this if request was not a call.
+// You must call this exactly once for any given request.
+// It should only be called from the handler go routine.
+// If err is set then result will be ignored.
+// If the request has not yet dropped into parallel mode
+// it will be before this function returns.
+func (r *Request) Reply(ctx context.Context, result interface{}, err error) error {
+	if r.state >= requestReplied {
+		return fmt.Errorf("reply invoked more than once")
+	}
+	if r.IsNotify() {
+		return fmt.Errorf("reply not invoked with a valid call")
+	}
+	// reply ends the handling phase of a call, so if we are not yet
+	// parallel we should be now. The go routine is allowed to continue
+	// to do work after replying, which is why it is important to unlock
+	// the rpc system at this point.
+	r.Parallel()
+	r.state = requestReplied
+
+	var raw *json.RawMessage
+	if err == nil {
+		raw, err = marshalToRaw(result)
+	}
+	response := &WireResponse{
+		Result: raw,
+		ID:     r.ID,
+	}
+	if err != nil {
+		if callErr, ok := err.(*Error); ok {
+			response.Error = callErr
+		} else {
+			response.Error = NewErrorf(0, "%s", err)
+		}
+	}
+	data, err := json.Marshal(response)
+	if err != nil {
+		return err
+	}
+	for _, h := range r.conn.handlers {
+		ctx = h.Response(ctx, r.conn, Send, response)
+	}
+	n, err := r.conn.stream.Write(ctx, data)
+	for _, h := range r.conn.handlers {
+		ctx = h.Wrote(ctx, n)
+	}
+
+	if err != nil {
+		// TODO(iancottrell): if a stream write fails, we really need to shut down
+		// the whole stream
+		return err
+	}
+	return nil
+}
+
+func (c *Conn) setHandling(r *Request, active bool) {
+	if r.ID == nil {
+		return
+	}
+	r.conn.handlingMu.Lock()
+	defer r.conn.handlingMu.Unlock()
+	if active {
+		r.conn.handling[*r.ID] = r
+	} else {
+		delete(r.conn.handling, *r.ID)
+	}
+}
+
+// combined has all the fields of both Request and Response.
+// We can decode this and then work out which it is.
+type combined struct {
+	VersionTag VersionTag       `json:"jsonrpc"`
+	ID         *ID              `json:"id,omitempty"`
+	Method     string           `json:"method"`
+	Params     *json.RawMessage `json:"params,omitempty"`
+	Result     *json.RawMessage `json:"result,omitempty"`
+	Error      *Error           `json:"error,omitempty"`
+}
+
+// Run blocks until the connection is terminated, and returns any error that
+// caused the termination.
+// It must be called exactly once for each Conn.
+// It returns only when the reader is closed or there is an error in the stream.
+func (c *Conn) Run(runCtx context.Context) error {
+	// we need to make the next request "lock" in an unlocked state to allow
+	// the first incoming request to proceed. All later requests are unlocked
+	// by the preceding request going to parallel mode.
+	nextRequest := make(chan struct{})
+	close(nextRequest)
+	for {
+		// get the data for a message
+		data, n, err := c.stream.Read(runCtx)
+		if err != nil {
+			// the stream failed, we cannot continue
+			return err
+		}
+		// read a combined message
+		msg := &combined{}
+		if err := json.Unmarshal(data, msg); err != nil {
+			// a badly formed message arrived, log it and continue
+			// we trust the stream to have isolated the error to just this message
+			for _, h := range c.handlers {
+				h.Error(runCtx, fmt.Errorf("unmarshal failed: %v", err))
+			}
+			continue
+		}
+		// work out which kind of message we have
+		switch {
+		case msg.Method != "":
+			// if method is set it must be a request
+			reqCtx, cancelReq := context.WithCancel(runCtx)
+			thisRequest := nextRequest
+			nextRequest = make(chan struct{})
+			req := &Request{
+				conn:        c,
+				cancel:      cancelReq,
+				nextRequest: nextRequest,
+				WireRequest: WireRequest{
+					VersionTag: msg.VersionTag,
+					Method:     msg.Method,
+					Params:     msg.Params,
+					ID:         msg.ID,
+				},
+			}
+			for _, h := range c.handlers {
+				reqCtx = h.Request(reqCtx, c, Receive, &req.WireRequest)
+				reqCtx = h.Read(reqCtx, n)
+			}
+			c.setHandling(req, true)
+			go func() {
+				<-thisRequest
+				req.state = requestSerial
+				defer func() {
+					c.setHandling(req, false)
+					if !req.IsNotify() && req.state < requestReplied {
+						req.Reply(reqCtx, nil, NewErrorf(CodeInternalError, "method %q did not reply", req.Method))
+					}
+					req.Parallel()
+					for _, h := range c.handlers {
+						h.Done(reqCtx, err)
+					}
+					cancelReq()
+				}()
+				delivered := false
+				for _, h := range c.handlers {
+					if h.Deliver(reqCtx, req, delivered) {
+						delivered = true
+					}
+				}
+			}()
+		case msg.ID != nil:
+			// we have a response, get the pending entry from the map
+			c.pendingMu.Lock()
+			rchan := c.pending[*msg.ID]
+			if rchan != nil {
+				delete(c.pending, *msg.ID)
+			}
+			c.pendingMu.Unlock()
+			// and send the reply to the channel
+			response := &WireResponse{
+				Result: msg.Result,
+				Error:  msg.Error,
+				ID:     msg.ID,
+			}
+			rchan <- response
+			close(rchan)
+		default:
+			for _, h := range c.handlers {
+				h.Error(runCtx, fmt.Errorf("message not a call, notify or response, ignoring"))
+			}
+		}
+	}
+}
+
+func marshalToRaw(obj interface{}) (*json.RawMessage, error) {
+	data, err := json.Marshal(obj)
+	if err != nil {
+		return nil, err
+	}
+	raw := json.RawMessage(data)
+	return &raw, nil
+}
diff --git a/utils/vscode/src/lsp/jsonrpc2/stream.go b/utils/vscode/src/lsp/jsonrpc2/stream.go
new file mode 100644
index 0000000..2c6ad6d
--- /dev/null
+++ b/utils/vscode/src/lsp/jsonrpc2/stream.go
@@ -0,0 +1,160 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package jsonrpc2
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// Stream abstracts the transport mechanics from the JSON RPC protocol.
+// A Conn reads and writes messages using the stream it was provided on
+// construction, and assumes that each call to Read or Write fully transfers
+// a single message, or returns an error.
+type Stream interface {
+	// Read gets the next message from the stream.
+	// It is never called concurrently.
+	Read(context.Context) ([]byte, int64, error)
+	// Write sends a message to the stream.
+	// It must be safe for concurrent use.
+	Write(context.Context, []byte) (int64, error)
+}
+
+// NewStream returns a Stream built on top of an io.Reader and io.Writer
+// The messages are sent with no wrapping, and rely on json decode consistency
+// to determine message boundaries.
+func NewStream(in io.Reader, out io.Writer) Stream {
+	return &plainStream{
+		in:  json.NewDecoder(in),
+		out: out,
+	}
+}
+
+type plainStream struct {
+	in    *json.Decoder
+	outMu sync.Mutex
+	out   io.Writer
+}
+
+func (s *plainStream) Read(ctx context.Context) ([]byte, int64, error) {
+	select {
+	case <-ctx.Done():
+		return nil, 0, ctx.Err()
+	default:
+	}
+	var raw json.RawMessage
+	if err := s.in.Decode(&raw); err != nil {
+		return nil, 0, err
+	}
+	return raw, int64(len(raw)), nil
+}
+
+func (s *plainStream) Write(ctx context.Context, data []byte) (int64, error) {
+	select {
+	case <-ctx.Done():
+		return 0, ctx.Err()
+	default:
+	}
+	s.outMu.Lock()
+	n, err := s.out.Write(data)
+	s.outMu.Unlock()
+	return int64(n), err
+}
+
+// NewHeaderStream returns a Stream built on top of an io.Reader and io.Writer
+// The messages are sent with HTTP content length and MIME type headers.
+// This is the format used by LSP and others.
+func NewHeaderStream(in io.Reader, out io.Writer) Stream {
+	return &headerStream{
+		in:  bufio.NewReader(in),
+		out: out,
+	}
+}
+
+type headerStream struct {
+	in    *bufio.Reader
+	outMu sync.Mutex
+	out   io.Writer
+}
+
+func (s *headerStream) Read(ctx context.Context) ([]byte, int64, error) {
+	select {
+	case <-ctx.Done():
+		return nil, 0, ctx.Err()
+	default:
+	}
+	var total, length int64
+	// read the header, stop on the first empty line
+	for {
+		line, err := s.in.ReadString('\n')
+		total += int64(len(line))
+		if err != nil {
+			return nil, total, fmt.Errorf("failed reading header line %q", err)
+		}
+		line = strings.TrimSpace(line)
+		// check we have a header line
+		if line == "" {
+			break
+		}
+		colon := strings.IndexRune(line, ':')
+		if colon < 0 {
+			return nil, total, fmt.Errorf("invalid header line %q", line)
+		}
+		name, value := line[:colon], strings.TrimSpace(line[colon+1:])
+		switch name {
+		case "Content-Length":
+			if length, err = strconv.ParseInt(value, 10, 32); err != nil {
+				return nil, total, fmt.Errorf("failed parsing Content-Length: %v", value)
+			}
+			if length <= 0 {
+				return nil, total, fmt.Errorf("invalid Content-Length: %v", length)
+			}
+		default:
+			// ignoring unknown headers
+		}
+	}
+	if length == 0 {
+		return nil, total, fmt.Errorf("missing Content-Length header")
+	}
+	data := make([]byte, length)
+	if _, err := io.ReadFull(s.in, data); err != nil {
+		return nil, total, err
+	}
+	total += length
+	return data, total, nil
+}
+
+func (s *headerStream) Write(ctx context.Context, data []byte) (int64, error) {
+	select {
+	case <-ctx.Done():
+		return 0, ctx.Err()
+	default:
+	}
+	s.outMu.Lock()
+	defer s.outMu.Unlock()
+	n, err := fmt.Fprintf(s.out, "Content-Length: %v\r\n\r\n", len(data))
+	total := int64(n)
+	if err == nil {
+		n, err = s.out.Write(data)
+		total += int64(n)
+	}
+	return total, err
+}
diff --git a/utils/vscode/src/lsp/jsonrpc2/wire.go b/utils/vscode/src/lsp/jsonrpc2/wire.go
new file mode 100644
index 0000000..3e31c34
--- /dev/null
+++ b/utils/vscode/src/lsp/jsonrpc2/wire.go
@@ -0,0 +1,148 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package jsonrpc2
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+)
+
+// this file contains the go forms of the wire specification
+// see http://www.jsonrpc.org/specification for details
+
+const (
+	// CodeUnknownError should be used for all non coded errors.
+	CodeUnknownError = -32001
+	// CodeParseError is used when invalid JSON was received by the server.
+	CodeParseError = -32700
+	//CodeInvalidRequest is used when the JSON sent is not a valid Request object.
+	CodeInvalidRequest = -32600
+	// CodeMethodNotFound should be returned by the handler when the method does
+	// not exist / is not available.
+	CodeMethodNotFound = -32601
+	// CodeInvalidParams should be returned by the handler when method
+	// parameter(s) were invalid.
+	CodeInvalidParams = -32602
+	// CodeInternalError is not currently returned but defined for completeness.
+	CodeInternalError = -32603
+
+	//CodeServerOverloaded is returned when a message was refused due to a
+	//server being temporarily unable to accept any new messages.
+	CodeServerOverloaded = -32000
+)
+
+// WireRequest is sent to a server to represent a Call or Notify operaton.
+type WireRequest struct {
+	// VersionTag is always encoded as the string "2.0"
+	VersionTag VersionTag `json:"jsonrpc"`
+	// Method is a string containing the method name to invoke.
+	Method string `json:"method"`
+	// Params is either a struct or an array with the parameters of the method.
+	Params *json.RawMessage `json:"params,omitempty"`
+	// The id of this request, used to tie the Response back to the request.
+	// Will be either a string or a number. If not set, the Request is a notify,
+	// and no response is possible.
+	ID *ID `json:"id,omitempty"`
+}
+
+// WireResponse is a reply to a Request.
+// It will always have the ID field set to tie it back to a request, and will
+// have either the Result or Error fields set depending on whether it is a
+// success or failure response.
+type WireResponse struct {
+	// VersionTag is always encoded as the string "2.0"
+	VersionTag VersionTag `json:"jsonrpc"`
+	// Result is the response value, and is required on success.
+	Result *json.RawMessage `json:"result,omitempty"`
+	// Error is a structured error response if the call fails.
+	Error *Error `json:"error,omitempty"`
+	// ID must be set and is the identifier of the Request this is a response to.
+	ID *ID `json:"id,omitempty"`
+}
+
+// Error represents a structured error in a Response.
+type Error struct {
+	// Code is an error code indicating the type of failure.
+	Code int64 `json:"code"`
+	// Message is a short description of the error.
+	Message string `json:"message"`
+	// Data is optional structured data containing additional information about the error.
+	Data *json.RawMessage `json:"data"`
+}
+
+// VersionTag is a special 0 sized struct that encodes as the jsonrpc version
+// tag.
+// It will fail during decode if it is not the correct version tag in the
+// stream.
+type VersionTag struct{}
+
+// ID is a Request identifier.
+// Only one of either the Name or Number members will be set, using the
+// number form if the Name is the empty string.
+type ID struct {
+	Name   string
+	Number int64
+}
+
+func (err *Error) Error() string {
+	if err == nil {
+		return ""
+	}
+	return err.Message
+}
+
+func (VersionTag) MarshalJSON() ([]byte, error) {
+	return json.Marshal("2.0")
+}
+
+func (VersionTag) UnmarshalJSON(data []byte) error {
+	version := ""
+	if err := json.Unmarshal(data, &version); err != nil {
+		return err
+	}
+	if version != "2.0" {
+		return fmt.Errorf("Invalid RPC version %v", version)
+	}
+	return nil
+}
+
+// String returns a string representation of the ID.
+// The representation is non ambiguous, string forms are quoted, number forms
+// are preceded by a #
+func (id *ID) String() string {
+	if id == nil {
+		return ""
+	}
+	if id.Name != "" {
+		return strconv.Quote(id.Name)
+	}
+	return "#" + strconv.FormatInt(id.Number, 10)
+}
+
+func (id *ID) MarshalJSON() ([]byte, error) {
+	if id.Name != "" {
+		return json.Marshal(id.Name)
+	}
+	return json.Marshal(id.Number)
+}
+
+func (id *ID) UnmarshalJSON(data []byte) error {
+	*id = ID{}
+	if err := json.Unmarshal(data, &id.Number); err == nil {
+		return nil
+	}
+	return json.Unmarshal(data, &id.Name)
+}
diff --git a/utils/vscode/src/lsp/protocol/context.go b/utils/vscode/src/lsp/protocol/context.go
new file mode 100644
index 0000000..7833d40
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/context.go
@@ -0,0 +1,29 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protocol
+
+import (
+	"context"
+)
+
+type contextKey int
+
+const (
+	clientKey = contextKey(iota)
+)
+
+func WithClient(ctx context.Context, client Client) context.Context {
+	return context.WithValue(ctx, clientKey, client)
+}
diff --git a/utils/vscode/src/lsp/protocol/doc.go b/utils/vscode/src/lsp/protocol/doc.go
new file mode 100644
index 0000000..3c9198d
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/doc.go
@@ -0,0 +1,26 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package protocol contains the structs that map directly to the wire format
+// of the "Language Server Protocol".
+//
+// It is a literal transcription, with unmodified comments, and only the changes
+// required to make it go code.
+// Names are uppercased to export them.
+// All fields have JSON tags added to correct the names.
+// Fields marked with a ? are also marked as "omitempty"
+// Fields that are "|| null" are made pointers
+// Fields that are string or number are left as string
+// Fields that are type "number" are made float64
+package protocol
diff --git a/utils/vscode/src/lsp/protocol/enums.go b/utils/vscode/src/lsp/protocol/enums.go
new file mode 100644
index 0000000..db76ca3
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/enums.go
@@ -0,0 +1,256 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protocol
+
+import (
+	"fmt"
+)
+
+var (
+	namesTextDocumentSyncKind   [int(Incremental) + 1]string
+	namesInitializeError        [int(UnknownProtocolVersion) + 1]string
+	namesMessageType            [int(Log) + 1]string
+	namesFileChangeType         [int(Deleted) + 1]string
+	namesWatchKind              [int(WatchDelete) + 1]string
+	namesCompletionTriggerKind  [int(TriggerForIncompleteCompletions) + 1]string
+	namesDiagnosticSeverity     [int(SeverityHint) + 1]string
+	namesDiagnosticTag          [int(Unnecessary) + 1]string
+	namesCompletionItemKind     [int(TypeParameterCompletion) + 1]string
+	namesInsertTextFormat       [int(SnippetTextFormat) + 1]string
+	namesDocumentHighlightKind  [int(Write) + 1]string
+	namesSymbolKind             [int(TypeParameter) + 1]string
+	namesTextDocumentSaveReason [int(FocusOut) + 1]string
+)
+
+func init() {
+	namesTextDocumentSyncKind[int(None)] = "None"
+	namesTextDocumentSyncKind[int(Full)] = "Full"
+	namesTextDocumentSyncKind[int(Incremental)] = "Incremental"
+
+	namesInitializeError[int(UnknownProtocolVersion)] = "UnknownProtocolVersion"
+
+	namesMessageType[int(Error)] = "Error"
+	namesMessageType[int(Warning)] = "Warning"
+	namesMessageType[int(Info)] = "Info"
+	namesMessageType[int(Log)] = "Log"
+
+	namesFileChangeType[int(Created)] = "Created"
+	namesFileChangeType[int(Changed)] = "Changed"
+	namesFileChangeType[int(Deleted)] = "Deleted"
+
+	namesWatchKind[int(WatchCreate)] = "WatchCreate"
+	namesWatchKind[int(WatchChange)] = "WatchChange"
+	namesWatchKind[int(WatchDelete)] = "WatchDelete"
+
+	namesCompletionTriggerKind[int(Invoked)] = "Invoked"
+	namesCompletionTriggerKind[int(TriggerCharacter)] = "TriggerCharacter"
+	namesCompletionTriggerKind[int(TriggerForIncompleteCompletions)] = "TriggerForIncompleteCompletions"
+
+	namesDiagnosticSeverity[int(SeverityError)] = "Error"
+	namesDiagnosticSeverity[int(SeverityWarning)] = "Warning"
+	namesDiagnosticSeverity[int(SeverityInformation)] = "Information"
+	namesDiagnosticSeverity[int(SeverityHint)] = "Hint"
+
+	namesDiagnosticTag[int(Unnecessary)] = "Unnecessary"
+
+	namesCompletionItemKind[int(TextCompletion)] = "text"
+	namesCompletionItemKind[int(MethodCompletion)] = "method"
+	namesCompletionItemKind[int(FunctionCompletion)] = "func"
+	namesCompletionItemKind[int(ConstructorCompletion)] = "constructor"
+	namesCompletionItemKind[int(FieldCompletion)] = "field"
+	namesCompletionItemKind[int(VariableCompletion)] = "var"
+	namesCompletionItemKind[int(ClassCompletion)] = "type"
+	namesCompletionItemKind[int(InterfaceCompletion)] = "interface"
+	namesCompletionItemKind[int(ModuleCompletion)] = "package"
+	namesCompletionItemKind[int(PropertyCompletion)] = "property"
+	namesCompletionItemKind[int(UnitCompletion)] = "unit"
+	namesCompletionItemKind[int(ValueCompletion)] = "value"
+	namesCompletionItemKind[int(EnumCompletion)] = "enum"
+	namesCompletionItemKind[int(KeywordCompletion)] = "keyword"
+	namesCompletionItemKind[int(SnippetCompletion)] = "snippet"
+	namesCompletionItemKind[int(ColorCompletion)] = "color"
+	namesCompletionItemKind[int(FileCompletion)] = "file"
+	namesCompletionItemKind[int(ReferenceCompletion)] = "reference"
+	namesCompletionItemKind[int(FolderCompletion)] = "folder"
+	namesCompletionItemKind[int(EnumMemberCompletion)] = "enumMember"
+	namesCompletionItemKind[int(ConstantCompletion)] = "const"
+	namesCompletionItemKind[int(StructCompletion)] = "struct"
+	namesCompletionItemKind[int(EventCompletion)] = "event"
+	namesCompletionItemKind[int(OperatorCompletion)] = "operator"
+	namesCompletionItemKind[int(TypeParameterCompletion)] = "typeParam"
+
+	namesInsertTextFormat[int(PlainTextTextFormat)] = "PlainText"
+	namesInsertTextFormat[int(SnippetTextFormat)] = "Snippet"
+
+	namesDocumentHighlightKind[int(Text)] = "Text"
+	namesDocumentHighlightKind[int(Read)] = "Read"
+	namesDocumentHighlightKind[int(Write)] = "Write"
+
+	namesSymbolKind[int(File)] = "File"
+	namesSymbolKind[int(Module)] = "Module"
+	namesSymbolKind[int(Namespace)] = "Namespace"
+	namesSymbolKind[int(Package)] = "Package"
+	namesSymbolKind[int(Class)] = "Class"
+	namesSymbolKind[int(Method)] = "Method"
+	namesSymbolKind[int(Property)] = "Property"
+	namesSymbolKind[int(Field)] = "Field"
+	namesSymbolKind[int(Constructor)] = "Constructor"
+	namesSymbolKind[int(Enum)] = "Enum"
+	namesSymbolKind[int(Interface)] = "Interface"
+	namesSymbolKind[int(Function)] = "Function"
+	namesSymbolKind[int(Variable)] = "Variable"
+	namesSymbolKind[int(Constant)] = "Constant"
+	namesSymbolKind[int(String)] = "String"
+	namesSymbolKind[int(Number)] = "Number"
+	namesSymbolKind[int(Boolean)] = "Boolean"
+	namesSymbolKind[int(Array)] = "Array"
+	namesSymbolKind[int(Object)] = "Object"
+	namesSymbolKind[int(Key)] = "Key"
+	namesSymbolKind[int(Null)] = "Null"
+	namesSymbolKind[int(EnumMember)] = "EnumMember"
+	namesSymbolKind[int(Struct)] = "Struct"
+	namesSymbolKind[int(Event)] = "Event"
+	namesSymbolKind[int(Operator)] = "Operator"
+	namesSymbolKind[int(TypeParameter)] = "TypeParameter"
+
+	namesTextDocumentSaveReason[int(Manual)] = "Manual"
+	namesTextDocumentSaveReason[int(AfterDelay)] = "AfterDelay"
+	namesTextDocumentSaveReason[int(FocusOut)] = "FocusOut"
+}
+
+func formatEnum(f fmt.State, c rune, i int, names []string, unknown string) {
+	s := ""
+	if i >= 0 && i < len(names) {
+		s = names[i]
+	}
+	if s != "" {
+		fmt.Fprint(f, s)
+	} else {
+		fmt.Fprintf(f, "%s(%d)", unknown, i)
+	}
+}
+
+func parseEnum(s string, names []string) int {
+	for i, name := range names {
+		if s == name {
+			return i
+		}
+	}
+	return 0
+}
+
+func (e TextDocumentSyncKind) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesTextDocumentSyncKind[:], "TextDocumentSyncKind")
+}
+
+func ParseTextDocumentSyncKind(s string) TextDocumentSyncKind {
+	return TextDocumentSyncKind(parseEnum(s, namesTextDocumentSyncKind[:]))
+}
+
+func (e InitializeError) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesInitializeError[:], "InitializeError")
+}
+
+func ParseInitializeError(s string) InitializeError {
+	return InitializeError(parseEnum(s, namesInitializeError[:]))
+}
+
+func (e MessageType) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesMessageType[:], "MessageType")
+}
+
+func ParseMessageType(s string) MessageType {
+	return MessageType(parseEnum(s, namesMessageType[:]))
+}
+
+func (e FileChangeType) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesFileChangeType[:], "FileChangeType")
+}
+
+func ParseFileChangeType(s string) FileChangeType {
+	return FileChangeType(parseEnum(s, namesFileChangeType[:]))
+}
+
+func (e WatchKind) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesWatchKind[:], "WatchKind")
+}
+
+func ParseWatchKind(s string) WatchKind {
+	return WatchKind(parseEnum(s, namesWatchKind[:]))
+}
+
+func (e CompletionTriggerKind) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesCompletionTriggerKind[:], "CompletionTriggerKind")
+}
+
+func ParseCompletionTriggerKind(s string) CompletionTriggerKind {
+	return CompletionTriggerKind(parseEnum(s, namesCompletionTriggerKind[:]))
+}
+
+func (e DiagnosticSeverity) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesDiagnosticSeverity[:], "DiagnosticSeverity")
+}
+
+func ParseDiagnosticSeverity(s string) DiagnosticSeverity {
+	return DiagnosticSeverity(parseEnum(s, namesDiagnosticSeverity[:]))
+}
+
+func (e DiagnosticTag) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesDiagnosticTag[:], "DiagnosticTag")
+}
+
+func ParseDiagnosticTag(s string) DiagnosticTag {
+	return DiagnosticTag(parseEnum(s, namesDiagnosticTag[:]))
+}
+
+func (e CompletionItemKind) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesCompletionItemKind[:], "CompletionItemKind")
+}
+
+func ParseCompletionItemKind(s string) CompletionItemKind {
+	return CompletionItemKind(parseEnum(s, namesCompletionItemKind[:]))
+}
+
+func (e InsertTextFormat) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesInsertTextFormat[:], "InsertTextFormat")
+}
+
+func ParseInsertTextFormat(s string) InsertTextFormat {
+	return InsertTextFormat(parseEnum(s, namesInsertTextFormat[:]))
+}
+
+func (e DocumentHighlightKind) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesDocumentHighlightKind[:], "DocumentHighlightKind")
+}
+
+func ParseDocumentHighlightKind(s string) DocumentHighlightKind {
+	return DocumentHighlightKind(parseEnum(s, namesDocumentHighlightKind[:]))
+}
+
+func (e SymbolKind) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesSymbolKind[:], "SymbolKind")
+}
+
+func ParseSymbolKind(s string) SymbolKind {
+	return SymbolKind(parseEnum(s, namesSymbolKind[:]))
+}
+
+func (e TextDocumentSaveReason) Format(f fmt.State, c rune) {
+	formatEnum(f, c, int(e), namesTextDocumentSaveReason[:], "TextDocumentSaveReason")
+}
+
+func ParseTextDocumentSaveReason(s string) TextDocumentSaveReason {
+	return TextDocumentSaveReason(parseEnum(s, namesTextDocumentSaveReason[:]))
+}
diff --git a/utils/vscode/src/lsp/protocol/log.go b/utils/vscode/src/lsp/protocol/log.go
new file mode 100644
index 0000000..f245881
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/log.go
@@ -0,0 +1,258 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protocol
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"time"
+
+	"../jsonrpc2"
+)
+
+type loggingStream struct {
+	stream jsonrpc2.Stream
+	log    io.Writer
+}
+
+// LoggingStream returns a stream that does LSP protocol logging too
+func LoggingStream(str jsonrpc2.Stream, w io.Writer) jsonrpc2.Stream {
+	return &loggingStream{str, w}
+}
+
+func (s *loggingStream) Read(ctx context.Context) ([]byte, int64, error) {
+	data, count, err := s.stream.Read(ctx)
+	if err == nil {
+		logIn(s.log, data)
+	}
+	return data, count, err
+}
+
+func (s *loggingStream) Write(ctx context.Context, data []byte) (int64, error) {
+	logOut(s.log, data)
+	count, err := s.stream.Write(ctx, data)
+	return count, err
+}
+
+// Combined has all the fields of both Request and Response.
+// We can decode this and then work out which it is.
+type Combined struct {
+	VersionTag jsonrpc2.VersionTag `json:"jsonrpc"`
+	ID         *jsonrpc2.ID        `json:"id,omitempty"`
+	Method     string              `json:"method"`
+	Params     *json.RawMessage    `json:"params,omitempty"`
+	Result     *json.RawMessage    `json:"result,omitempty"`
+	Error      *jsonrpc2.Error     `json:"error,omitempty"`
+}
+
+type req struct {
+	method string
+	start  time.Time
+}
+
+type mapped struct {
+	mu          sync.Mutex
+	clientCalls map[string]req
+	serverCalls map[string]req
+}
+
+var maps = &mapped{
+	sync.Mutex{},
+	make(map[string]req),
+	make(map[string]req),
+}
+
+// these 4 methods are each used exactly once, but it seemed
+// better to have the encapsulation rather than ad hoc mutex
+// code in 4 places
+func (m *mapped) client(id string, del bool) req {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	v := m.clientCalls[id]
+	if del {
+		delete(m.clientCalls, id)
+	}
+	return v
+}
+
+func (m *mapped) server(id string, del bool) req {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	v := m.serverCalls[id]
+	if del {
+		delete(m.serverCalls, id)
+	}
+	return v
+}
+
+func (m *mapped) setClient(id string, r req) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.clientCalls[id] = r
+}
+
+func (m *mapped) setServer(id string, r req) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.serverCalls[id] = r
+}
+
+const eor = "\r\n\r\n\r\n"
+
+func strID(x *jsonrpc2.ID) string {
+	if x == nil {
+		// should never happen, but we need a number
+		return "999999999"
+	}
+	if x.Name != "" {
+		return x.Name
+	}
+	return fmt.Sprintf("%d", x.Number)
+}
+
+func logCommon(outfd io.Writer, data []byte) (*Combined, time.Time, string) {
+	if outfd == nil {
+		return nil, time.Time{}, ""
+	}
+	var v Combined
+	err := json.Unmarshal(data, &v)
+	if err != nil {
+		fmt.Fprintf(outfd, "Unmarshal %v\n", err)
+		panic(err) // do better
+	}
+	tm := time.Now()
+	tmfmt := tm.Format("15:04:05.000 PM")
+	return &v, tm, tmfmt
+}
+
+// logOut and logIn could be combined. "received"<->"Sending", serverCalls<->clientCalls
+// but it wouldn't be a lot shorter or clearer and "shutdown" is a special case
+
+// Writing a message to the client, log it
+func logOut(outfd io.Writer, data []byte) {
+	v, tm, tmfmt := logCommon(outfd, data)
+	if v == nil {
+		return
+	}
+	if v.Error != nil {
+		id := strID(v.ID)
+		fmt.Fprintf(outfd, "[Error - %s] Received #%s %s%s", tmfmt, id, v.Error, eor)
+		return
+	}
+	buf := strings.Builder{}
+	id := strID(v.ID)
+	fmt.Fprintf(&buf, "[Trace - %s] ", tmfmt) // common beginning
+	if v.ID != nil && v.Method != "" && v.Params != nil {
+		fmt.Fprintf(&buf, "Received request '%s - (%s)'.\n", v.Method, id)
+		fmt.Fprintf(&buf, "Params: %s%s", *v.Params, eor)
+		maps.setServer(id, req{method: v.Method, start: tm})
+	} else if v.ID != nil && v.Method == "" && v.Params == nil {
+		cc := maps.client(id, true)
+		elapsed := tm.Sub(cc.start)
+		fmt.Fprintf(&buf, "Received response '%s - (%s)' in %dms.\n",
+			cc.method, id, elapsed/time.Millisecond)
+		if v.Result == nil {
+			fmt.Fprintf(&buf, "Result: {}%s", eor)
+		} else {
+			fmt.Fprintf(&buf, "Result: %s%s", string(*v.Result), eor)
+		}
+	} else if v.ID == nil && v.Method != "" && v.Params != nil {
+		p := "null"
+		if v.Params != nil {
+			p = string(*v.Params)
+		}
+		fmt.Fprintf(&buf, "Received notification '%s'.\n", v.Method)
+		fmt.Fprintf(&buf, "Params: %s%s", p, eor)
+	} else { // for completeness, as it should never happen
+		buf = strings.Builder{} // undo common Trace
+		fmt.Fprintf(&buf, "[Error - %s] on write ID?%v method:%q Params:%v Result:%v Error:%v%s",
+			tmfmt, v.ID != nil, v.Method, v.Params != nil,
+			v.Result != nil, v.Error != nil, eor)
+		p := "null"
+		if v.Params != nil {
+			p = string(*v.Params)
+		}
+		r := "null"
+		if v.Result != nil {
+			r = string(*v.Result)
+		}
+		fmt.Fprintf(&buf, "%s\n%s\n%s%s", p, r, v.Error, eor)
+	}
+	outfd.Write([]byte(buf.String()))
+}
+
+// Got a message from the client, log it
+func logIn(outfd io.Writer, data []byte) {
+	v, tm, tmfmt := logCommon(outfd, data)
+	if v == nil {
+		return
+	}
+	// ID Method Params => Sending request
+	// ID !Method Result(might be null, but !Params) => Sending response (could we get an Error?)
+	// !ID Method Params => Sending notification
+	if v.Error != nil { // does this ever happen?
+		id := strID(v.ID)
+		fmt.Fprintf(outfd, "[Error - %s] Sent #%s %s%s", tmfmt, id, v.Error, eor)
+		return
+	}
+	buf := strings.Builder{}
+	id := strID(v.ID)
+	fmt.Fprintf(&buf, "[Trace - %s] ", tmfmt) // common beginning
+	if v.ID != nil && v.Method != "" && (v.Params != nil || v.Method == "shutdown") {
+		fmt.Fprintf(&buf, "Sending request '%s - (%s)'.\n", v.Method, id)
+		x := "{}"
+		if v.Params != nil {
+			x = string(*v.Params)
+		}
+		fmt.Fprintf(&buf, "Params: %s%s", x, eor)
+		maps.setClient(id, req{method: v.Method, start: tm})
+	} else if v.ID != nil && v.Method == "" && v.Params == nil {
+		sc := maps.server(id, true)
+		elapsed := tm.Sub(sc.start)
+		fmt.Fprintf(&buf, "Sending response '%s - (%s)' took %dms.\n",
+			sc.method, id, elapsed/time.Millisecond)
+		if v.Result == nil {
+			fmt.Fprintf(&buf, "Result: {}%s", eor)
+		} else {
+			fmt.Fprintf(&buf, "Result: %s%s", string(*v.Result), eor)
+		}
+	} else if v.ID == nil && v.Method != "" {
+		p := "null"
+		if v.Params != nil {
+			p = string(*v.Params)
+		}
+		fmt.Fprintf(&buf, "Sending notification '%s'.\n", v.Method)
+		fmt.Fprintf(&buf, "Params: %s%s", p, eor)
+	} else { // for completeness, as it should never happen
+		buf = strings.Builder{} // undo common Trace
+		fmt.Fprintf(&buf, "[Error - %s] on read ID?%v method:%q Params:%v Result:%v Error:%v%s",
+			tmfmt, v.ID != nil, v.Method, v.Params != nil,
+			v.Result != nil, v.Error != nil, eor)
+		p := "null"
+		if v.Params != nil {
+			p = string(*v.Params)
+		}
+		r := "null"
+		if v.Result != nil {
+			r = string(*v.Result)
+		}
+		fmt.Fprintf(&buf, "%s\n%s\n%s%s", p, r, v.Error, eor)
+	}
+	outfd.Write([]byte(buf.String()))
+}
diff --git a/utils/vscode/src/lsp/protocol/protocol.go b/utils/vscode/src/lsp/protocol/protocol.go
new file mode 100644
index 0000000..e396c83
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/protocol.go
@@ -0,0 +1,86 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protocol
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+
+	"../jsonrpc2"
+)
+
+const (
+	// RequestCancelledError should be used when a request is cancelled early.
+	RequestCancelledError = -32800
+)
+
+type DocumentUri = string
+
+type canceller struct{ jsonrpc2.EmptyHandler }
+
+type clientHandler struct {
+	canceller
+	client Client
+}
+
+type serverHandler struct {
+	canceller
+	server Server
+}
+
+func (canceller) Request(ctx context.Context, conn *jsonrpc2.Conn, direction jsonrpc2.Direction, r *jsonrpc2.WireRequest) context.Context {
+	if direction == jsonrpc2.Receive && r.Method == "$/cancelRequest" {
+		var params CancelParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			log.Printf("%v", err)
+		} else {
+			conn.Cancel(params.ID)
+		}
+	}
+	return ctx
+}
+
+func (canceller) Cancel(ctx context.Context, conn *jsonrpc2.Conn, id jsonrpc2.ID, cancelled bool) bool {
+	if cancelled {
+		return false
+	}
+	conn.Notify(ctx, "$/cancelRequest", &CancelParams{ID: id})
+	return true
+}
+
+func NewClient(ctx context.Context, stream jsonrpc2.Stream, client Client) (context.Context, *jsonrpc2.Conn, Server) {
+	ctx = WithClient(ctx, client)
+	conn := jsonrpc2.NewConn(stream)
+	conn.AddHandler(&clientHandler{client: client})
+	return ctx, conn, &serverDispatcher{Conn: conn}
+}
+
+func NewServer(ctx context.Context, stream jsonrpc2.Stream, server Server) (context.Context, *jsonrpc2.Conn, Client) {
+	conn := jsonrpc2.NewConn(stream)
+	client := &clientDispatcher{Conn: conn}
+	ctx = WithClient(ctx, client)
+	conn.AddHandler(&serverHandler{server: server})
+	return ctx, conn, client
+}
+
+func sendParseError(ctx context.Context, req *jsonrpc2.Request, err error) {
+	if _, ok := err.(*jsonrpc2.Error); !ok {
+		err = jsonrpc2.NewErrorf(jsonrpc2.CodeParseError, "%v", err)
+	}
+	if err := req.Reply(ctx, nil, err); err != nil {
+		log.Printf("%v", err)
+	}
+}
diff --git a/utils/vscode/src/lsp/protocol/span.go b/utils/vscode/src/lsp/protocol/span.go
new file mode 100644
index 0000000..33cc2a6
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/span.go
@@ -0,0 +1,137 @@
+// Copyright 2018 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// this file contains protocol<->span converters
+
+package protocol
+
+import (
+	"fmt"
+
+	"../span"
+	errors "golang.org/x/xerrors"
+)
+
+type ColumnMapper struct {
+	URI       span.URI
+	Converter *span.TokenConverter
+	Content   []byte
+}
+
+func NewURI(uri span.URI) string {
+	return string(uri)
+}
+
+func (m *ColumnMapper) Location(s span.Span) (Location, error) {
+	rng, err := m.Range(s)
+	if err != nil {
+		return Location{}, err
+	}
+	return Location{URI: NewURI(s.URI()), Range: rng}, nil
+}
+
+func (m *ColumnMapper) Range(s span.Span) (Range, error) {
+	if span.CompareURI(m.URI, s.URI()) != 0 {
+		return Range{}, errors.Errorf("column mapper is for file %q instead of %q", m.URI, s.URI())
+	}
+	s, err := s.WithAll(m.Converter)
+	if err != nil {
+		return Range{}, err
+	}
+	start, err := m.Position(s.Start())
+	if err != nil {
+		return Range{}, err
+	}
+	end, err := m.Position(s.End())
+	if err != nil {
+		return Range{}, err
+	}
+	return Range{Start: start, End: end}, nil
+}
+
+func (m *ColumnMapper) Position(p span.Point) (Position, error) {
+	chr, err := span.ToUTF16Column(p, m.Content)
+	if err != nil {
+		return Position{}, err
+	}
+	return Position{
+		Line:      float64(p.Line() - 1),
+		Character: float64(chr - 1),
+	}, nil
+}
+
+func (m *ColumnMapper) Span(l Location) (span.Span, error) {
+	return m.RangeSpan(l.Range)
+}
+
+func (m *ColumnMapper) RangeSpan(r Range) (span.Span, error) {
+	start, err := m.Point(r.Start)
+	if err != nil {
+		return span.Span{}, err
+	}
+	end, err := m.Point(r.End)
+	if err != nil {
+		return span.Span{}, err
+	}
+	return span.New(m.URI, start, end).WithAll(m.Converter)
+}
+
+func (m *ColumnMapper) PointSpan(p Position) (span.Span, error) {
+	start, err := m.Point(p)
+	if err != nil {
+		return span.Span{}, err
+	}
+	return span.New(m.URI, start, start).WithAll(m.Converter)
+}
+
+func (m *ColumnMapper) Point(p Position) (span.Point, error) {
+	line := int(p.Line) + 1
+	offset, err := m.Converter.ToOffset(line, 1)
+	if err != nil {
+		return span.Point{}, err
+	}
+	lineStart := span.NewPoint(line, 1, offset)
+	return span.FromUTF16Column(lineStart, int(p.Character)+1, m.Content)
+}
+
+func IsPoint(r Range) bool {
+	return r.Start.Line == r.End.Line && r.Start.Character == r.End.Character
+}
+
+func CompareRange(a, b Range) int {
+	if r := ComparePosition(a.Start, b.Start); r != 0 {
+		return r
+	}
+	return ComparePosition(a.End, b.End)
+}
+
+func ComparePosition(a, b Position) int {
+	if a.Line < b.Line {
+		return -1
+	}
+	if a.Line > b.Line {
+		return 1
+	}
+	if a.Character < b.Character {
+		return -1
+	}
+	if a.Character > b.Character {
+		return 1
+	}
+	return 0
+}
+
+func (r Range) Format(f fmt.State, _ rune) {
+	fmt.Fprintf(f, "%v:%v-%v:%v", r.Start.Line, r.Start.Character, r.End.Line, r.End.Character)
+}
diff --git a/utils/vscode/src/lsp/protocol/tsclient.go b/utils/vscode/src/lsp/protocol/tsclient.go
new file mode 100644
index 0000000..2f9beef
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/tsclient.go
@@ -0,0 +1,221 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protocol
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+
+	"../jsonrpc2"
+)
+
+type Client interface {
+	ShowMessage(context.Context, *ShowMessageParams) error
+	LogMessage(context.Context, *LogMessageParams) error
+	Event(context.Context, *interface{}) error
+	PublishDiagnostics(context.Context, *PublishDiagnosticsParams) error
+	WorkspaceFolders(context.Context) ([]WorkspaceFolder, error)
+	Configuration(context.Context, *ParamConfig) ([]interface{}, error)
+	RegisterCapability(context.Context, *RegistrationParams) error
+	UnregisterCapability(context.Context, *UnregistrationParams) error
+	ShowMessageRequest(context.Context, *ShowMessageRequestParams) (*MessageActionItem, error)
+	ApplyEdit(context.Context, *ApplyWorkspaceEditParams) (*ApplyWorkspaceEditResponse, error)
+}
+
+func (h clientHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, delivered bool) bool {
+	if delivered {
+		return false
+	}
+	if ctx.Err() != nil {
+		r.Reply(ctx, nil, jsonrpc2.NewErrorf(RequestCancelledError, ""))
+		return true
+	}
+	switch r.Method {
+	case "window/showMessage": // notif
+		var params ShowMessageParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.client.ShowMessage(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "window/logMessage": // notif
+		var params LogMessageParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.client.LogMessage(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "telemetry/event": // notif
+		var params interface{}
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.client.Event(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/publishDiagnostics": // notif
+		var params PublishDiagnosticsParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.client.PublishDiagnostics(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/workspaceFolders": // req
+		if r.Params != nil {
+			r.Reply(ctx, nil, jsonrpc2.NewErrorf(jsonrpc2.CodeInvalidParams, "Expected no params"))
+			return true
+		}
+		resp, err := h.client.WorkspaceFolders(ctx)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/configuration": // req
+		var params ParamConfig
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.client.Configuration(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "client/registerCapability": // req
+		var params RegistrationParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		err := h.client.RegisterCapability(ctx, &params)
+		if err := r.Reply(ctx, nil, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "client/unregisterCapability": // req
+		var params UnregistrationParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		err := h.client.UnregisterCapability(ctx, &params)
+		if err := r.Reply(ctx, nil, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "window/showMessageRequest": // req
+		var params ShowMessageRequestParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.client.ShowMessageRequest(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/applyEdit": // req
+		var params ApplyWorkspaceEditParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.client.ApplyEdit(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+
+	default:
+		return false
+	}
+}
+
+type clientDispatcher struct {
+	*jsonrpc2.Conn
+}
+
+func (s *clientDispatcher) ShowMessage(ctx context.Context, params *ShowMessageParams) error {
+	return s.Conn.Notify(ctx, "window/showMessage", params)
+}
+
+func (s *clientDispatcher) LogMessage(ctx context.Context, params *LogMessageParams) error {
+	return s.Conn.Notify(ctx, "window/logMessage", params)
+}
+
+func (s *clientDispatcher) Event(ctx context.Context, params *interface{}) error {
+	return s.Conn.Notify(ctx, "telemetry/event", params)
+}
+
+func (s *clientDispatcher) PublishDiagnostics(ctx context.Context, params *PublishDiagnosticsParams) error {
+	return s.Conn.Notify(ctx, "textDocument/publishDiagnostics", params)
+}
+func (s *clientDispatcher) WorkspaceFolders(ctx context.Context) ([]WorkspaceFolder, error) {
+	var result []WorkspaceFolder
+	if err := s.Conn.Call(ctx, "workspace/workspaceFolders", nil, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *clientDispatcher) Configuration(ctx context.Context, params *ParamConfig) ([]interface{}, error) {
+	var result []interface{}
+	if err := s.Conn.Call(ctx, "workspace/configuration", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *clientDispatcher) RegisterCapability(ctx context.Context, params *RegistrationParams) error {
+	return s.Conn.Call(ctx, "client/registerCapability", params, nil) // Call, not Notify
+}
+
+func (s *clientDispatcher) UnregisterCapability(ctx context.Context, params *UnregistrationParams) error {
+	return s.Conn.Call(ctx, "client/unregisterCapability", params, nil) // Call, not Notify
+}
+
+func (s *clientDispatcher) ShowMessageRequest(ctx context.Context, params *ShowMessageRequestParams) (*MessageActionItem, error) {
+	var result MessageActionItem
+	if err := s.Conn.Call(ctx, "window/showMessageRequest", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *clientDispatcher) ApplyEdit(ctx context.Context, params *ApplyWorkspaceEditParams) (*ApplyWorkspaceEditResponse, error) {
+	var result ApplyWorkspaceEditResponse
+	if err := s.Conn.Call(ctx, "workspace/applyEdit", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+// Types constructed to avoid structs as formal argument types
+type ParamConfig struct {
+	ConfigurationParams
+	PartialResultParams
+}
diff --git a/utils/vscode/src/lsp/protocol/tsprotocol.go b/utils/vscode/src/lsp/protocol/tsprotocol.go
new file mode 100644
index 0000000..50543fc
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/tsprotocol.go
@@ -0,0 +1,4630 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package protocol contains data types and code for LSP jsonrpcs
+// generated automatically from vscode-languageserver-node
+// commit: 36ac51f057215e6e2e0408384e07ecf564a938da
+// last fetched Tue Sep 24 2019 17:44:28 GMT-0400 (Eastern Daylight Time)
+package protocol
+
+// Code generated (see typescript/README.md) DO NOT EDIT.
+
+/*ImplementationClientCapabilities defined:
+ * Since 3.6.0
+ */
+type ImplementationClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether implementation supports dynamic registration. If this is set to `true`
+	 * the client supports the new `ImplementationRegistrationOptions` return value
+	 * for the corresponding server capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*LinkSupport defined:
+	 * The client supports additional metadata in the form of definition links.
+	 *
+	 * Since 3.14.0
+	 */
+	LinkSupport bool `json:"linkSupport,omitempty"`
+}
+
+// ImplementationOptions is
+type ImplementationOptions struct {
+	WorkDoneProgressOptions
+}
+
+// ImplementationRegistrationOptions is
+type ImplementationRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	ImplementationOptions
+	StaticRegistrationOptions
+}
+
+// ImplementationParams is
+type ImplementationParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*TypeDefinitionClientCapabilities defined:
+ * Since 3.6.0
+ */
+type TypeDefinitionClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether implementation supports dynamic registration. If this is set to `true`
+	 * the client supports the new `TypeDefinitionRegistrationOptions` return value
+	 * for the corresponding server capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*LinkSupport defined:
+	 * The client supports additional metadata in the form of definition links.
+	 *
+	 * Since 3.14.0
+	 */
+	LinkSupport bool `json:"linkSupport,omitempty"`
+}
+
+// TypeDefinitionOptions is
+type TypeDefinitionOptions struct {
+	WorkDoneProgressOptions
+}
+
+// TypeDefinitionRegistrationOptions is
+type TypeDefinitionRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	TypeDefinitionOptions
+	StaticRegistrationOptions
+}
+
+// TypeDefinitionParams is
+type TypeDefinitionParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+// WorkspaceFoldersInitializeParams is
+type WorkspaceFoldersInitializeParams struct {
+
+	/*WorkspaceFolders defined:
+	 * The actual configured workspace folders.
+	 */
+	WorkspaceFolders []WorkspaceFolder `json:"workspaceFolders"`
+}
+
+// WorkspaceFoldersClientCapabilities is
+type WorkspaceFoldersClientCapabilities struct {
+
+	/*Workspace defined:
+	 * The workspace client capabilities
+	 */
+	Workspace *struct {
+
+		/*WorkspaceFolders defined:
+		 * The client has support for workspace folders
+		 */
+		WorkspaceFolders bool `json:"workspaceFolders,omitempty"`
+	} `json:"workspace,omitempty"`
+}
+
+// WorkspaceFoldersServerCapabilities is
+type WorkspaceFoldersServerCapabilities struct {
+
+	/*Workspace defined:
+	 * The workspace server capabilities
+	 */
+	Workspace *struct {
+
+		// WorkspaceFolders is
+		WorkspaceFolders *struct {
+
+			/*Supported defined:
+			 * The Server has support for workspace folders
+			 */
+			Supported bool `json:"supported,omitempty"`
+
+			/*ChangeNotifications defined:
+			 * Whether the server wants to receive workspace folder
+			 * change notifications.
+			 *
+			 * If a strings is provided the string is treated as a ID
+			 * under which the notification is registed on the client
+			 * side. The ID can be used to unregister for these events
+			 * using the `client/unregisterCapability` request.
+			 */
+			ChangeNotifications string `json:"changeNotifications,omitempty"` // string | boolean
+		} `json:"workspaceFolders,omitempty"`
+	} `json:"workspace,omitempty"`
+}
+
+// WorkspaceFolder is
+type WorkspaceFolder struct {
+
+	/*URI defined:
+	 * The associated URI for this workspace folder.
+	 */
+	URI string `json:"uri"`
+
+	/*Name defined:
+	 * The name of the workspace folder. Used to refer to this
+	 * workspace folder in thge user interface.
+	 */
+	Name string `json:"name"`
+}
+
+/*DidChangeWorkspaceFoldersParams defined:
+ * The parameters of a `workspace/didChangeWorkspaceFolders` notification.
+ */
+type DidChangeWorkspaceFoldersParams struct {
+
+	/*Event defined:
+	 * The actual workspace folder change event.
+	 */
+	Event WorkspaceFoldersChangeEvent `json:"event"`
+}
+
+/*WorkspaceFoldersChangeEvent defined:
+ * The workspace folder change event.
+ */
+type WorkspaceFoldersChangeEvent struct {
+
+	/*Added defined:
+	 * The array of added workspace folders
+	 */
+	Added []WorkspaceFolder `json:"added"`
+
+	/*Removed defined:
+	 * The array of the removed workspace folders
+	 */
+	Removed []WorkspaceFolder `json:"removed"`
+}
+
+// ConfigurationClientCapabilities is
+type ConfigurationClientCapabilities struct {
+
+	/*Workspace defined:
+	 * The workspace client capabilities
+	 */
+	Workspace *struct {
+
+		/*Configuration defined:
+		* The client supports `workspace/configuration` requests.
+		 */
+		Configuration bool `json:"configuration,omitempty"`
+	} `json:"workspace,omitempty"`
+}
+
+// ConfigurationItem is
+type ConfigurationItem struct {
+
+	/*ScopeURI defined:
+	 * The scope to get the configuration section for.
+	 */
+	ScopeURI string `json:"scopeUri,omitempty"`
+
+	/*Section defined:
+	 * The configuration section asked for.
+	 */
+	Section string `json:"section,omitempty"`
+}
+
+/*ConfigurationParams defined:
+ * The parameters of a configuration request.
+ */
+type ConfigurationParams struct {
+
+	// Items is
+	Items []ConfigurationItem `json:"items"`
+}
+
+// DocumentColorClientCapabilities is
+type DocumentColorClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether implementation supports dynamic registration. If this is set to `true`
+	 * the client supports the new `DocumentColorRegistrationOptions` return value
+	 * for the corresponding server capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+// DocumentColorOptions is
+type DocumentColorOptions struct {
+
+	/*ResolveProvider defined:
+	 * Code lens has a resolve provider as well.
+	 */
+	ResolveProvider bool `json:"resolveProvider,omitempty"`
+	WorkDoneProgressOptions
+}
+
+// DocumentColorRegistrationOptions is
+type DocumentColorRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	StaticRegistrationOptions
+	DocumentColorOptions
+}
+
+/*DocumentColorParams defined:
+ * Parameters for a [DocumentColorRequest](#DocumentColorRequest).
+ */
+type DocumentColorParams struct {
+
+	/*TextDocument defined:
+	 * The text document.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*ColorPresentationParams defined:
+ * Parameters for a [ColorPresentationRequest](#ColorPresentationRequest).
+ */
+type ColorPresentationParams struct {
+
+	/*TextDocument defined:
+	 * The text document.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Color defined:
+	 * The color to request presentations for.
+	 */
+	Color Color `json:"color"`
+
+	/*Range defined:
+	 * The range where the color would be inserted. Serves as a context.
+	 */
+	Range Range `json:"range"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+// FoldingRangeClientCapabilities is
+type FoldingRangeClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether implementation supports dynamic registration for folding range providers. If this is set to `true`
+	 * the client supports the new `FoldingRangeRegistrationOptions` return value for the corresponding server
+	 * capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*RangeLimit defined:
+	 * The maximum number of folding ranges that the client prefers to receive per document. The value serves as a
+	 * hint, servers are free to follow the limit.
+	 */
+	RangeLimit float64 `json:"rangeLimit,omitempty"`
+
+	/*LineFoldingOnly defined:
+	 * If set, the client signals that it only supports folding complete lines. If set, client will
+	 * ignore specified `startCharacter` and `endCharacter` properties in a FoldingRange.
+	 */
+	LineFoldingOnly bool `json:"lineFoldingOnly,omitempty"`
+}
+
+// FoldingRangeOptions is
+type FoldingRangeOptions struct {
+	WorkDoneProgressOptions
+}
+
+// FoldingRangeRegistrationOptions is
+type FoldingRangeRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	FoldingRangeOptions
+	StaticRegistrationOptions
+}
+
+/*FoldingRange defined:
+ * Represents a folding range.
+ */
+type FoldingRange struct {
+
+	/*StartLine defined:
+	 * The zero-based line number from where the folded range starts.
+	 */
+	StartLine float64 `json:"startLine"`
+
+	/*StartCharacter defined:
+	 * The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.
+	 */
+	StartCharacter float64 `json:"startCharacter,omitempty"`
+
+	/*EndLine defined:
+	 * The zero-based line number where the folded range ends.
+	 */
+	EndLine float64 `json:"endLine"`
+
+	/*EndCharacter defined:
+	 * The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.
+	 */
+	EndCharacter float64 `json:"endCharacter,omitempty"`
+
+	/*Kind defined:
+	 * Describes the kind of the folding range such as `comment' or 'region'. The kind
+	 * is used to categorize folding ranges and used by commands like 'Fold all comments'. See
+	 * [FoldingRangeKind](#FoldingRangeKind) for an enumeration of standardized kinds.
+	 */
+	Kind string `json:"kind,omitempty"`
+}
+
+/*FoldingRangeParams defined:
+ * Parameters for a [FoldingRangeRequest](#FoldingRangeRequest).
+ */
+type FoldingRangeParams struct {
+
+	/*TextDocument defined:
+	 * The text document.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*DeclarationClientCapabilities defined:
+ * Since 3.14.0
+ */
+type DeclarationClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether declaration supports dynamic registration. If this is set to `true`
+	 * the client supports the new `DeclarationRegistrationOptions` return value
+	 * for the corresponding server capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*LinkSupport defined:
+	 * The client supports additional metadata in the form of declaration links.
+	 */
+	LinkSupport bool `json:"linkSupport,omitempty"`
+}
+
+// DeclarationOptions is
+type DeclarationOptions struct {
+	WorkDoneProgressOptions
+}
+
+// DeclarationRegistrationOptions is
+type DeclarationRegistrationOptions struct {
+	DeclarationOptions
+	TextDocumentRegistrationOptions
+	StaticRegistrationOptions
+}
+
+// DeclarationParams is
+type DeclarationParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+// SelectionRangeClientCapabilities is
+type SelectionRangeClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
+	 * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server
+	 * capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+// SelectionRangeOptions is
+type SelectionRangeOptions struct {
+	WorkDoneProgressOptions
+}
+
+// SelectionRangeRegistrationOptions is
+type SelectionRangeRegistrationOptions struct {
+	SelectionRangeOptions
+	TextDocumentRegistrationOptions
+	StaticRegistrationOptions
+}
+
+/*SelectionRangeParams defined:
+ * A parameter literal used in selection range requests.
+ */
+type SelectionRangeParams struct {
+
+	/*TextDocument defined:
+	 * The text document.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Positions defined:
+	 * The positions inside the text document.
+	 */
+	Positions []Position `json:"positions"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*Registration defined:
+ * General parameters to to register for an notification or to register a provider.
+ */
+type Registration struct {
+
+	/*ID defined:
+	 * The id used to register the request. The id can be used to deregister
+	 * the request again.
+	 */
+	ID string `json:"id"`
+
+	/*Method defined:
+	 * The method to register for.
+	 */
+	Method string `json:"method"`
+
+	/*RegisterOptions defined:
+	 * Options necessary for the registration.
+	 */
+	RegisterOptions interface{} `json:"registerOptions,omitempty"`
+}
+
+// RegistrationParams is
+type RegistrationParams struct {
+
+	// Registrations is
+	Registrations []Registration `json:"registrations"`
+}
+
+/*Unregistration defined:
+ * General parameters to unregister a request or notification.
+ */
+type Unregistration struct {
+
+	/*ID defined:
+	 * The id used to unregister the request or notification. Usually an id
+	 * provided during the register request.
+	 */
+	ID string `json:"id"`
+
+	/*Method defined:
+	 * The method to unregister for.
+	 */
+	Method string `json:"method"`
+}
+
+// UnregistrationParams is
+type UnregistrationParams struct {
+
+	// Unregisterations is
+	Unregisterations []Unregistration `json:"unregisterations"`
+}
+
+// WorkDoneProgressParams is
+type WorkDoneProgressParams struct {
+
+	/*WorkDoneToken defined:
+	 * An optional token that a server can use to report work done progress.
+	 */
+	WorkDoneToken *ProgressToken `json:"workDoneToken,omitempty"`
+}
+
+// PartialResultParams is
+type PartialResultParams struct {
+
+	/*PartialResultToken defined:
+	 * An optional token that a server can use to report partial results (e.g. streaming) to
+	 * the client.
+	 */
+	PartialResultToken *ProgressToken `json:"partialResultToken,omitempty"`
+}
+
+/*TextDocumentPositionParams defined:
+ * A parameter literal used in requests to pass a text document and a position inside that
+ * document.
+ */
+type TextDocumentPositionParams struct {
+
+	/*TextDocument defined:
+	 * The text document.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Position defined:
+	 * The position inside the text document.
+	 */
+	Position Position `json:"position"`
+}
+
+/*WorkspaceClientCapabilities defined:
+ * Workspace specific client capabilities.
+ */
+type WorkspaceClientCapabilities struct {
+
+	/*ApplyEdit defined:
+	 * The client supports applying batch edits
+	 * to the workspace by supporting the request
+	 * 'workspace/applyEdit'
+	 */
+	ApplyEdit bool `json:"applyEdit,omitempty"`
+
+	/*WorkspaceEdit defined:
+	 * Capabilities specific to `WorkspaceEdit`s
+	 */
+	WorkspaceEdit *WorkspaceEditClientCapabilities `json:"workspaceEdit,omitempty"`
+
+	/*DidChangeConfiguration defined:
+	 * Capabilities specific to the `workspace/didChangeConfiguration` notification.
+	 */
+	DidChangeConfiguration *DidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitempty"`
+
+	/*DidChangeWatchedFiles defined:
+	 * Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
+	 */
+	DidChangeWatchedFiles *DidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitempty"`
+
+	/*Symbol defined:
+	 * Capabilities specific to the `workspace/symbol` request.
+	 */
+	Symbol *WorkspaceSymbolClientCapabilities `json:"symbol,omitempty"`
+
+	/*ExecuteCommand defined:
+	 * Capabilities specific to the `workspace/executeCommand` request.
+	 */
+	ExecuteCommand *ExecuteCommandClientCapabilities `json:"executeCommand,omitempty"`
+}
+
+/*TextDocumentClientCapabilities defined:
+ * Text document specific client capabilities.
+ */
+type TextDocumentClientCapabilities struct {
+
+	/*Synchronization defined:
+	 * Defines which synchronization capabilities the client supports.
+	 */
+	Synchronization *TextDocumentSyncClientCapabilities `json:"synchronization,omitempty"`
+
+	/*Completion defined:
+	 * Capabilities specific to the `textDocument/completion`
+	 */
+	Completion *CompletionClientCapabilities `json:"completion,omitempty"`
+
+	/*Hover defined:
+	 * Capabilities specific to the `textDocument/hover`
+	 */
+	Hover *HoverClientCapabilities `json:"hover,omitempty"`
+
+	/*SignatureHelp defined:
+	 * Capabilities specific to the `textDocument/signatureHelp`
+	 */
+	SignatureHelp *SignatureHelpClientCapabilities `json:"signatureHelp,omitempty"`
+
+	/*Declaration defined:
+	 * Capabilities specific to the `textDocument/declaration`
+	 *
+	 * @since 3.14.0
+	 */
+	Declaration *DeclarationClientCapabilities `json:"declaration,omitempty"`
+
+	/*Definition defined:
+	 * Capabilities specific to the `textDocument/definition`
+	 */
+	Definition *DefinitionClientCapabilities `json:"definition,omitempty"`
+
+	/*TypeDefinition defined:
+	 * Capabilities specific to the `textDocument/typeDefinition`
+	 *
+	 * @since 3.6.0
+	 */
+	TypeDefinition *TypeDefinitionClientCapabilities `json:"typeDefinition,omitempty"`
+
+	/*Implementation defined:
+	 * Capabilities specific to the `textDocument/implementation`
+	 *
+	 * @since 3.6.0
+	 */
+	Implementation *ImplementationClientCapabilities `json:"implementation,omitempty"`
+
+	/*References defined:
+	 * Capabilities specific to the `textDocument/references`
+	 */
+	References *ReferenceClientCapabilities `json:"references,omitempty"`
+
+	/*DocumentHighlight defined:
+	 * Capabilities specific to the `textDocument/documentHighlight`
+	 */
+	DocumentHighlight *DocumentHighlightClientCapabilities `json:"documentHighlight,omitempty"`
+
+	/*DocumentSymbol defined:
+	 * Capabilities specific to the `textDocument/documentSymbol`
+	 */
+	DocumentSymbol *DocumentSymbolClientCapabilities `json:"documentSymbol,omitempty"`
+
+	/*CodeAction defined:
+	 * Capabilities specific to the `textDocument/codeAction`
+	 */
+	CodeAction *CodeActionClientCapabilities `json:"codeAction,omitempty"`
+
+	/*CodeLens defined:
+	 * Capabilities specific to the `textDocument/codeLens`
+	 */
+	CodeLens *CodeLensClientCapabilities `json:"codeLens,omitempty"`
+
+	/*DocumentLink defined:
+	 * Capabilities specific to the `textDocument/documentLink`
+	 */
+	DocumentLink *DocumentLinkClientCapabilities `json:"documentLink,omitempty"`
+
+	/*ColorProvider defined:
+	 * Capabilities specific to the `textDocument/documentColor`
+	 */
+	ColorProvider *DocumentColorClientCapabilities `json:"colorProvider,omitempty"`
+
+	/*Formatting defined:
+	 * Capabilities specific to the `textDocument/formatting`
+	 */
+	Formatting *DocumentFormattingClientCapabilities `json:"formatting,omitempty"`
+
+	/*RangeFormatting defined:
+	 * Capabilities specific to the `textDocument/rangeFormatting`
+	 */
+	RangeFormatting *DocumentRangeFormattingClientCapabilities `json:"rangeFormatting,omitempty"`
+
+	/*OnTypeFormatting defined:
+	 * Capabilities specific to the `textDocument/onTypeFormatting`
+	 */
+	OnTypeFormatting *DocumentOnTypeFormattingClientCapabilities `json:"onTypeFormatting,omitempty"`
+
+	/*Rename defined:
+	 * Capabilities specific to the `textDocument/rename`
+	 */
+	Rename *RenameClientCapabilities `json:"rename,omitempty"`
+
+	/*FoldingRange defined:
+	 * Capabilities specific to `textDocument/foldingRange` requests.
+	 *
+	 * @since 3.10.0
+	 */
+	FoldingRange *FoldingRangeClientCapabilities `json:"foldingRange,omitempty"`
+
+	/*SelectionRange defined:
+	 * Capabilities specific to `textDocument/selectionRange` requests
+	 *
+	 * @since 3.15.0
+	 */
+	SelectionRange *SelectionRangeClientCapabilities `json:"selectionRange,omitempty"`
+
+	/*PublishDiagnostics defined:
+	 * Capabilities specific to `textDocument/publishDiagnostics`.
+	 */
+	PublishDiagnostics *PublishDiagnosticsClientCapabilities `json:"publishDiagnostics,omitempty"`
+}
+
+/*InnerClientCapabilities defined:
+ * Defines the capabilities provided by the client.
+ */
+type InnerClientCapabilities struct {
+
+	/*Workspace defined:
+	 * Workspace specific client capabilities.
+	 */
+	Workspace *WorkspaceClientCapabilities `json:"workspace,omitempty"`
+
+	/*TextDocument defined:
+	 * Text document specific client capabilities.
+	 */
+	TextDocument *TextDocumentClientCapabilities `json:"textDocument,omitempty"`
+
+	/*Window defined:
+	 * Window specific client capabilities.
+	 */
+	Window interface{} `json:"window,omitempty"`
+
+	/*Experimental defined:
+	 * Experimental client capabilities.
+	 */
+	Experimental interface{} `json:"experimental,omitempty"`
+}
+
+// ClientCapabilities is
+type ClientCapabilities struct {
+
+	/*Workspace defined:
+	 * Workspace specific client capabilities.
+	 */
+	Workspace struct {
+
+		/*ApplyEdit defined:
+		 * The client supports applying batch edits
+		 * to the workspace by supporting the request
+		 * 'workspace/applyEdit'
+		 */
+		ApplyEdit bool `json:"applyEdit,omitempty"`
+
+		/*WorkspaceEdit defined:
+		 * Capabilities specific to `WorkspaceEdit`s
+		 */
+		WorkspaceEdit WorkspaceEditClientCapabilities `json:"workspaceEdit,omitempty"`
+
+		/*DidChangeConfiguration defined:
+		 * Capabilities specific to the `workspace/didChangeConfiguration` notification.
+		 */
+		DidChangeConfiguration DidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitempty"`
+
+		/*DidChangeWatchedFiles defined:
+		 * Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
+		 */
+		DidChangeWatchedFiles DidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitempty"`
+
+		/*Symbol defined:
+		 * Capabilities specific to the `workspace/symbol` request.
+		 */
+		Symbol WorkspaceSymbolClientCapabilities `json:"symbol,omitempty"`
+
+		/*ExecuteCommand defined:
+		 * Capabilities specific to the `workspace/executeCommand` request.
+		 */
+		ExecuteCommand ExecuteCommandClientCapabilities `json:"executeCommand,omitempty"`
+
+		/*WorkspaceFolders defined:
+		 * The client has support for workspace folders
+		 */
+		WorkspaceFolders bool `json:"workspaceFolders,omitempty"`
+
+		/*Configuration defined:
+		* The client supports `workspace/configuration` requests.
+		 */
+		Configuration bool `json:"configuration,omitempty"`
+	} `json:"workspace,omitempty"`
+
+	/*TextDocument defined:
+	 * Text document specific client capabilities.
+	 */
+	TextDocument TextDocumentClientCapabilities `json:"textDocument,omitempty"`
+
+	/*Window defined:
+	 * Window specific client capabilities.
+	 */
+	Window interface{} `json:"window,omitempty"`
+
+	/*Experimental defined:
+	 * Experimental client capabilities.
+	 */
+	Experimental interface{} `json:"experimental,omitempty"`
+
+	/*DynamicRegistration defined:
+	 * Whether implementation supports dynamic registration for selection range providers. If this is set to `true`
+	 * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server
+	 * capability as well.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*StaticRegistrationOptions defined:
+ * Static registration options to be returned in the initialize
+ * request.
+ */
+type StaticRegistrationOptions struct {
+
+	/*ID defined:
+	 * The id used to register the request. The id can be used to deregister
+	 * the request again. See also Registration#id.
+	 */
+	ID string `json:"id,omitempty"`
+}
+
+/*TextDocumentRegistrationOptions defined:
+ * General text document registration options.
+ */
+type TextDocumentRegistrationOptions struct {
+
+	/*DocumentSelector defined:
+	 * A document selector to identify the scope of the registration. If set to null
+	 * the document selector provided on the client side will be used.
+	 */
+	DocumentSelector DocumentSelector `json:"documentSelector"`
+}
+
+/*SaveOptions defined:
+ * Save options.
+ */
+type SaveOptions struct {
+
+	/*IncludeText defined:
+	 * The client is supposed to include the content on save.
+	 */
+	IncludeText bool `json:"includeText,omitempty"`
+}
+
+// WorkDoneProgressOptions is
+type WorkDoneProgressOptions struct {
+
+	// WorkDoneProgress is
+	WorkDoneProgress bool `json:"workDoneProgress,omitempty"`
+}
+
+/*InnerServerCapabilities defined:
+ * Defines the capabilities provided by a language
+ * server.
+ */
+type InnerServerCapabilities struct {
+
+	/*TextDocumentSync defined:
+	 * Defines how text documents are synced. Is either a detailed structure defining each notification or
+	 * for backwards compatibility the TextDocumentSyncKind number.
+	 */
+	TextDocumentSync interface{} `json:"textDocumentSync,omitempty"` // TextDocumentSyncOptions | TextDocumentSyncKind
+
+	/*CompletionProvider defined:
+	 * The server provides completion support.
+	 */
+	CompletionProvider *CompletionOptions `json:"completionProvider,omitempty"`
+
+	/*HoverProvider defined:
+	 * The server provides hover support.
+	 */
+	HoverProvider bool `json:"hoverProvider,omitempty"` // boolean | HoverOptions
+
+	/*SignatureHelpProvider defined:
+	 * The server provides signature help support.
+	 */
+	SignatureHelpProvider *SignatureHelpOptions `json:"signatureHelpProvider,omitempty"`
+
+	/*DeclarationProvider defined:
+	 * The server provides Goto Declaration support.
+	 */
+	DeclarationProvider bool `json:"declarationProvider,omitempty"` // boolean | DeclarationOptions | DeclarationRegistrationOptions
+
+	/*DefinitionProvider defined:
+	 * The server provides goto definition support.
+	 */
+	DefinitionProvider bool `json:"definitionProvider,omitempty"` // boolean | DefinitionOptions
+
+	/*TypeDefinitionProvider defined:
+	 * The server provides Goto Type Definition support.
+	 */
+	TypeDefinitionProvider bool `json:"typeDefinitionProvider,omitempty"` // boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions
+
+	/*ImplementationProvider defined:
+	 * The server provides Goto Implementation support.
+	 */
+	ImplementationProvider bool `json:"implementationProvider,omitempty"` // boolean | ImplementationOptions | ImplementationRegistrationOptions
+
+	/*ReferencesProvider defined:
+	 * The server provides find references support.
+	 */
+	ReferencesProvider bool `json:"referencesProvider,omitempty"` // boolean | ReferenceOptions
+
+	/*DocumentHighlightProvider defined:
+	 * The server provides document highlight support.
+	 */
+	DocumentHighlightProvider bool `json:"documentHighlightProvider,omitempty"` // boolean | DocumentHighlightOptions
+
+	/*DocumentSymbolProvider defined:
+	 * The server provides document symbol support.
+	 */
+	DocumentSymbolProvider bool `json:"documentSymbolProvider,omitempty"` // boolean | DocumentSymbolOptions
+
+	/*CodeActionProvider defined:
+	 * The server provides code actions. CodeActionOptions may only be
+	 * specified if the client states that it supports
+	 * `codeActionLiteralSupport` in its initial `initialize` request.
+	 */
+	CodeActionProvider interface{} `json:"codeActionProvider,omitempty"` // boolean | CodeActionOptions
+
+	/*CodeLensProvider defined:
+	 * The server provides code lens.
+	 */
+	CodeLensProvider *CodeLensOptions `json:"codeLensProvider,omitempty"`
+
+	/*DocumentLinkProvider defined:
+	 * The server provides document link support.
+	 */
+	DocumentLinkProvider *DocumentLinkOptions `json:"documentLinkProvider,omitempty"`
+
+	/*ColorProvider defined:
+	 * The server provides color provider support.
+	 */
+	ColorProvider bool `json:"colorProvider,omitempty"` // boolean | DocumentColorOptions | DocumentColorRegistrationOptions
+
+	/*WorkspaceSymbolProvider defined:
+	 * The server provides workspace symbol support.
+	 */
+	WorkspaceSymbolProvider bool `json:"workspaceSymbolProvider,omitempty"` // boolean | WorkspaceSymbolOptions
+
+	/*DocumentFormattingProvider defined:
+	 * The server provides document formatting.
+	 */
+	DocumentFormattingProvider bool `json:"documentFormattingProvider,omitempty"` // boolean | DocumentFormattingOptions
+
+	/*DocumentRangeFormattingProvider defined:
+	 * The server provides document range formatting.
+	 */
+	DocumentRangeFormattingProvider bool `json:"documentRangeFormattingProvider,omitempty"` // boolean | DocumentRangeFormattingOptions
+
+	/*DocumentOnTypeFormattingProvider defined:
+	 * The server provides document formatting on typing.
+	 */
+	DocumentOnTypeFormattingProvider *DocumentOnTypeFormattingOptions `json:"documentOnTypeFormattingProvider,omitempty"`
+
+	/*RenameProvider defined:
+	 * The server provides rename support. RenameOptions may only be
+	 * specified if the client states that it supports
+	 * `prepareSupport` in its initial `initialize` request.
+	 */
+	RenameProvider interface{} `json:"renameProvider,omitempty"` // boolean | RenameOptions
+
+	/*FoldingRangeProvider defined:
+	 * The server provides folding provider support.
+	 */
+	FoldingRangeProvider bool `json:"foldingRangeProvider,omitempty"` // boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions
+
+	/*SelectionRangeProvider defined:
+	 * The server provides selection range support.
+	 */
+	SelectionRangeProvider bool `json:"selectionRangeProvider,omitempty"` // boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions
+
+	/*ExecuteCommandProvider defined:
+	 * The server provides execute command support.
+	 */
+	ExecuteCommandProvider *ExecuteCommandOptions `json:"executeCommandProvider,omitempty"`
+
+	/*Experimental defined:
+	 * Experimental server capabilities.
+	 */
+	Experimental interface{} `json:"experimental,omitempty"`
+}
+
+// ServerCapabilities is
+type ServerCapabilities struct {
+
+	/*TextDocumentSync defined:
+	 * Defines how text documents are synced. Is either a detailed structure defining each notification or
+	 * for backwards compatibility the TextDocumentSyncKind number.
+	 */
+	TextDocumentSync interface{} `json:"textDocumentSync,omitempty"` // TextDocumentSyncOptions | TextDocumentSyncKind
+
+	/*CompletionProvider defined:
+	 * The server provides completion support.
+	 */
+	CompletionProvider *CompletionOptions `json:"completionProvider,omitempty"`
+
+	/*HoverProvider defined:
+	 * The server provides hover support.
+	 */
+	HoverProvider bool `json:"hoverProvider,omitempty"` // boolean | HoverOptions
+
+	/*SignatureHelpProvider defined:
+	 * The server provides signature help support.
+	 */
+	SignatureHelpProvider *SignatureHelpOptions `json:"signatureHelpProvider,omitempty"`
+
+	/*DeclarationProvider defined:
+	 * The server provides Goto Declaration support.
+	 */
+	DeclarationProvider bool `json:"declarationProvider,omitempty"` // boolean | DeclarationOptions | DeclarationRegistrationOptions
+
+	/*DefinitionProvider defined:
+	 * The server provides goto definition support.
+	 */
+	DefinitionProvider bool `json:"definitionProvider,omitempty"` // boolean | DefinitionOptions
+
+	/*TypeDefinitionProvider defined:
+	 * The server provides Goto Type Definition support.
+	 */
+	TypeDefinitionProvider bool `json:"typeDefinitionProvider,omitempty"` // boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions
+
+	/*ImplementationProvider defined:
+	 * The server provides Goto Implementation support.
+	 */
+	ImplementationProvider bool `json:"implementationProvider,omitempty"` // boolean | ImplementationOptions | ImplementationRegistrationOptions
+
+	/*ReferencesProvider defined:
+	 * The server provides find references support.
+	 */
+	ReferencesProvider bool `json:"referencesProvider,omitempty"` // boolean | ReferenceOptions
+
+	/*DocumentHighlightProvider defined:
+	 * The server provides document highlight support.
+	 */
+	DocumentHighlightProvider bool `json:"documentHighlightProvider,omitempty"` // boolean | DocumentHighlightOptions
+
+	/*DocumentSymbolProvider defined:
+	 * The server provides document symbol support.
+	 */
+	DocumentSymbolProvider bool `json:"documentSymbolProvider,omitempty"` // boolean | DocumentSymbolOptions
+
+	/*CodeActionProvider defined:
+	 * The server provides code actions. CodeActionOptions may only be
+	 * specified if the client states that it supports
+	 * `codeActionLiteralSupport` in its initial `initialize` request.
+	 */
+	CodeActionProvider interface{} `json:"codeActionProvider,omitempty"` // boolean | CodeActionOptions
+
+	/*CodeLensProvider defined:
+	 * The server provides code lens.
+	 */
+	CodeLensProvider *CodeLensOptions `json:"codeLensProvider,omitempty"`
+
+	/*DocumentLinkProvider defined:
+	 * The server provides document link support.
+	 */
+	DocumentLinkProvider *DocumentLinkOptions `json:"documentLinkProvider,omitempty"`
+
+	/*ColorProvider defined:
+	 * The server provides color provider support.
+	 */
+	ColorProvider bool `json:"colorProvider,omitempty"` // boolean | DocumentColorOptions | DocumentColorRegistrationOptions
+
+	/*WorkspaceSymbolProvider defined:
+	 * The server provides workspace symbol support.
+	 */
+	WorkspaceSymbolProvider bool `json:"workspaceSymbolProvider,omitempty"` // boolean | WorkspaceSymbolOptions
+
+	/*DocumentFormattingProvider defined:
+	 * The server provides document formatting.
+	 */
+	DocumentFormattingProvider bool `json:"documentFormattingProvider,omitempty"` // boolean | DocumentFormattingOptions
+
+	/*DocumentRangeFormattingProvider defined:
+	 * The server provides document range formatting.
+	 */
+	DocumentRangeFormattingProvider bool `json:"documentRangeFormattingProvider,omitempty"` // boolean | DocumentRangeFormattingOptions
+
+	/*DocumentOnTypeFormattingProvider defined:
+	 * The server provides document formatting on typing.
+	 */
+	DocumentOnTypeFormattingProvider *DocumentOnTypeFormattingOptions `json:"documentOnTypeFormattingProvider,omitempty"`
+
+	/*RenameProvider defined:
+	 * The server provides rename support. RenameOptions may only be
+	 * specified if the client states that it supports
+	 * `prepareSupport` in its initial `initialize` request.
+	 */
+	RenameProvider interface{} `json:"renameProvider,omitempty"` // boolean | RenameOptions
+
+	/*FoldingRangeProvider defined:
+	 * The server provides folding provider support.
+	 */
+	FoldingRangeProvider bool `json:"foldingRangeProvider,omitempty"` // boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions
+
+	/*SelectionRangeProvider defined:
+	 * The server provides selection range support.
+	 */
+	SelectionRangeProvider bool `json:"selectionRangeProvider,omitempty"` // boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions
+
+	/*ExecuteCommandProvider defined:
+	 * The server provides execute command support.
+	 */
+	ExecuteCommandProvider *ExecuteCommandOptions `json:"executeCommandProvider,omitempty"`
+
+	/*Experimental defined:
+	 * Experimental server capabilities.
+	 */
+	Experimental interface{} `json:"experimental,omitempty"`
+
+	/*Workspace defined:
+	 * The workspace server capabilities
+	 */
+	Workspace *struct {
+
+		// WorkspaceFolders is
+		WorkspaceFolders *struct {
+
+			/*Supported defined:
+			 * The Server has support for workspace folders
+			 */
+			Supported bool `json:"supported,omitempty"`
+
+			/*ChangeNotifications defined:
+			 * Whether the server wants to receive workspace folder
+			 * change notifications.
+			 *
+			 * If a strings is provided the string is treated as a ID
+			 * under which the notification is registed on the client
+			 * side. The ID can be used to unregister for these events
+			 * using the `client/unregisterCapability` request.
+			 */
+			ChangeNotifications string `json:"changeNotifications,omitempty"` // string | boolean
+		} `json:"workspaceFolders,omitempty"`
+	} `json:"workspace,omitempty"`
+}
+
+/*InnerInitializeParams defined:
+ * The initialize parameters
+ */
+type InnerInitializeParams struct {
+
+	/*ProcessID defined:
+	 * The process Id of the parent process that started
+	 * the server.
+	 */
+	ProcessID float64 `json:"processId"`
+
+	/*ClientInfo defined:
+	 * Information about the client
+	 *
+	 * @since 3.15.0
+	 */
+	ClientInfo *struct {
+
+		/*Name defined:
+		 * The name of the client as defined by the client.
+		 */
+		Name string `json:"name"`
+
+		/*Version defined:
+		 * The client's version as defined by the client.
+		 */
+		Version string `json:"version,omitempty"`
+	} `json:"clientInfo,omitempty"`
+
+	/*RootPath defined:
+	 * The rootPath of the workspace. Is null
+	 * if no folder is open.
+	 *
+	 * @deprecated in favour of rootUri.
+	 */
+	RootPath string `json:"rootPath,omitempty"`
+
+	/*RootURI defined:
+	 * The rootUri of the workspace. Is null if no
+	 * folder is open. If both `rootPath` and `rootUri` are set
+	 * `rootUri` wins.
+	 *
+	 * @deprecated in favour of workspaceFolders.
+	 */
+	RootURI DocumentURI `json:"rootUri"`
+
+	/*Capabilities defined:
+	 * The capabilities provided by the client (editor or tool)
+	 */
+	Capabilities ClientCapabilities `json:"capabilities"`
+
+	/*InitializationOptions defined:
+	 * User provided initialization options.
+	 */
+	InitializationOptions interface{} `json:"initializationOptions,omitempty"`
+
+	/*Trace defined:
+	 * The initial trace setting. If omitted trace is disabled ('off').
+	 */
+	Trace string `json:"trace,omitempty"` // 'off' | 'messages' | 'verbose'
+	WorkDoneProgressParams
+}
+
+// InitializeParams is
+type InitializeParams struct {
+
+	/*ProcessID defined:
+	 * The process Id of the parent process that started
+	 * the server.
+	 */
+	ProcessID float64 `json:"processId"`
+
+	/*ClientInfo defined:
+	 * Information about the client
+	 *
+	 * @since 3.15.0
+	 */
+	ClientInfo *struct {
+
+		/*Name defined:
+		 * The name of the client as defined by the client.
+		 */
+		Name string `json:"name"`
+
+		/*Version defined:
+		 * The client's version as defined by the client.
+		 */
+		Version string `json:"version,omitempty"`
+	} `json:"clientInfo,omitempty"`
+
+	/*RootPath defined:
+	 * The rootPath of the workspace. Is null
+	 * if no folder is open.
+	 *
+	 * @deprecated in favour of rootUri.
+	 */
+	RootPath string `json:"rootPath,omitempty"`
+
+	/*RootURI defined:
+	 * The rootUri of the workspace. Is null if no
+	 * folder is open. If both `rootPath` and `rootUri` are set
+	 * `rootUri` wins.
+	 *
+	 * @deprecated in favour of workspaceFolders.
+	 */
+	RootURI DocumentURI `json:"rootUri"`
+
+	/*Capabilities defined:
+	 * The capabilities provided by the client (editor or tool)
+	 */
+	Capabilities ClientCapabilities `json:"capabilities"`
+
+	/*InitializationOptions defined:
+	 * User provided initialization options.
+	 */
+	InitializationOptions interface{} `json:"initializationOptions,omitempty"`
+
+	/*Trace defined:
+	 * The initial trace setting. If omitted trace is disabled ('off').
+	 */
+	Trace string `json:"trace,omitempty"` // 'off' | 'messages' | 'verbose'
+
+	/*WorkspaceFolders defined:
+	 * The actual configured workspace folders.
+	 */
+	WorkspaceFolders []WorkspaceFolder `json:"workspaceFolders"`
+}
+
+/*InitializeResult defined:
+ * The result returned from an initialize request.
+ */
+type InitializeResult struct {
+
+	/*Capabilities defined:
+	 * The capabilities the language server provides.
+	 */
+	Capabilities ServerCapabilities `json:"capabilities"`
+
+	/*ServerInfo defined:
+	 * Information about the server.
+	 *
+	 * @since 3.15.0
+	 */
+	ServerInfo *struct {
+
+		/*Name defined:
+		 * The name of the server as defined by the server.
+		 */
+		Name string `json:"name"`
+
+		/*Version defined:
+		 * The servers's version as defined by the server.
+		 */
+		Version string `json:"version,omitempty"`
+	} `json:"serverInfo,omitempty"`
+
+	/*Custom defined:
+	 * Custom initialization results.
+	 */
+	Custom map[string]interface{} `json:"custom"` // [custom: string]: any;
+}
+
+// InitializedParams is
+type InitializedParams struct {
+}
+
+// DidChangeConfigurationClientCapabilities is
+type DidChangeConfigurationClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Did change configuration notification supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+// DidChangeConfigurationRegistrationOptions is
+type DidChangeConfigurationRegistrationOptions struct {
+
+	// Section is
+	Section string `json:"section,omitempty"` // string | string[]
+}
+
+/*DidChangeConfigurationParams defined:
+ * The parameters of a change configuration notification.
+ */
+type DidChangeConfigurationParams struct {
+
+	/*Settings defined:
+	 * The actual changed settings
+	 */
+	Settings interface{} `json:"settings"`
+}
+
+/*ShowMessageParams defined:
+ * The parameters of a notification message.
+ */
+type ShowMessageParams struct {
+
+	/*Type defined:
+	 * The message type. See {@link MessageType}
+	 */
+	Type MessageType `json:"type"`
+
+	/*Message defined:
+	 * The actual message
+	 */
+	Message string `json:"message"`
+}
+
+// MessageActionItem is
+type MessageActionItem struct {
+
+	/*Title defined:
+	 * A short title like 'Retry', 'Open Log' etc.
+	 */
+	Title string `json:"title"`
+}
+
+// ShowMessageRequestParams is
+type ShowMessageRequestParams struct {
+
+	/*Type defined:
+	 * The message type. See {@link MessageType}
+	 */
+	Type MessageType `json:"type"`
+
+	/*Message defined:
+	 * The actual message
+	 */
+	Message string `json:"message"`
+
+	/*Actions defined:
+	 * The message action items to present.
+	 */
+	Actions []MessageActionItem `json:"actions,omitempty"`
+}
+
+/*LogMessageParams defined:
+ * The log message parameters.
+ */
+type LogMessageParams struct {
+
+	/*Type defined:
+	 * The message type. See {@link MessageType}
+	 */
+	Type MessageType `json:"type"`
+
+	/*Message defined:
+	 * The actual message
+	 */
+	Message string `json:"message"`
+}
+
+// TextDocumentSyncClientCapabilities is
+type TextDocumentSyncClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether text document synchronization supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*WillSave defined:
+	 * The client supports sending will save notifications.
+	 */
+	WillSave bool `json:"willSave,omitempty"`
+
+	/*WillSaveWaitUntil defined:
+	 * The client supports sending a will save request and
+	 * waits for a response providing text edits which will
+	 * be applied to the document before it is saved.
+	 */
+	WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitempty"`
+
+	/*DidSave defined:
+	 * The client supports did save notifications.
+	 */
+	DidSave bool `json:"didSave,omitempty"`
+}
+
+// TextDocumentSyncOptions is
+type TextDocumentSyncOptions struct {
+
+	/*OpenClose defined:
+	 * Open and close notifications are sent to the server. If omitted open close notification should not
+	 * be sent.
+	 */
+	OpenClose bool `json:"openClose,omitempty"`
+
+	/*Change defined:
+	 * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
+	 * and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None.
+	 */
+	Change TextDocumentSyncKind `json:"change,omitempty"`
+
+	/*WillSave defined:
+	 * If present will save notifications are sent to the server. If omitted the notification should not be
+	 * sent.
+	 */
+	WillSave bool `json:"willSave,omitempty"`
+
+	/*WillSaveWaitUntil defined:
+	 * If present will save wait until requests are sent to the server. If omitted the request should not be
+	 * sent.
+	 */
+	WillSaveWaitUntil bool `json:"willSaveWaitUntil,omitempty"`
+
+	/*Save defined:
+	 * If present save notifications are sent to the server. If omitted the notification should not be
+	 * sent.
+	 */
+	Save *SaveOptions `json:"save,omitempty"`
+}
+
+/*DidOpenTextDocumentParams defined:
+ * The parameters send in a open text document notification
+ */
+type DidOpenTextDocumentParams struct {
+
+	/*TextDocument defined:
+	 * The document that was opened.
+	 */
+	TextDocument TextDocumentItem `json:"textDocument"`
+}
+
+/*DidChangeTextDocumentParams defined:
+ * The change text document notification's parameters.
+ */
+type DidChangeTextDocumentParams struct {
+
+	/*TextDocument defined:
+	 * The document that did change. The version number points
+	 * to the version after all provided content changes have
+	 * been applied.
+	 */
+	TextDocument VersionedTextDocumentIdentifier `json:"textDocument"`
+
+	/*ContentChanges defined:
+	 * The actual content changes. The content changes describe single state changes
+	 * to the document. So if there are two content changes c1 and c2 for a document
+	 * in state S then c1 move the document to S' and c2 to S''.
+	 */
+	ContentChanges []TextDocumentContentChangeEvent `json:"contentChanges"`
+}
+
+/*TextDocumentChangeRegistrationOptions defined:
+ * Describe options to be used when registered for text document change events.
+ */
+type TextDocumentChangeRegistrationOptions struct {
+
+	/*SyncKind defined:
+	 * How documents are synced to the server.
+	 */
+	SyncKind TextDocumentSyncKind `json:"syncKind"`
+	TextDocumentRegistrationOptions
+}
+
+/*DidCloseTextDocumentParams defined:
+ * The parameters send in a close text document notification
+ */
+type DidCloseTextDocumentParams struct {
+
+	/*TextDocument defined:
+	 * The document that was closed.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+}
+
+/*DidSaveTextDocumentParams defined:
+ * The parameters send in a save text document notification
+ */
+type DidSaveTextDocumentParams struct {
+
+	/*TextDocument defined:
+	 * The document that was closed.
+	 */
+	TextDocument VersionedTextDocumentIdentifier `json:"textDocument"`
+
+	/*Text defined:
+	 * Optional the content when saved. Depends on the includeText value
+	 * when the save notification was requested.
+	 */
+	Text string `json:"text,omitempty"`
+}
+
+/*TextDocumentSaveRegistrationOptions defined:
+ * Save registration options.
+ */
+type TextDocumentSaveRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	SaveOptions
+}
+
+/*WillSaveTextDocumentParams defined:
+ * The parameters send in a will save text document notification.
+ */
+type WillSaveTextDocumentParams struct {
+
+	/*TextDocument defined:
+	 * The document that will be saved.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Reason defined:
+	 * The 'TextDocumentSaveReason'.
+	 */
+	Reason TextDocumentSaveReason `json:"reason"`
+}
+
+// DidChangeWatchedFilesClientCapabilities is
+type DidChangeWatchedFilesClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Did change watched files notification supports dynamic registration. Please note
+	 * that the current protocol doesn't support static configuration for file changes
+	 * from the server side.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*DidChangeWatchedFilesParams defined:
+ * The watched files change notification's parameters.
+ */
+type DidChangeWatchedFilesParams struct {
+
+	/*Changes defined:
+	 * The actual file events.
+	 */
+	Changes []FileEvent `json:"changes"`
+}
+
+/*FileEvent defined:
+ * An event describing a file change.
+ */
+type FileEvent struct {
+
+	/*URI defined:
+	 * The file's uri.
+	 */
+	URI DocumentURI `json:"uri"`
+
+	/*Type defined:
+	 * The change type.
+	 */
+	Type FileChangeType `json:"type"`
+}
+
+/*DidChangeWatchedFilesRegistrationOptions defined:
+ * Describe options to be used when registered for text document change events.
+ */
+type DidChangeWatchedFilesRegistrationOptions struct {
+
+	/*Watchers defined:
+	 * The watchers to register.
+	 */
+	Watchers []FileSystemWatcher `json:"watchers"`
+}
+
+// FileSystemWatcher is
+type FileSystemWatcher struct {
+
+	/*GlobPattern defined:
+	 * The  glob pattern to watch. Glob patterns can have the following syntax:
+	 * - `*` to match one or more characters in a path segment
+	 * - `?` to match on one character in a path segment
+	 * - `**` to match any number of path segments, including none
+	 * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+	 * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+	 * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+	 */
+	GlobPattern string `json:"globPattern"`
+
+	/*Kind defined:
+	 * The kind of events of interest. If omitted it defaults
+	 * to WatchKind.Create | WatchKind.Change | WatchKind.Delete
+	 * which is 7.
+	 */
+	Kind float64 `json:"kind,omitempty"`
+}
+
+/*PublishDiagnosticsClientCapabilities defined:
+ * The publish diagnostic client capabilities.
+ */
+type PublishDiagnosticsClientCapabilities struct {
+
+	/*RelatedInformation defined:
+	 * Whether the clients accepts diagnostics with related information.
+	 */
+	RelatedInformation bool `json:"relatedInformation,omitempty"`
+
+	/*TagSupport defined:
+	 * Client supports the tag property to provide meta data about a diagnostic.
+	 * Clients supporting tags have to handle unknown tags gracefully.
+	 *
+	 * @since 3.15.0
+	 */
+	TagSupport *struct {
+
+		/*ValueSet defined:
+		 * The tags supported by the client.
+		 */
+		ValueSet []DiagnosticTag `json:"valueSet"`
+	} `json:"tagSupport,omitempty"`
+}
+
+/*PublishDiagnosticsParams defined:
+ * The publish diagnostic notification's parameters.
+ */
+type PublishDiagnosticsParams struct {
+
+	/*URI defined:
+	 * The URI for which diagnostic information is reported.
+	 */
+	URI DocumentURI `json:"uri"`
+
+	/*Version defined:
+	 * Optional the version number of the document the diagnostics are published for.
+	 *
+	 * @since 3.15.0
+	 */
+	Version float64 `json:"version,omitempty"`
+
+	/*Diagnostics defined:
+	 * An array of diagnostic information items.
+	 */
+	Diagnostics []Diagnostic `json:"diagnostics"`
+}
+
+/*CompletionClientCapabilities defined:
+ * Completion client capabilities
+ */
+type CompletionClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether completion supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*CompletionItem defined:
+	 * The client supports the following `CompletionItem` specific
+	 * capabilities.
+	 */
+	CompletionItem *struct {
+
+		/*SnippetSupport defined:
+		 * Client supports snippets as insert text.
+		 *
+		 * A snippet can define tab stops and placeholders with `$1`, `$2`
+		 * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+		 * the end of the snippet. Placeholders with equal identifiers are linked,
+		 * that is typing in one will update others too.
+		 */
+		SnippetSupport bool `json:"snippetSupport,omitempty"`
+
+		/*CommitCharactersSupport defined:
+		 * Client supports commit characters on a completion item.
+		 */
+		CommitCharactersSupport bool `json:"commitCharactersSupport,omitempty"`
+
+		/*DocumentationFormat defined:
+		 * Client supports the follow content formats for the documentation
+		 * property. The order describes the preferred format of the client.
+		 */
+		DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"`
+
+		/*DeprecatedSupport defined:
+		 * Client supports the deprecated property on a completion item.
+		 */
+		DeprecatedSupport bool `json:"deprecatedSupport,omitempty"`
+
+		/*PreselectSupport defined:
+		 * Client supports the preselect property on a completion item.
+		 */
+		PreselectSupport bool `json:"preselectSupport,omitempty"`
+
+		/*TagSupport defined:
+		 * Client supports the tag property on a completion item. Clients supporting
+		 * tags have to handle unknown tags gracefully. Clients especially need to
+		 * preserve unknown tags when sending a completion item back to the server in
+		 * a resolve call.
+		 *
+		 * @since 3.15.0
+		 */
+		TagSupport *struct {
+
+			/*ValueSet defined:
+			 * The tags supported by the client.
+			 */
+			ValueSet []CompletionItemTag `json:"valueSet"`
+		} `json:"tagSupport,omitempty"`
+	} `json:"completionItem,omitempty"`
+
+	// CompletionItemKind is
+	CompletionItemKind *struct {
+
+		/*ValueSet defined:
+		 * The completion item kind values the client supports. When this
+		 * property exists the client also guarantees that it will
+		 * handle values outside its set gracefully and falls back
+		 * to a default value when unknown.
+		 *
+		 * If this property is not present the client only supports
+		 * the completion items kinds from `Text` to `Reference` as defined in
+		 * the initial version of the protocol.
+		 */
+		ValueSet []CompletionItemKind `json:"valueSet,omitempty"`
+	} `json:"completionItemKind,omitempty"`
+
+	/*ContextSupport defined:
+	 * The client supports to send additional context information for a
+	 * `textDocument/completion` requestion.
+	 */
+	ContextSupport bool `json:"contextSupport,omitempty"`
+}
+
+/*CompletionContext defined:
+ * Contains additional information about the context in which a completion request is triggered.
+ */
+type CompletionContext struct {
+
+	/*TriggerKind defined:
+	 * How the completion was triggered.
+	 */
+	TriggerKind CompletionTriggerKind `json:"triggerKind"`
+
+	/*TriggerCharacter defined:
+	 * The trigger character (a single character) that has trigger code complete.
+	 * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
+	 */
+	TriggerCharacter string `json:"triggerCharacter,omitempty"`
+}
+
+/*CompletionParams defined:
+ * Completion parameters
+ */
+type CompletionParams struct {
+
+	/*Context defined:
+	 * The completion context. This is only available it the client specifies
+	 * to send this using the client capability `textDocument.completion.contextSupport === true`
+	 */
+	Context *CompletionContext `json:"context,omitempty"`
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*CompletionOptions defined:
+ * Completion options.
+ */
+type CompletionOptions struct {
+
+	/*TriggerCharacters defined:
+	 * Most tools trigger completion request automatically without explicitly requesting
+	 * it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user
+	 * starts to type an identifier. For example if the user types `c` in a JavaScript file
+	 * code complete will automatically pop up present `console` besides others as a
+	 * completion item. Characters that make up identifiers don't need to be listed here.
+	 *
+	 * If code complete should automatically be trigger on characters not being valid inside
+	 * an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
+	 */
+	TriggerCharacters []string `json:"triggerCharacters,omitempty"`
+
+	/*AllCommitCharacters defined:
+	 * The list of all possible characters that commit a completion. This field can be used
+	 * if clients don't support individual commmit characters per completion item. See
+	 * `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport`
+	 *
+	 * @since 3.2.0
+	 */
+	AllCommitCharacters []string `json:"allCommitCharacters,omitempty"`
+
+	/*ResolveProvider defined:
+	 * The server provides support to resolve additional
+	 * information for a completion item.
+	 */
+	ResolveProvider bool `json:"resolveProvider,omitempty"`
+	WorkDoneProgressOptions
+}
+
+/*CompletionRegistrationOptions defined:
+ * Registration options for a [CompletionRequest](#CompletionRequest).
+ */
+type CompletionRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	CompletionOptions
+}
+
+// HoverClientCapabilities is
+type HoverClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether hover supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*ContentFormat defined:
+	 * Client supports the follow content formats for the content
+	 * property. The order describes the preferred format of the client.
+	 */
+	ContentFormat []MarkupKind `json:"contentFormat,omitempty"`
+}
+
+/*HoverOptions defined:
+ * Hover options.
+ */
+type HoverOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*HoverParams defined:
+ * Parameters for a [HoverRequest](#HoverRequest).
+ */
+type HoverParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+}
+
+/*HoverRegistrationOptions defined:
+ * Registration options for a [HoverRequest](#HoverRequest).
+ */
+type HoverRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	HoverOptions
+}
+
+/*SignatureHelpClientCapabilities defined:
+ * Client Capabilities for a [SignatureHelpRequest](#SignatureHelpRequest).
+ */
+type SignatureHelpClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether signature help supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*SignatureInformation defined:
+	 * The client supports the following `SignatureInformation`
+	 * specific properties.
+	 */
+	SignatureInformation *struct {
+
+		/*DocumentationFormat defined:
+		 * Client supports the follow content formats for the documentation
+		 * property. The order describes the preferred format of the client.
+		 */
+		DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"`
+
+		/*ParameterInformation defined:
+		 * Client capabilities specific to parameter information.
+		 */
+		ParameterInformation *struct {
+
+			/*LabelOffsetSupport defined:
+			 * The client supports processing label offsets instead of a
+			 * simple label string.
+			 *
+			 * @since 3.14.0
+			 */
+			LabelOffsetSupport bool `json:"labelOffsetSupport,omitempty"`
+		} `json:"parameterInformation,omitempty"`
+	} `json:"signatureInformation,omitempty"`
+
+	/*ContextSupport defined:
+	 * The client supports to send additional context information for a
+	 * `textDocument/signatureHelp` request. A client that opts into
+	 * contextSupport will also support the `retriggerCharacters` on
+	 * `SignatureHelpOptions`.
+	 *
+	 * @since 3.15.0
+	 */
+	ContextSupport bool `json:"contextSupport,omitempty"`
+}
+
+/*SignatureHelpOptions defined:
+ * Server Capabilities for a [SignatureHelpRequest](#SignatureHelpRequest).
+ */
+type SignatureHelpOptions struct {
+
+	/*TriggerCharacters defined:
+	 * List of characters that trigger signature help.
+	 */
+	TriggerCharacters []string `json:"triggerCharacters,omitempty"`
+
+	/*RetriggerCharacters defined:
+	 * List of characters that re-trigger signature help.
+	 *
+	 * These trigger characters are only active when signature help is already showing. All trigger characters
+	 * are also counted as re-trigger characters.
+	 *
+	 * @since 3.15.0
+	 */
+	RetriggerCharacters []string `json:"retriggerCharacters,omitempty"`
+	WorkDoneProgressOptions
+}
+
+/*SignatureHelpContext defined:
+ * Additional information about the context in which a signature help request was triggered.
+ *
+ * @since 3.15.0
+ */
+type SignatureHelpContext struct {
+
+	/*TriggerKind defined:
+	 * Action that caused signature help to be triggered.
+	 */
+	TriggerKind SignatureHelpTriggerKind `json:"triggerKind"`
+
+	/*TriggerCharacter defined:
+	 * Character that caused signature help to be triggered.
+	 *
+	 * This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
+	 */
+	TriggerCharacter string `json:"triggerCharacter,omitempty"`
+
+	/*IsRetrigger defined:
+	 * `true` if signature help was already showing when it was triggered.
+	 *
+	 * Retriggers occur when the signature help is already active and can be caused by actions such as
+	 * typing a trigger character, a cursor move, or document content changes.
+	 */
+	IsRetrigger bool `json:"isRetrigger"`
+
+	/*ActiveSignatureHelp defined:
+	 * The currently active `SignatureHelp`.
+	 *
+	 * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
+	 * the user navigating through available signatures.
+	 */
+	ActiveSignatureHelp *SignatureHelp `json:"activeSignatureHelp,omitempty"`
+}
+
+/*SignatureHelpParams defined:
+ * Parameters for a [SignatureHelpRequest](#SignatureHelpRequest).
+ */
+type SignatureHelpParams struct {
+
+	/*Context defined:
+	 * The signature help context. This is only available if the client specifies
+	 * to send this using the client capability `textDocument.signatureHelp.contextSupport === true`
+	 *
+	 * @since 3.15.0
+	 */
+	Context *SignatureHelpContext `json:"context,omitempty"`
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+}
+
+/*SignatureHelpRegistrationOptions defined:
+ * Registration options for a [SignatureHelpRequest](#SignatureHelpRequest).
+ */
+type SignatureHelpRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	SignatureHelpOptions
+}
+
+/*DefinitionClientCapabilities defined:
+ * Client Capabilities for a [DefinitionRequest](#DefinitionRequest).
+ */
+type DefinitionClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether definition supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*LinkSupport defined:
+	 * The client supports additional metadata in the form of definition links.
+	 *
+	 * @since 3.14.0
+	 */
+	LinkSupport bool `json:"linkSupport,omitempty"`
+}
+
+/*DefinitionOptions defined:
+ * Server Capabilities for a [DefinitionRequest](#DefinitionRequest).
+ */
+type DefinitionOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*DefinitionParams defined:
+ * Parameters for a [DefinitionRequest](#DefinitionRequest).
+ */
+type DefinitionParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*DefinitionRegistrationOptions defined:
+ * Registration options for a [DefinitionRequest](#DefinitionRequest).
+ */
+type DefinitionRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DefinitionOptions
+}
+
+/*ReferenceClientCapabilities defined:
+ * Client Capabilities for a [ReferencesRequest](#ReferencesRequest).
+ */
+type ReferenceClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether references supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*ReferenceParams defined:
+ * Parameters for a [ReferencesRequest](#ReferencesRequest).
+ */
+type ReferenceParams struct {
+
+	// Context is
+	Context ReferenceContext `json:"context"`
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*ReferenceOptions defined:
+ * Reference options.
+ */
+type ReferenceOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*ReferenceRegistrationOptions defined:
+ * Registration options for a [ReferencesRequest](#ReferencesRequest).
+ */
+type ReferenceRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	ReferenceOptions
+}
+
+/*DocumentHighlightClientCapabilities defined:
+ * Client Capabilities for a [DocumentHighlightRequest](#DocumentHighlightRequest).
+ */
+type DocumentHighlightClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether document highlight supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*DocumentHighlightParams defined:
+ * Parameters for a [DocumentHighlightRequest](#DocumentHighlightRequest).
+ */
+type DocumentHighlightParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*DocumentHighlightOptions defined:
+ * Provider options for a [DocumentHighlightRequest](#DocumentHighlightRequest).
+ */
+type DocumentHighlightOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*DocumentHighlightRegistrationOptions defined:
+ * Registration options for a [DocumentHighlightRequest](#DocumentHighlightRequest).
+ */
+type DocumentHighlightRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DocumentHighlightOptions
+}
+
+/*DocumentSymbolClientCapabilities defined:
+ * Client Capabilities for a [DocumentSymbolRequest](#DocumentSymbolRequest).
+ */
+type DocumentSymbolClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether document symbol supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*SymbolKind defined:
+	 * Specific capabilities for the `SymbolKind`.
+	 */
+	SymbolKind *struct {
+
+		/*ValueSet defined:
+		 * The symbol kind values the client supports. When this
+		 * property exists the client also guarantees that it will
+		 * handle values outside its set gracefully and falls back
+		 * to a default value when unknown.
+		 *
+		 * If this property is not present the client only supports
+		 * the symbol kinds from `File` to `Array` as defined in
+		 * the initial version of the protocol.
+		 */
+		ValueSet []SymbolKind `json:"valueSet,omitempty"`
+	} `json:"symbolKind,omitempty"`
+
+	/*HierarchicalDocumentSymbolSupport defined:
+	 * The client support hierarchical document symbols.
+	 */
+	HierarchicalDocumentSymbolSupport bool `json:"hierarchicalDocumentSymbolSupport,omitempty"`
+}
+
+/*DocumentSymbolParams defined:
+ * Parameters for a [DocumentSymbolRequest](#DocumentSymbolRequest).
+ */
+type DocumentSymbolParams struct {
+
+	/*TextDocument defined:
+	 * The text document.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*DocumentSymbolOptions defined:
+ * Provider options for a [DocumentSymbolRequest](#DocumentSymbolRequest).
+ */
+type DocumentSymbolOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*DocumentSymbolRegistrationOptions defined:
+ * Registration options for a [DocumentSymbolRequest](#DocumentSymbolRequest).
+ */
+type DocumentSymbolRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DocumentSymbolOptions
+}
+
+/*CodeActionClientCapabilities defined:
+ * The Client Capabilities of a [CodeActionRequest](#CodeActionRequest).
+ */
+type CodeActionClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether code action supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*CodeActionLiteralSupport defined:
+	 * The client support code action literals as a valid
+	 * response of the `textDocument/codeAction` request.
+	 *
+	 * @since 3.8.0
+	 */
+	CodeActionLiteralSupport *struct {
+
+		/*CodeActionKind defined:
+		 * The code action kind is support with the following value
+		 * set.
+		 */
+		CodeActionKind struct {
+
+			/*ValueSet defined:
+			 * The code action kind values the client supports. When this
+			 * property exists the client also guarantees that it will
+			 * handle values outside its set gracefully and falls back
+			 * to a default value when unknown.
+			 */
+			ValueSet []CodeActionKind `json:"valueSet"`
+		} `json:"codeActionKind"`
+	} `json:"codeActionLiteralSupport,omitempty"`
+
+	/*IsPreferredSupport defined:
+	 * Whether code action supports the `isPreferred` property.
+	 * @since 3.15.0
+	 */
+	IsPreferredSupport bool `json:"isPreferredSupport,omitempty"`
+}
+
+/*CodeActionParams defined:
+ * The parameters of a [CodeActionRequest](#CodeActionRequest).
+ */
+type CodeActionParams struct {
+
+	/*TextDocument defined:
+	 * The document in which the command was invoked.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Range defined:
+	 * The range for which the command was invoked.
+	 */
+	Range Range `json:"range"`
+
+	/*Context defined:
+	 * Context carrying additional information.
+	 */
+	Context CodeActionContext `json:"context"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*CodeActionOptions defined:
+ * Provider options for a [CodeActionRequest](#CodeActionRequest).
+ */
+type CodeActionOptions struct {
+
+	/*CodeActionKinds defined:
+	 * CodeActionKinds that this server may return.
+	 *
+	 * The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server
+	 * may list out every specific kind they provide.
+	 */
+	CodeActionKinds []CodeActionKind `json:"codeActionKinds,omitempty"`
+	WorkDoneProgressOptions
+}
+
+/*CodeActionRegistrationOptions defined:
+ * Registration options for a [CodeActionRequest](#CodeActionRequest).
+ */
+type CodeActionRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	CodeActionOptions
+}
+
+/*WorkspaceSymbolClientCapabilities defined:
+ * Client capabilities for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
+ */
+type WorkspaceSymbolClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Symbol request supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*SymbolKind defined:
+	 * Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
+	 */
+	SymbolKind *struct {
+
+		/*ValueSet defined:
+		 * The symbol kind values the client supports. When this
+		 * property exists the client also guarantees that it will
+		 * handle values outside its set gracefully and falls back
+		 * to a default value when unknown.
+		 *
+		 * If this property is not present the client only supports
+		 * the symbol kinds from `File` to `Array` as defined in
+		 * the initial version of the protocol.
+		 */
+		ValueSet []SymbolKind `json:"valueSet,omitempty"`
+	} `json:"symbolKind,omitempty"`
+}
+
+/*WorkspaceSymbolParams defined:
+ * The parameters of a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
+ */
+type WorkspaceSymbolParams struct {
+
+	/*Query defined:
+	 * A query string to filter symbols by. Clients may send an empty
+	 * string here to request all symbols.
+	 */
+	Query string `json:"query"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*WorkspaceSymbolOptions defined:
+ * Server capabilities for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
+ */
+type WorkspaceSymbolOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*WorkspaceSymbolRegistrationOptions defined:
+ * Registration options for a [WorkspaceSymbolRequest](#WorkspaceSymbolRequest).
+ */
+type WorkspaceSymbolRegistrationOptions struct {
+	WorkspaceSymbolOptions
+}
+
+/*CodeLensClientCapabilities defined:
+ * The client capabilities  of a [CodeLensRequest](#CodeLensRequest).
+ */
+type CodeLensClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether code lens supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*CodeLensParams defined:
+ * The parameters of a [CodeLensRequest](#CodeLensRequest).
+ */
+type CodeLensParams struct {
+
+	/*TextDocument defined:
+	 * The document to request code lens for.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*CodeLensOptions defined:
+ * Code Lens provider options of a [CodeLensRequest](#CodeLensRequest).
+ */
+type CodeLensOptions struct {
+
+	/*ResolveProvider defined:
+	 * Code lens has a resolve provider as well.
+	 */
+	ResolveProvider bool `json:"resolveProvider,omitempty"`
+	WorkDoneProgressOptions
+}
+
+/*CodeLensRegistrationOptions defined:
+ * Registration options for a [CodeLensRequest](#CodeLensRequest).
+ */
+type CodeLensRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	CodeLensOptions
+}
+
+/*DocumentLinkClientCapabilities defined:
+ * The client capabilities of a [DocumentLinkRequest](#DocumentLinkRequest).
+ */
+type DocumentLinkClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether document link supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*TooltipSupport defined:
+	 * Whether the client support the `tooltip` property on `DocumentLink`.
+	 *
+	 * @since 3.15.0
+	 */
+	TooltipSupport bool `json:"tooltipSupport,omitempty"`
+}
+
+/*DocumentLinkParams defined:
+ * The parameters of a [DocumentLinkRequest](#DocumentLinkRequest).
+ */
+type DocumentLinkParams struct {
+
+	/*TextDocument defined:
+	 * The document to provide document links for.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+	WorkDoneProgressParams
+	PartialResultParams
+}
+
+/*DocumentLinkOptions defined:
+ * Provider options for a [DocumentLinkRequest](#DocumentLinkRequest).
+ */
+type DocumentLinkOptions struct {
+
+	/*ResolveProvider defined:
+	 * Document links have a resolve provider as well.
+	 */
+	ResolveProvider bool `json:"resolveProvider,omitempty"`
+	WorkDoneProgressOptions
+}
+
+/*DocumentLinkRegistrationOptions defined:
+ * Registration options for a [DocumentLinkRequest](#DocumentLinkRequest).
+ */
+type DocumentLinkRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DocumentLinkOptions
+}
+
+/*DocumentFormattingClientCapabilities defined:
+ * Client capabilities of a [DocumentFormattingRequest](#DocumentFormattingRequest).
+ */
+type DocumentFormattingClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether formatting supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*DocumentFormattingParams defined:
+ * The parameters of a [DocumentFormattingRequest](#DocumentFormattingRequest).
+ */
+type DocumentFormattingParams struct {
+
+	/*TextDocument defined:
+	 * The document to format.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Options defined:
+	 * The format options
+	 */
+	Options FormattingOptions `json:"options"`
+	WorkDoneProgressParams
+}
+
+/*DocumentFormattingOptions defined:
+ * Provider options for a [DocumentFormattingRequest](#DocumentFormattingRequest).
+ */
+type DocumentFormattingOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*DocumentFormattingRegistrationOptions defined:
+ * Registration options for a [DocumentFormattingRequest](#DocumentFormattingRequest).
+ */
+type DocumentFormattingRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DocumentFormattingOptions
+}
+
+/*DocumentRangeFormattingClientCapabilities defined:
+ * Client capabilities of a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
+ */
+type DocumentRangeFormattingClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether range formatting supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*DocumentRangeFormattingParams defined:
+ * The parameters of a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
+ */
+type DocumentRangeFormattingParams struct {
+
+	/*TextDocument defined:
+	 * The document to format.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Range defined:
+	 * The range to format
+	 */
+	Range Range `json:"range"`
+
+	/*Options defined:
+	 * The format options
+	 */
+	Options FormattingOptions `json:"options"`
+	WorkDoneProgressParams
+}
+
+/*DocumentRangeFormattingOptions defined:
+ * Provider options for a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
+ */
+type DocumentRangeFormattingOptions struct {
+	WorkDoneProgressOptions
+}
+
+/*DocumentRangeFormattingRegistrationOptions defined:
+ * Registration options for a [DocumentRangeFormattingRequest](#DocumentRangeFormattingRequest).
+ */
+type DocumentRangeFormattingRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DocumentRangeFormattingOptions
+}
+
+/*DocumentOnTypeFormattingClientCapabilities defined:
+ * Client capabilities of a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
+ */
+type DocumentOnTypeFormattingClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether on type formatting supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*DocumentOnTypeFormattingParams defined:
+ * The parameters of a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
+ */
+type DocumentOnTypeFormattingParams struct {
+
+	/*TextDocument defined:
+	 * The document to format.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Position defined:
+	 * The position at which this request was send.
+	 */
+	Position Position `json:"position"`
+
+	/*Ch defined:
+	 * The character that has been typed.
+	 */
+	Ch string `json:"ch"`
+
+	/*Options defined:
+	 * The format options.
+	 */
+	Options FormattingOptions `json:"options"`
+}
+
+/*DocumentOnTypeFormattingOptions defined:
+ * Provider options for a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
+ */
+type DocumentOnTypeFormattingOptions struct {
+
+	/*FirstTriggerCharacter defined:
+	 * A character on which formatting should be triggered, like `}`.
+	 */
+	FirstTriggerCharacter string `json:"firstTriggerCharacter"`
+
+	/*MoreTriggerCharacter defined:
+	 * More trigger characters.
+	 */
+	MoreTriggerCharacter []string `json:"moreTriggerCharacter,omitempty"`
+}
+
+/*DocumentOnTypeFormattingRegistrationOptions defined:
+ * Registration options for a [DocumentOnTypeFormattingRequest](#DocumentOnTypeFormattingRequest).
+ */
+type DocumentOnTypeFormattingRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	DocumentOnTypeFormattingOptions
+}
+
+// RenameClientCapabilities is
+type RenameClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Whether rename supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+
+	/*PrepareSupport defined:
+	 * Client supports testing for validity of rename operations
+	 * before execution.
+	 *
+	 * @since version 3.12.0
+	 */
+	PrepareSupport bool `json:"prepareSupport,omitempty"`
+}
+
+/*RenameParams defined:
+ * The parameters of a [RenameRequest](#RenameRequest).
+ */
+type RenameParams struct {
+
+	/*TextDocument defined:
+	 * The document to rename.
+	 */
+	TextDocument TextDocumentIdentifier `json:"textDocument"`
+
+	/*Position defined:
+	 * The position at which this request was sent.
+	 */
+	Position Position `json:"position"`
+
+	/*NewName defined:
+	 * The new name of the symbol. If the given name is not valid the
+	 * request must return a [ResponseError](#ResponseError) with an
+	 * appropriate message set.
+	 */
+	NewName string `json:"newName"`
+	WorkDoneProgressParams
+}
+
+/*RenameOptions defined:
+ * Provider options for a [RenameRequest](#RenameRequest).
+ */
+type RenameOptions struct {
+
+	/*PrepareProvider defined:
+	 * Renames should be checked and tested before being executed.
+	 *
+	 * @since version 3.12.0
+	 */
+	PrepareProvider bool `json:"prepareProvider,omitempty"`
+	WorkDoneProgressOptions
+}
+
+/*RenameRegistrationOptions defined:
+ * Registration options for a [RenameRequest](#RenameRequest).
+ */
+type RenameRegistrationOptions struct {
+	TextDocumentRegistrationOptions
+	RenameOptions
+}
+
+// PrepareRenameParams is
+type PrepareRenameParams struct {
+	TextDocumentPositionParams
+	WorkDoneProgressParams
+}
+
+/*ExecuteCommandClientCapabilities defined:
+ * The client capabilities of a [ExecuteCommandRequest](#ExecuteCommandRequest).
+ */
+type ExecuteCommandClientCapabilities struct {
+
+	/*DynamicRegistration defined:
+	 * Execute command supports dynamic registration.
+	 */
+	DynamicRegistration bool `json:"dynamicRegistration,omitempty"`
+}
+
+/*ExecuteCommandParams defined:
+ * The parameters of a [ExecuteCommandRequest](#ExecuteCommandRequest).
+ */
+type ExecuteCommandParams struct {
+
+	/*Command defined:
+	 * The identifier of the actual command handler.
+	 */
+	Command string `json:"command"`
+
+	/*Arguments defined:
+	 * Arguments that the command should be invoked with.
+	 */
+	Arguments []interface{} `json:"arguments,omitempty"`
+	WorkDoneProgressParams
+}
+
+/*ExecuteCommandOptions defined:
+ * The server capabilities of a [ExecuteCommandRequest](#ExecuteCommandRequest).
+ */
+type ExecuteCommandOptions struct {
+
+	/*Commands defined:
+	 * The commands to be executed on the server
+	 */
+	Commands []string `json:"commands"`
+	WorkDoneProgressOptions
+}
+
+/*ExecuteCommandRegistrationOptions defined:
+ * Registration options for a [ExecuteCommandRequest](#ExecuteCommandRequest).
+ */
+type ExecuteCommandRegistrationOptions struct {
+	ExecuteCommandOptions
+}
+
+// WorkspaceEditClientCapabilities is
+type WorkspaceEditClientCapabilities struct {
+
+	/*DocumentChanges defined:
+	 * The client supports versioned document changes in `WorkspaceEdit`s
+	 */
+	DocumentChanges bool `json:"documentChanges,omitempty"`
+
+	/*ResourceOperations defined:
+	 * The resource operations the client supports. Clients should at least
+	 * support 'create', 'rename' and 'delete' files and folders.
+	 *
+	 * @since 3.13.0
+	 */
+	ResourceOperations []ResourceOperationKind `json:"resourceOperations,omitempty"`
+
+	/*FailureHandling defined:
+	 * The failure handling strategy of a client if applying the workspace edit
+	 * fails.
+	 *
+	 * @since 3.13.0
+	 */
+	FailureHandling FailureHandlingKind `json:"failureHandling,omitempty"`
+}
+
+/*ApplyWorkspaceEditParams defined:
+ * The parameters passed via a apply workspace edit request.
+ */
+type ApplyWorkspaceEditParams struct {
+
+	/*Label defined:
+	 * An optional label of the workspace edit. This label is
+	 * presented in the user interface for example on an undo
+	 * stack to undo the workspace edit.
+	 */
+	Label string `json:"label,omitempty"`
+
+	/*Edit defined:
+	 * The edits to apply.
+	 */
+	Edit WorkspaceEdit `json:"edit"`
+}
+
+/*ApplyWorkspaceEditResponse defined:
+ * A response returned from the apply workspace edit request.
+ */
+type ApplyWorkspaceEditResponse struct {
+
+	/*Applied defined:
+	 * Indicates whether the edit was applied or not.
+	 */
+	Applied bool `json:"applied"`
+
+	/*FailureReason defined:
+	 * An optional textual description for why the edit was not applied.
+	 * This may be used by the server for diagnostic logging or to provide
+	 * a suitable error for a request that triggered the edit.
+	 */
+	FailureReason string `json:"failureReason,omitempty"`
+
+	/*FailedChange defined:
+	 * Depending on the client's failure handling strategy `failedChange` might
+	 * contain the index of the change that failed. This property is only available
+	 * if the client signals a `failureHandlingStrategy` in its client capabilities.
+	 */
+	FailedChange float64 `json:"failedChange,omitempty"`
+}
+
+/*Position defined:
+ * Position in a text document expressed as zero-based line and character offset.
+ * The offsets are based on a UTF-16 string representation. So a string of the form
+ * `a𐐀b` the character offset of the character `a` is 0, the character offset of `𐐀`
+ * is 1 and the character offset of b is 3 since `𐐀` is represented using two code
+ * units in UTF-16.
+ *
+ * Positions are line end character agnostic. So you can not specify a position that
+ * denotes `\r|\n` or `\n|` where `|` represents the character offset.
+ */
+type Position struct {
+
+	/*Line defined:
+	 * Line position in a document (zero-based).
+	 * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
+	 * If a line number is negative, it defaults to 0.
+	 */
+	Line float64 `json:"line"`
+
+	/*Character defined:
+	 * Character offset on a line in a document (zero-based). Assuming that the line is
+	 * represented as a string, the `character` value represents the gap between the
+	 * `character` and `character + 1`.
+	 *
+	 * If the character value is greater than the line length it defaults back to the
+	 * line length.
+	 * If a line number is negative, it defaults to 0.
+	 */
+	Character float64 `json:"character"`
+}
+
+/*Range defined:
+ * A range in a text document expressed as (zero-based) start and end positions.
+ *
+ * If you want to specify a range that contains a line including the line ending
+ * character(s) then use an end position denoting the start of the next line.
+ * For example:
+ * ```ts
+ * {
+ *     start: { line: 5, character: 23 }
+ *     end : { line 6, character : 0 }
+ * }
+ * ```
+ */
+type Range struct {
+
+	/*Start defined:
+	 * The range's start position
+	 */
+	Start Position `json:"start"`
+
+	/*End defined:
+	 * The range's end position.
+	 */
+	End Position `json:"end"`
+}
+
+/*Location defined:
+ * Represents a location inside a resource, such as a line
+ * inside a text file.
+ */
+type Location struct {
+
+	// URI is
+	URI DocumentURI `json:"uri"`
+
+	// Range is
+	Range Range `json:"range"`
+}
+
+/*LocationLink defined:
+ * Represents the connection of two locations. Provides additional metadata over normal [locations](#Location),
+ * including an origin range.
+ */
+type LocationLink struct {
+
+	/*OriginSelectionRange defined:
+	 * Span of the origin of this link.
+	 *
+	 * Used as the underlined span for mouse definition hover. Defaults to the word range at
+	 * the definition position.
+	 */
+	OriginSelectionRange *Range `json:"originSelectionRange,omitempty"`
+
+	/*TargetURI defined:
+	 * The target resource identifier of this link.
+	 */
+	TargetURI DocumentURI `json:"targetUri"`
+
+	/*TargetRange defined:
+	 * The full target range of this link. If the target for example is a symbol then target range is the
+	 * range enclosing this symbol not including leading/trailing whitespace but everything else
+	 * like comments. This information is typically used to highlight the range in the editor.
+	 */
+	TargetRange Range `json:"targetRange"`
+
+	/*TargetSelectionRange defined:
+	 * The range that should be selected and revealed when this link is being followed, e.g the name of a function.
+	 * Must be contained by the the `targetRange`. See also `DocumentSymbol#range`
+	 */
+	TargetSelectionRange Range `json:"targetSelectionRange"`
+}
+
+/*Color defined:
+ * Represents a color in RGBA space.
+ */
+type Color struct {
+
+	/*Red defined:
+	 * The red component of this color in the range [0-1].
+	 */
+	Red float64 `json:"red"`
+
+	/*Green defined:
+	 * The green component of this color in the range [0-1].
+	 */
+	Green float64 `json:"green"`
+
+	/*Blue defined:
+	 * The blue component of this color in the range [0-1].
+	 */
+	Blue float64 `json:"blue"`
+
+	/*Alpha defined:
+	 * The alpha component of this color in the range [0-1].
+	 */
+	Alpha float64 `json:"alpha"`
+}
+
+/*ColorInformation defined:
+ * Represents a color range from a document.
+ */
+type ColorInformation struct {
+
+	/*Range defined:
+	 * The range in the document where this color appers.
+	 */
+	Range Range `json:"range"`
+
+	/*Color defined:
+	 * The actual color value for this color range.
+	 */
+	Color Color `json:"color"`
+}
+
+// ColorPresentation is
+type ColorPresentation struct {
+
+	/*Label defined:
+	 * The label of this color presentation. It will be shown on the color
+	 * picker header. By default this is also the text that is inserted when selecting
+	 * this color presentation.
+	 */
+	Label string `json:"label"`
+
+	/*TextEdit defined:
+	 * An [edit](#TextEdit) which is applied to a document when selecting
+	 * this presentation for the color.  When `falsy` the [label](#ColorPresentation.label)
+	 * is used.
+	 */
+	TextEdit *TextEdit `json:"textEdit,omitempty"`
+
+	/*AdditionalTextEdits defined:
+	 * An optional array of additional [text edits](#TextEdit) that are applied when
+	 * selecting this color presentation. Edits must not overlap with the main [edit](#ColorPresentation.textEdit) nor with themselves.
+	 */
+	AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"`
+}
+
+/*DiagnosticRelatedInformation defined:
+ * Represents a related message and source code location for a diagnostic. This should be
+ * used to point to code locations that cause or related to a diagnostics, e.g when duplicating
+ * a symbol in a scope.
+ */
+type DiagnosticRelatedInformation struct {
+
+	/*Location defined:
+	 * The location of this related diagnostic information.
+	 */
+	Location Location `json:"location"`
+
+	/*Message defined:
+	 * The message of this related diagnostic information.
+	 */
+	Message string `json:"message"`
+}
+
+/*Diagnostic defined:
+ * Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
+ * are only valid in the scope of a resource.
+ */
+type Diagnostic struct {
+
+	/*Range defined:
+	 * The range at which the message applies
+	 */
+	Range Range `json:"range"`
+
+	/*Severity defined:
+	 * The diagnostic's severity. Can be omitted. If omitted it is up to the
+	 * client to interpret diagnostics as error, warning, info or hint.
+	 */
+	Severity DiagnosticSeverity `json:"severity,omitempty"`
+
+	/*Code defined:
+	 * The diagnostic's code, which usually appear in the user interface.
+	 */
+	Code interface{} `json:"code,omitempty"` // number | string
+
+	/*Source defined:
+	 * A human-readable string describing the source of this
+	 * diagnostic, e.g. 'typescript' or 'super lint'. It usually
+	 * appears in the user interface.
+	 */
+	Source string `json:"source,omitempty"`
+
+	/*Message defined:
+	 * The diagnostic's message. It usually appears in the user interface
+	 */
+	Message string `json:"message"`
+
+	/*Tags defined:
+	 * Additional metadata about the diagnostic.
+	 */
+	Tags []DiagnosticTag `json:"tags,omitempty"`
+
+	/*RelatedInformation defined:
+	 * An array of related diagnostic information, e.g. when symbol-names within
+	 * a scope collide all definitions can be marked via this property.
+	 */
+	RelatedInformation []DiagnosticRelatedInformation `json:"relatedInformation,omitempty"`
+}
+
+/*Command defined:
+ * Represents a reference to a command. Provides a title which
+ * will be used to represent a command in the UI and, optionally,
+ * an array of arguments which will be passed to the command handler
+ * function when invoked.
+ */
+type Command struct {
+
+	/*Title defined:
+	 * Title of the command, like `save`.
+	 */
+	Title string `json:"title"`
+
+	/*Command defined:
+	 * The identifier of the actual command handler.
+	 */
+	Command string `json:"command"`
+
+	/*Arguments defined:
+	 * Arguments that the command handler should be
+	 * invoked with.
+	 */
+	Arguments []interface{} `json:"arguments,omitempty"`
+}
+
+/*TextEdit defined:
+ * A text edit applicable to a text document.
+ */
+type TextEdit struct {
+
+	/*Range defined:
+	 * The range of the text document to be manipulated. To insert
+	 * text into a document create a range where start === end.
+	 */
+	Range Range `json:"range"`
+
+	/*NewText defined:
+	 * The string to be inserted. For delete operations use an
+	 * empty string.
+	 */
+	NewText string `json:"newText"`
+}
+
+/*TextDocumentEdit defined:
+ * Describes textual changes on a text document.
+ */
+type TextDocumentEdit struct {
+
+	/*TextDocument defined:
+	 * The text document to change.
+	 */
+	TextDocument VersionedTextDocumentIdentifier `json:"textDocument"`
+
+	/*Edits defined:
+	 * The edits to be applied.
+	 */
+	Edits []TextEdit `json:"edits"`
+}
+
+// ResourceOperation is
+type ResourceOperation struct {
+
+	// Kind is
+	Kind string `json:"kind"`
+}
+
+/*CreateFileOptions defined:
+ * Options to create a file.
+ */
+type CreateFileOptions struct {
+
+	/*Overwrite defined:
+	 * Overwrite existing file. Overwrite wins over `ignoreIfExists`
+	 */
+	Overwrite bool `json:"overwrite,omitempty"`
+
+	/*IgnoreIfExists defined:
+	 * Ignore if exists.
+	 */
+	IgnoreIfExists bool `json:"ignoreIfExists,omitempty"`
+}
+
+/*CreateFile defined:
+ * Create file operation.
+ */
+type CreateFile struct {
+
+	/*Kind defined:
+	 * A create
+	 */
+	Kind string `json:"kind"` // 'create'
+
+	/*URI defined:
+	 * The resource to create.
+	 */
+	URI DocumentURI `json:"uri"`
+
+	/*Options defined:
+	 * Additional options
+	 */
+	Options *CreateFileOptions `json:"options,omitempty"`
+}
+
+/*RenameFileOptions defined:
+ * Rename file options
+ */
+type RenameFileOptions struct {
+
+	/*Overwrite defined:
+	 * Overwrite target if existing. Overwrite wins over `ignoreIfExists`
+	 */
+	Overwrite bool `json:"overwrite,omitempty"`
+
+	/*IgnoreIfExists defined:
+	 * Ignores if target exists.
+	 */
+	IgnoreIfExists bool `json:"ignoreIfExists,omitempty"`
+}
+
+/*RenameFile defined:
+ * Rename file operation
+ */
+type RenameFile struct {
+
+	/*Kind defined:
+	 * A rename
+	 */
+	Kind string `json:"kind"` // 'rename'
+
+	/*OldURI defined:
+	 * The old (existing) location.
+	 */
+	OldURI DocumentURI `json:"oldUri"`
+
+	/*NewURI defined:
+	 * The new location.
+	 */
+	NewURI DocumentURI `json:"newUri"`
+
+	/*Options defined:
+	 * Rename options.
+	 */
+	Options *RenameFileOptions `json:"options,omitempty"`
+}
+
+/*DeleteFileOptions defined:
+ * Delete file options
+ */
+type DeleteFileOptions struct {
+
+	/*Recursive defined:
+	 * Delete the content recursively if a folder is denoted.
+	 */
+	Recursive bool `json:"recursive,omitempty"`
+
+	/*IgnoreIfNotExists defined:
+	 * Ignore the operation if the file doesn't exist.
+	 */
+	IgnoreIfNotExists bool `json:"ignoreIfNotExists,omitempty"`
+}
+
+/*DeleteFile defined:
+ * Delete file operation
+ */
+type DeleteFile struct {
+
+	/*Kind defined:
+	 * A delete
+	 */
+	Kind string `json:"kind"` // 'delete'
+
+	/*URI defined:
+	 * The file to delete.
+	 */
+	URI DocumentURI `json:"uri"`
+
+	/*Options defined:
+	 * Delete options.
+	 */
+	Options *DeleteFileOptions `json:"options,omitempty"`
+}
+
+/*WorkspaceEdit defined:
+ * A workspace edit represents changes to many resources managed in the workspace. The edit
+ * should either provide `changes` or `documentChanges`. If documentChanges are present
+ * they are preferred over `changes` if the client can handle versioned document edits.
+ */
+type WorkspaceEdit struct {
+
+	/*Changes defined:
+	 * Holds changes to existing resources.
+	 */
+	Changes *map[string][]TextEdit `json:"changes,omitempty"` // [uri: string]: TextEdit[];
+
+	/*DocumentChanges defined:
+	 * Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes
+	 * are either an array of `TextDocumentEdit`s to express changes to n different text documents
+	 * where each text document edit addresses a specific version of a text document. Or it can contain
+	 * above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations.
+	 *
+	 * Whether a client supports versioned document edits is expressed via
+	 * `workspace.workspaceEdit.documentChanges` client capability.
+	 *
+	 * If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then
+	 * only plain `TextEdit`s using the `changes` property are supported.
+	 */
+	DocumentChanges []TextDocumentEdit `json:"documentChanges,omitempty"` // (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)
+}
+
+/*TextEditChange defined:
+ * A change to capture text edits for existing resources.
+ */
+type TextEditChange struct {
+}
+
+/*TextDocumentIdentifier defined:
+ * A literal to identify a text document in the client.
+ */
+type TextDocumentIdentifier struct {
+
+	/*URI defined:
+	 * The text document's uri.
+	 */
+	URI DocumentURI `json:"uri"`
+}
+
+/*VersionedTextDocumentIdentifier defined:
+ * An identifier to denote a specific version of a text document.
+ */
+type VersionedTextDocumentIdentifier struct {
+
+	/*Version defined:
+	 * The version number of this document. If a versioned text document identifier
+	 * is sent from the server to the client and the file is not open in the editor
+	 * (the server has not received an open notification before) the server can send
+	 * `null` to indicate that the version is unknown and the content on disk is the
+	 * truth (as speced with document content ownership).
+	 */
+	Version float64 `json:"version"`
+	TextDocumentIdentifier
+}
+
+/*TextDocumentItem defined:
+ * An item to transfer a text document from the client to the
+ * server.
+ */
+type TextDocumentItem struct {
+
+	/*URI defined:
+	 * The text document's uri.
+	 */
+	URI DocumentURI `json:"uri"`
+
+	/*LanguageID defined:
+	 * The text document's language identifier
+	 */
+	LanguageID string `json:"languageId"`
+
+	/*Version defined:
+	 * The version number of this document (it will increase after each
+	 * change, including undo/redo).
+	 */
+	Version float64 `json:"version"`
+
+	/*Text defined:
+	 * The content of the opened text document.
+	 */
+	Text string `json:"text"`
+}
+
+/*MarkupContent defined:
+ * A `MarkupContent` literal represents a string value which content is interpreted base on its
+ * kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds.
+ *
+ * If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues.
+ * See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+ *
+ * Here is an example how such a string can be constructed using JavaScript / TypeScript:
+ * ```ts
+ * let markdown: MarkdownContent = {
+ *  kind: MarkupKind.Markdown,
+ *	value: [
+ *		'# Header',
+ *		'Some text',
+ *		'```typescript',
+ *		'someCode();',
+ *		'```'
+ *	].join('\n')
+ * };
+ * ```
+ *
+ * *Please Note* that clients might sanitize the return markdown. A client could decide to
+ * remove HTML from the markdown to avoid script execution.
+ */
+type MarkupContent struct {
+
+	/*Kind defined:
+	 * The type of the Markup
+	 */
+	Kind MarkupKind `json:"kind"`
+
+	/*Value defined:
+	 * The content itself
+	 */
+	Value string `json:"value"`
+}
+
+/*CompletionItem defined:
+ * A completion item represents a text snippet that is
+ * proposed to complete text that is being typed.
+ */
+type CompletionItem struct {
+
+	/*Label defined:
+	 * The label of this completion item. By default
+	 * also the text that is inserted when selecting
+	 * this completion.
+	 */
+	Label string `json:"label"`
+
+	/*Kind defined:
+	 * The kind of this completion item. Based of the kind
+	 * an icon is chosen by the editor.
+	 */
+	Kind CompletionItemKind `json:"kind,omitempty"`
+
+	/*Tags defined:
+	 * Tags for this completion item.
+	 *
+	 * @since 3.15.0
+	 */
+	Tags []CompletionItemTag `json:"tags,omitempty"`
+
+	/*Detail defined:
+	 * A human-readable string with additional information
+	 * about this item, like type or symbol information.
+	 */
+	Detail string `json:"detail,omitempty"`
+
+	/*Documentation defined:
+	 * A human-readable string that represents a doc-comment.
+	 */
+	Documentation string `json:"documentation,omitempty"` // string | MarkupContent
+
+	/*Deprecated defined:
+	 * Indicates if this item is deprecated.
+	 * @deprecated Use `tags` instead.
+	 */
+	Deprecated bool `json:"deprecated,omitempty"`
+
+	/*Preselect defined:
+	 * Select this item when showing.
+	 *
+	 * *Note* that only one completion item can be selected and that the
+	 * tool / client decides which item that is. The rule is that the *first*
+	 * item of those that match best is selected.
+	 */
+	Preselect bool `json:"preselect,omitempty"`
+
+	/*SortText defined:
+	 * A string that should be used when comparing this item
+	 * with other items. When `falsy` the [label](#CompletionItem.label)
+	 * is used.
+	 */
+	SortText string `json:"sortText,omitempty"`
+
+	/*FilterText defined:
+	 * A string that should be used when filtering a set of
+	 * completion items. When `falsy` the [label](#CompletionItem.label)
+	 * is used.
+	 */
+	FilterText string `json:"filterText,omitempty"`
+
+	/*InsertText defined:
+	 * A string that should be inserted into a document when selecting
+	 * this completion. When `falsy` the [label](#CompletionItem.label)
+	 * is used.
+	 *
+	 * The `insertText` is subject to interpretation by the client side.
+	 * Some tools might not take the string literally. For example
+	 * VS Code when code complete is requested in this example `con<cursor position>`
+	 * and a completion item with an `insertText` of `console` is provided it
+	 * will only insert `sole`. Therefore it is recommended to use `textEdit` instead
+	 * since it avoids additional client side interpretation.
+	 */
+	InsertText string `json:"insertText,omitempty"`
+
+	/*InsertTextFormat defined:
+	 * The format of the insert text. The format applies to both the `insertText` property
+	 * and the `newText` property of a provided `textEdit`.
+	 */
+	InsertTextFormat InsertTextFormat `json:"insertTextFormat,omitempty"`
+
+	/*TextEdit defined:
+	 * An [edit](#TextEdit) which is applied to a document when selecting
+	 * this completion. When an edit is provided the value of
+	 * [insertText](#CompletionItem.insertText) is ignored.
+	 *
+	 * *Note:* The text edit's range must be a [single line] and it must contain the position
+	 * at which completion has been requested.
+	 */
+	TextEdit *TextEdit `json:"textEdit,omitempty"`
+
+	/*AdditionalTextEdits defined:
+	 * An optional array of additional [text edits](#TextEdit) that are applied when
+	 * selecting this completion. Edits must not overlap (including the same insert position)
+	 * with the main [edit](#CompletionItem.textEdit) nor with themselves.
+	 *
+	 * Additional text edits should be used to change text unrelated to the current cursor position
+	 * (for example adding an import statement at the top of the file if the completion item will
+	 * insert an unqualified type).
+	 */
+	AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"`
+
+	/*CommitCharacters defined:
+	 * An optional set of characters that when pressed while this completion is active will accept it first and
+	 * then type that character. *Note* that all commit characters should have `length=1` and that superfluous
+	 * characters will be ignored.
+	 */
+	CommitCharacters []string `json:"commitCharacters,omitempty"`
+
+	/*Command defined:
+	 * An optional [command](#Command) that is executed *after* inserting this completion. *Note* that
+	 * additional modifications to the current document should be described with the
+	 * [additionalTextEdits](#CompletionItem.additionalTextEdits)-property.
+	 */
+	Command *Command `json:"command,omitempty"`
+
+	/*Data defined:
+	 * An data entry field that is preserved on a completion item between
+	 * a [CompletionRequest](#CompletionRequest) and a [CompletionResolveRequest]
+	 * (#CompletionResolveRequest)
+	 */
+	Data interface{} `json:"data,omitempty"`
+}
+
+/*CompletionList defined:
+ * Represents a collection of [completion items](#CompletionItem) to be presented
+ * in the editor.
+ */
+type CompletionList struct {
+
+	/*IsIncomplete defined:
+	 * This list it not complete. Further typing results in recomputing this list.
+	 */
+	IsIncomplete bool `json:"isIncomplete"`
+
+	/*Items defined:
+	 * The completion items.
+	 */
+	Items []CompletionItem `json:"items"`
+}
+
+/*Hover defined:
+ * The result of a hover request.
+ */
+type Hover struct {
+
+	/*Contents defined:
+	 * The hover's content
+	 */
+	Contents MarkupContent `json:"contents"` // MarkupContent | MarkedString | MarkedString[]
+
+	/*Range defined:
+	 * An optional range
+	 */
+	Range *Range `json:"range,omitempty"`
+}
+
+/*ParameterInformation defined:
+ * Represents a parameter of a callable-signature. A parameter can
+ * have a label and a doc-comment.
+ */
+type ParameterInformation struct {
+
+	/*Label defined:
+	 * The label of this parameter information.
+	 *
+	 * Either a string or an inclusive start and exclusive end offsets within its containing
+	 * signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
+	 * string representation as `Position` and `Range` does.
+	 *
+	 * *Note*: a label of type string should be a substring of its containing signature label.
+	 * Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
+	 */
+	Label string `json:"label"` // string | [number, number]
+
+	/*Documentation defined:
+	 * The human-readable doc-comment of this signature. Will be shown
+	 * in the UI but can be omitted.
+	 */
+	Documentation string `json:"documentation,omitempty"` // string | MarkupContent
+}
+
+/*SignatureInformation defined:
+ * Represents the signature of something callable. A signature
+ * can have a label, like a function-name, a doc-comment, and
+ * a set of parameters.
+ */
+type SignatureInformation struct {
+
+	/*Label defined:
+	 * The label of this signature. Will be shown in
+	 * the UI.
+	 */
+	Label string `json:"label"`
+
+	/*Documentation defined:
+	 * The human-readable doc-comment of this signature. Will be shown
+	 * in the UI but can be omitted.
+	 */
+	Documentation string `json:"documentation,omitempty"` // string | MarkupContent
+
+	/*Parameters defined:
+	 * The parameters of this signature.
+	 */
+	Parameters []ParameterInformation `json:"parameters,omitempty"`
+}
+
+/*SignatureHelp defined:
+ * Signature help represents the signature of something
+ * callable. There can be multiple signature but only one
+ * active and only one active parameter.
+ */
+type SignatureHelp struct {
+
+	/*Signatures defined:
+	 * One or more signatures.
+	 */
+	Signatures []SignatureInformation `json:"signatures"`
+
+	/*ActiveSignature defined:
+	 * The active signature. Set to `null` if no
+	 * signatures exist.
+	 */
+	ActiveSignature float64 `json:"activeSignature"`
+
+	/*ActiveParameter defined:
+	 * The active parameter of the active signature. Set to `null`
+	 * if the active signature has no parameters.
+	 */
+	ActiveParameter float64 `json:"activeParameter"`
+}
+
+/*ReferenceContext defined:
+ * Value-object that contains additional information when
+ * requesting references.
+ */
+type ReferenceContext struct {
+
+	/*IncludeDeclaration defined:
+	 * Include the declaration of the current symbol.
+	 */
+	IncludeDeclaration bool `json:"includeDeclaration"`
+}
+
+/*DocumentHighlight defined:
+ * A document highlight is a range inside a text document which deserves
+ * special attention. Usually a document highlight is visualized by changing
+ * the background color of its range.
+ */
+type DocumentHighlight struct {
+
+	/*Range defined:
+	 * The range this highlight applies to.
+	 */
+	Range Range `json:"range"`
+
+	/*Kind defined:
+	 * The highlight kind, default is [text](#DocumentHighlightKind.Text).
+	 */
+	Kind *DocumentHighlightKind `json:"kind,omitempty"`
+}
+
+/*SymbolInformation defined:
+ * Represents information about programming constructs like variables, classes,
+ * interfaces etc.
+ */
+type SymbolInformation struct {
+
+	/*Name defined:
+	 * The name of this symbol.
+	 */
+	Name string `json:"name"`
+
+	/*Kind defined:
+	 * The kind of this symbol.
+	 */
+	Kind SymbolKind `json:"kind"`
+
+	/*Deprecated defined:
+	 * Indicates if this symbol is deprecated.
+	 */
+	Deprecated bool `json:"deprecated,omitempty"`
+
+	/*Location defined:
+	 * The location of this symbol. The location's range is used by a tool
+	 * to reveal the location in the editor. If the symbol is selected in the
+	 * tool the range's start information is used to position the cursor. So
+	 * the range usually spans more than the actual symbol's name and does
+	 * normally include thinks like visibility modifiers.
+	 *
+	 * The range doesn't have to denote a node range in the sense of a abstract
+	 * syntax tree. It can therefore not be used to re-construct a hierarchy of
+	 * the symbols.
+	 */
+	Location Location `json:"location"`
+
+	/*ContainerName defined:
+	 * The name of the symbol containing this symbol. This information is for
+	 * user interface purposes (e.g. to render a qualifier in the user interface
+	 * if necessary). It can't be used to re-infer a hierarchy for the document
+	 * symbols.
+	 */
+	ContainerName string `json:"containerName,omitempty"`
+}
+
+/*DocumentSymbol defined:
+ * Represents programming constructs like variables, classes, interfaces etc.
+ * that appear in a document. Document symbols can be hierarchical and they
+ * have two ranges: one that encloses its definition and one that points to
+ * its most interesting range, e.g. the range of an identifier.
+ */
+type DocumentSymbol struct {
+
+	/*Name defined:
+	 * The name of this symbol. Will be displayed in the user interface and therefore must not be
+	 * an empty string or a string only consisting of white spaces.
+	 */
+	Name string `json:"name"`
+
+	/*Detail defined:
+	 * More detail for this symbol, e.g the signature of a function.
+	 */
+	Detail string `json:"detail,omitempty"`
+
+	/*Kind defined:
+	 * The kind of this symbol.
+	 */
+	Kind SymbolKind `json:"kind"`
+
+	/*Deprecated defined:
+	 * Indicates if this symbol is deprecated.
+	 */
+	Deprecated bool `json:"deprecated,omitempty"`
+
+	/*Range defined:
+	 * The range enclosing this symbol not including leading/trailing whitespace but everything else
+	 * like comments. This information is typically used to determine if the the clients cursor is
+	 * inside the symbol to reveal in the symbol in the UI.
+	 */
+	Range Range `json:"range"`
+
+	/*SelectionRange defined:
+	 * The range that should be selected and revealed when this symbol is being picked, e.g the name of a function.
+	 * Must be contained by the the `range`.
+	 */
+	SelectionRange Range `json:"selectionRange"`
+
+	/*Children defined:
+	 * Children of this symbol, e.g. properties of a class.
+	 */
+	Children []DocumentSymbol `json:"children,omitempty"`
+}
+
+/*CodeActionContext defined:
+ * Contains additional diagnostic information about the context in which
+ * a [code action](#CodeActionProvider.provideCodeActions) is run.
+ */
+type CodeActionContext struct {
+
+	/*Diagnostics defined:
+	 * An array of diagnostics known on the client side overlapping the range provided to the
+	 * `textDocument/codeAction` request. They are provied so that the server knows which
+	 * errors are currently presented to the user for the given range. There is no guarantee
+	 * that these accurately reflect the error state of the resource. The primary parameter
+	 * to compute code actions is the provided range.
+	 */
+	Diagnostics []Diagnostic `json:"diagnostics"`
+
+	/*Only defined:
+	 * Requested kind of actions to return.
+	 *
+	 * Actions not of this kind are filtered out by the client before being shown. So servers
+	 * can omit computing them.
+	 */
+	Only []CodeActionKind `json:"only,omitempty"`
+}
+
+/*CodeAction defined:
+ * A code action represents a change that can be performed in code, e.g. to fix a problem or
+ * to refactor code.
+ *
+ * A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed.
+ */
+type CodeAction struct {
+
+	/*Title defined:
+	 * A short, human-readable, title for this code action.
+	 */
+	Title string `json:"title"`
+
+	/*Kind defined:
+	 * The kind of the code action.
+	 *
+	 * Used to filter code actions.
+	 */
+	Kind CodeActionKind `json:"kind,omitempty"`
+
+	/*Diagnostics defined:
+	 * The diagnostics that this code action resolves.
+	 */
+	Diagnostics []Diagnostic `json:"diagnostics,omitempty"`
+
+	/*IsPreferred defined:
+	 * Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted
+	 * by keybindings.
+	 *
+	 * A quick fix should be marked preferred if it properly addresses the underlying error.
+	 * A refactoring should be marked preferred if it is the most reasonable choice of actions to take.
+	 *
+	 * @since 3.15.0
+	 */
+	IsPreferred bool `json:"isPreferred,omitempty"`
+
+	/*Edit defined:
+	 * The workspace edit this code action performs.
+	 */
+	Edit *WorkspaceEdit `json:"edit,omitempty"`
+
+	/*Command defined:
+	 * A command this code action executes. If a code action
+	 * provides a edit and a command, first the edit is
+	 * executed and then the command.
+	 */
+	Command *Command `json:"command,omitempty"`
+}
+
+/*CodeLens defined:
+ * A code lens represents a [command](#Command) that should be shown along with
+ * source text, like the number of references, a way to run tests, etc.
+ *
+ * A code lens is _unresolved_ when no command is associated to it. For performance
+ * reasons the creation of a code lens and resolving should be done to two stages.
+ */
+type CodeLens struct {
+
+	/*Range defined:
+	 * The range in which this code lens is valid. Should only span a single line.
+	 */
+	Range Range `json:"range"`
+
+	/*Command defined:
+	 * The command this code lens represents.
+	 */
+	Command *Command `json:"command,omitempty"`
+
+	/*Data defined:
+	 * An data entry field that is preserved on a code lens item between
+	 * a [CodeLensRequest](#CodeLensRequest) and a [CodeLensResolveRequest]
+	 * (#CodeLensResolveRequest)
+	 */
+	Data interface{} `json:"data,omitempty"`
+}
+
+/*FormattingOptions defined:
+ * Value-object describing what options formatting should use.
+ */
+type FormattingOptions struct {
+
+	/*TabSize defined:
+	 * Size of a tab in spaces.
+	 */
+	TabSize float64 `json:"tabSize"`
+
+	/*InsertSpaces defined:
+	 * Prefer spaces over tabs.
+	 */
+	InsertSpaces bool `json:"insertSpaces"`
+
+	/*TrimTrailingWhitespace defined:
+	 * Trim trailing whitespaces on a line.
+	 *
+	 * @since 3.15.0
+	 */
+	TrimTrailingWhitespace bool `json:"trimTrailingWhitespace,omitempty"`
+
+	/*InsertFinalNewline defined:
+	 * Insert a newline character at the end of the file if one does not exist.
+	 *
+	 * @since 3.15.0
+	 */
+	InsertFinalNewline bool `json:"insertFinalNewline,omitempty"`
+
+	/*TrimFinalNewlines defined:
+	 * Trim all newlines after the final newline at the end of the file.
+	 *
+	 * @since 3.15.0
+	 */
+	TrimFinalNewlines bool `json:"trimFinalNewlines,omitempty"`
+
+	/*Key defined:
+	 * Signature for further properties.
+	 */
+	Key map[string]bool `json:"key"` // [key: string]: boolean | number | string | undefined;
+}
+
+/*DocumentLink defined:
+ * A document link is a range in a text document that links to an internal or external resource, like another
+ * text document or a web site.
+ */
+type DocumentLink struct {
+
+	/*Range defined:
+	 * The range this link applies to.
+	 */
+	Range Range `json:"range"`
+
+	/*Target defined:
+	 * The uri this link points to.
+	 */
+	Target string `json:"target,omitempty"`
+
+	/*Tooltip defined:
+	 * The tooltip text when you hover over this link.
+	 *
+	 * If a tooltip is provided, is will be displayed in a string that includes instructions on how to
+	 * trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS,
+	 * user settings, and localization.
+	 *
+	 * @since 3.15.0
+	 */
+	Tooltip string `json:"tooltip,omitempty"`
+
+	/*Data defined:
+	 * A data entry field that is preserved on a document link between a
+	 * DocumentLinkRequest and a DocumentLinkResolveRequest.
+	 */
+	Data interface{} `json:"data,omitempty"`
+}
+
+/*SelectionRange defined:
+ * A selection range represents a part of a selection hierarchy. A selection range
+ * may have a parent selection range that contains it.
+ */
+type SelectionRange struct {
+
+	/*Range defined:
+	 * The [range](#Range) of this selection range.
+	 */
+	Range Range `json:"range"`
+
+	/*Parent defined:
+	 * The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
+	 */
+	Parent *SelectionRange `json:"parent,omitempty"`
+}
+
+/*TextDocument defined:
+ * A simple text document. Not to be implemented.
+ */
+type TextDocument struct {
+
+	/*URI defined:
+	 * The associated URI for this document. Most documents have the __file__-scheme, indicating that they
+	 * represent files on disk. However, some documents may have other schemes indicating that they are not
+	 * available on disk.
+	 *
+	 * @readonly
+	 */
+	URI DocumentURI `json:"uri"`
+
+	/*LanguageID defined:
+	 * The identifier of the language associated with this document.
+	 *
+	 * @readonly
+	 */
+	LanguageID string `json:"languageId"`
+
+	/*Version defined:
+	 * The version number of this document (it will increase after each
+	 * change, including undo/redo).
+	 *
+	 * @readonly
+	 */
+	Version float64 `json:"version"`
+
+	/*LineCount defined:
+	 * The number of lines in this document.
+	 *
+	 * @readonly
+	 */
+	LineCount float64 `json:"lineCount"`
+}
+
+/*TextDocumentChangeEvent defined:
+ * Event to signal changes to a simple text document.
+ */
+type TextDocumentChangeEvent struct {
+
+	/*Document defined:
+	 * The document that has changed.
+	 */
+	Document TextDocument `json:"document"`
+}
+
+// TextDocumentWillSaveEvent is
+type TextDocumentWillSaveEvent struct {
+
+	/*Document defined:
+	 * The document that will be saved
+	 */
+	Document TextDocument `json:"document"`
+
+	/*Reason defined:
+	 * The reason why save was triggered.
+	 */
+	Reason TextDocumentSaveReason `json:"reason"`
+}
+
+/*TextDocumentContentChangeEvent defined:
+ * An event describing a change to a text document. If range and rangeLength are omitted
+ * the new text is considered to be the full content of the document.
+ */
+type TextDocumentContentChangeEvent struct {
+
+	/*Range defined:
+	 * The range of the document that changed.
+	 */
+	Range *Range `json:"range,omitempty"`
+
+	/*RangeLength defined:
+	 * The length of the range that got replaced.
+	 */
+	RangeLength float64 `json:"rangeLength,omitempty"`
+
+	/*Text defined:
+	 * The new text of the document.
+	 */
+	Text string `json:"text"`
+}
+
+// ProgressParams is
+type ProgressParams struct {
+
+	/*Token defined:
+	 * The progress token provided by the client or server.
+	 */
+	Token ProgressToken `json:"token"`
+
+	/*Value defined:
+	 * The progress data.
+	 */
+	Value interface{} `json:"value"`
+}
+
+// SetTraceParams is
+type SetTraceParams struct {
+
+	// Value is
+	Value TraceValues `json:"value"`
+}
+
+// LogTraceParams is
+type LogTraceParams struct {
+
+	// Message is
+	Message string `json:"message"`
+
+	// Verbose is
+	Verbose string `json:"verbose,omitempty"`
+}
+
+// Tracer is
+type Tracer struct {
+}
+
+// FoldingRangeKind defines constants
+type FoldingRangeKind string
+
+// ResourceOperationKind defines constants
+type ResourceOperationKind string
+
+// FailureHandlingKind defines constants
+type FailureHandlingKind string
+
+// InitializeError defines constants
+type InitializeError float64
+
+// MessageType defines constants
+type MessageType float64
+
+// TextDocumentSyncKind defines constants
+type TextDocumentSyncKind float64
+
+// FileChangeType defines constants
+type FileChangeType float64
+
+// WatchKind defines constants
+type WatchKind float64
+
+// CompletionTriggerKind defines constants
+type CompletionTriggerKind float64
+
+// SignatureHelpTriggerKind defines constants
+type SignatureHelpTriggerKind float64
+
+// DiagnosticSeverity defines constants
+type DiagnosticSeverity float64
+
+// DiagnosticTag defines constants
+type DiagnosticTag float64
+
+// MarkupKind defines constants
+type MarkupKind string
+
+// CompletionItemKind defines constants
+type CompletionItemKind float64
+
+// InsertTextFormat defines constants
+type InsertTextFormat float64
+
+// CompletionItemTag defines constants
+type CompletionItemTag float64
+
+// DocumentHighlightKind defines constants
+type DocumentHighlightKind float64
+
+// SymbolKind defines constants
+type SymbolKind float64
+
+// CodeActionKind defines constants
+type CodeActionKind string
+
+// TextDocumentSaveReason defines constants
+type TextDocumentSaveReason float64
+
+// ErrorCodes defines constants
+type ErrorCodes float64
+
+// Touch defines constants
+type Touch float64
+
+// Trace defines constants
+type Trace string
+
+// TraceFormat defines constants
+type TraceFormat string
+
+// ConnectionErrors defines constants
+type ConnectionErrors float64
+
+// ConnectionState defines constants
+type ConnectionState float64
+
+const (
+
+	/*Comment defined:
+	 * Folding range for a comment
+	 */
+	Comment FoldingRangeKind = "comment"
+
+	/*Imports defined:
+	 * Folding range for a imports or includes
+	 */
+	Imports FoldingRangeKind = "imports"
+
+	/*Region defined:
+	 * Folding range for a region (e.g. `#region`)
+	 */
+	Region FoldingRangeKind = "region"
+
+	/*Create defined:
+	 * Supports creating new files and folders.
+	 */
+	Create ResourceOperationKind = "create"
+
+	/*Rename defined:
+	 * Supports renaming existing files and folders.
+	 */
+	Rename ResourceOperationKind = "rename"
+
+	/*Delete defined:
+	 * Supports deleting existing files and folders.
+	 */
+	Delete ResourceOperationKind = "delete"
+
+	/*Abort defined:
+	 * Applying the workspace change is simply aborted if one of the changes provided
+	 * fails. All operations executed before the failing operation stay executed.
+	 */
+	Abort FailureHandlingKind = "abort"
+
+	/*Transactional defined:
+	 * All operations are executed transactional. That means they either all
+	 * succeed or no changes at all are applied to the workspace.
+	 */
+	Transactional FailureHandlingKind = "transactional"
+
+	/*TextOnlyTransactional defined:
+	 * If the workspace edit contains only textual file changes they are executed transactional.
+	 * If resource changes (create, rename or delete file) are part of the change the failure
+	 * handling startegy is abort.
+	 */
+	TextOnlyTransactional FailureHandlingKind = "textOnlyTransactional"
+
+	/*Undo defined:
+	 * The client tries to undo the operations already executed. But there is no
+	 * guaruntee that this is succeeding.
+	 */
+	Undo FailureHandlingKind = "undo"
+
+	/*UnknownProtocolVersion defined:
+	 * If the protocol version provided by the client can't be handled by the server.
+	 * @deprecated This initialize error got replaced by client capabilities. There is
+	 * no version handshake in version 3.0x
+	 */
+	UnknownProtocolVersion InitializeError = 1
+
+	/*Error defined:
+	 * An error message.
+	 */
+	Error MessageType = 1
+
+	/*Warning defined:
+	 * A warning message.
+	 */
+	Warning MessageType = 2
+
+	/*Info defined:
+	 * An information message.
+	 */
+	Info MessageType = 3
+
+	/*Log defined:
+	 * A log message.
+	 */
+	Log MessageType = 4
+
+	/*None defined:
+	 * Documents should not be synced at all.
+	 */
+	None TextDocumentSyncKind = 0
+
+	/*Full defined:
+	 * Documents are synced by always sending the full content
+	 * of the document.
+	 */
+	Full TextDocumentSyncKind = 1
+
+	/*Incremental defined:
+	 * Documents are synced by sending the full content on open.
+	 * After that only incremental updates to the document are
+	 * send.
+	 */
+	Incremental TextDocumentSyncKind = 2
+
+	/*Created defined:
+	 * The file got created.
+	 */
+	Created FileChangeType = 1
+
+	/*Changed defined:
+	 * The file got changed.
+	 */
+	Changed FileChangeType = 2
+
+	/*Deleted defined:
+	 * The file got deleted.
+	 */
+	Deleted FileChangeType = 3
+
+	/*WatchCreate defined:
+	 * Interested in create events.
+	 */
+	WatchCreate WatchKind = 1
+
+	/*WatchChange defined:
+	 * Interested in change events
+	 */
+	WatchChange WatchKind = 2
+
+	/*WatchDelete defined:
+	 * Interested in delete events
+	 */
+	WatchDelete WatchKind = 4
+
+	/*Invoked defined:
+	 * Completion was triggered by typing an identifier (24x7 code
+	 * complete), manual invocation (e.g Ctrl+Space) or via API.
+	 */
+	Invoked CompletionTriggerKind = 1
+
+	/*TriggerCharacter defined:
+	 * Completion was triggered by a trigger character specified by
+	 * the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
+	 */
+	TriggerCharacter CompletionTriggerKind = 2
+
+	/*TriggerForIncompleteCompletions defined:
+	 * Completion was re-triggered as current completion list is incomplete
+	 */
+	TriggerForIncompleteCompletions CompletionTriggerKind = 3
+
+	/*ContentChange defined:
+	 * Signature help was triggered by the cursor moving or by the document content changing.
+	 */
+	ContentChange SignatureHelpTriggerKind = 3
+
+	/*SeverityError defined:
+	 * Reports an error.
+	 */
+	SeverityError DiagnosticSeverity = 1
+
+	/*SeverityWarning defined:
+	 * Reports a warning.
+	 */
+	SeverityWarning DiagnosticSeverity = 2
+
+	/*SeverityInformation defined:
+	 * Reports an information.
+	 */
+	SeverityInformation DiagnosticSeverity = 3
+
+	/*SeverityHint defined:
+	 * Reports a hint.
+	 */
+	SeverityHint DiagnosticSeverity = 4
+
+	/*Unnecessary defined:
+	 * Unused or unnecessary code.
+	 *
+	 * Clients are allowed to render diagnostics with this tag faded out instead of having
+	 * an error squiggle.
+	 */
+	Unnecessary DiagnosticTag = 1
+
+	/*Deprecated defined:
+	 * Deprecated or obsolete code.
+	 *
+	 * Clients are allowed to rendered diagnostics with this tag strike through.
+	 */
+	Deprecated DiagnosticTag = 2
+
+	/*PlainText defined:
+	 * Plain text is supported as a content format
+	 */
+	PlainText MarkupKind = "plaintext"
+
+	/*Markdown defined:
+	 * Markdown is supported as a content format
+	 */
+	Markdown MarkupKind = "markdown"
+
+	// TextCompletion is
+	TextCompletion CompletionItemKind = 1
+
+	// MethodCompletion is
+	MethodCompletion CompletionItemKind = 2
+
+	// FunctionCompletion is
+	FunctionCompletion CompletionItemKind = 3
+
+	// ConstructorCompletion is
+	ConstructorCompletion CompletionItemKind = 4
+
+	// FieldCompletion is
+	FieldCompletion CompletionItemKind = 5
+
+	// VariableCompletion is
+	VariableCompletion CompletionItemKind = 6
+
+	// ClassCompletion is
+	ClassCompletion CompletionItemKind = 7
+
+	// InterfaceCompletion is
+	InterfaceCompletion CompletionItemKind = 8
+
+	// ModuleCompletion is
+	ModuleCompletion CompletionItemKind = 9
+
+	// PropertyCompletion is
+	PropertyCompletion CompletionItemKind = 10
+
+	// UnitCompletion is
+	UnitCompletion CompletionItemKind = 11
+
+	// ValueCompletion is
+	ValueCompletion CompletionItemKind = 12
+
+	// EnumCompletion is
+	EnumCompletion CompletionItemKind = 13
+
+	// KeywordCompletion is
+	KeywordCompletion CompletionItemKind = 14
+
+	// SnippetCompletion is
+	SnippetCompletion CompletionItemKind = 15
+
+	// ColorCompletion is
+	ColorCompletion CompletionItemKind = 16
+
+	// FileCompletion is
+	FileCompletion CompletionItemKind = 17
+
+	// ReferenceCompletion is
+	ReferenceCompletion CompletionItemKind = 18
+
+	// FolderCompletion is
+	FolderCompletion CompletionItemKind = 19
+
+	// EnumMemberCompletion is
+	EnumMemberCompletion CompletionItemKind = 20
+
+	// ConstantCompletion is
+	ConstantCompletion CompletionItemKind = 21
+
+	// StructCompletion is
+	StructCompletion CompletionItemKind = 22
+
+	// EventCompletion is
+	EventCompletion CompletionItemKind = 23
+
+	// OperatorCompletion is
+	OperatorCompletion CompletionItemKind = 24
+
+	// TypeParameterCompletion is
+	TypeParameterCompletion CompletionItemKind = 25
+
+	/*PlainTextTextFormat defined:
+	 * The primary text to be inserted is treated as a plain string.
+	 */
+	PlainTextTextFormat InsertTextFormat = 1
+
+	/*SnippetTextFormat defined:
+	 * The primary text to be inserted is treated as a snippet.
+	 *
+	 * A snippet can define tab stops and placeholders with `$1`, `$2`
+	 * and `${3:foo}`. `$0` defines the final tab stop, it defaults to
+	 * the end of the snippet. Placeholders with equal identifiers are linked,
+	 * that is typing in one will update others too.
+	 *
+	 * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md
+	 */
+	SnippetTextFormat InsertTextFormat = 2
+
+	/*Text defined:
+	 * A textual occurrence.
+	 */
+	Text DocumentHighlightKind = 1
+
+	/*Read defined:
+	 * Read-access of a symbol, like reading a variable.
+	 */
+	Read DocumentHighlightKind = 2
+
+	/*Write defined:
+	 * Write-access of a symbol, like writing to a variable.
+	 */
+	Write DocumentHighlightKind = 3
+
+	// File is
+	File SymbolKind = 1
+
+	// Module is
+	Module SymbolKind = 2
+
+	// Namespace is
+	Namespace SymbolKind = 3
+
+	// Package is
+	Package SymbolKind = 4
+
+	// Class is
+	Class SymbolKind = 5
+
+	// Method is
+	Method SymbolKind = 6
+
+	// Property is
+	Property SymbolKind = 7
+
+	// Field is
+	Field SymbolKind = 8
+
+	// Constructor is
+	Constructor SymbolKind = 9
+
+	// Enum is
+	Enum SymbolKind = 10
+
+	// Interface is
+	Interface SymbolKind = 11
+
+	// Function is
+	Function SymbolKind = 12
+
+	// Variable is
+	Variable SymbolKind = 13
+
+	// Constant is
+	Constant SymbolKind = 14
+
+	// String is
+	String SymbolKind = 15
+
+	// Number is
+	Number SymbolKind = 16
+
+	// Boolean is
+	Boolean SymbolKind = 17
+
+	// Array is
+	Array SymbolKind = 18
+
+	// Object is
+	Object SymbolKind = 19
+
+	// Key is
+	Key SymbolKind = 20
+
+	// Null is
+	Null SymbolKind = 21
+
+	// EnumMember is
+	EnumMember SymbolKind = 22
+
+	// Struct is
+	Struct SymbolKind = 23
+
+	// Event is
+	Event SymbolKind = 24
+
+	// Operator is
+	Operator SymbolKind = 25
+
+	// TypeParameter is
+	TypeParameter SymbolKind = 26
+
+	/*Empty defined:
+	 * Empty kind.
+	 */
+	Empty CodeActionKind = ""
+
+	/*QuickFix defined:
+	 * Base kind for quickfix actions: 'quickfix'
+	 */
+	QuickFix CodeActionKind = "quickfix"
+
+	/*Refactor defined:
+	 * Base kind for refactoring actions: 'refactor'
+	 */
+	Refactor CodeActionKind = "refactor"
+
+	/*RefactorExtract defined:
+	 * Base kind for refactoring extraction actions: 'refactor.extract'
+	 *
+	 * Example extract actions:
+	 *
+	 * - Extract method
+	 * - Extract function
+	 * - Extract variable
+	 * - Extract interface from class
+	 * - ...
+	 */
+	RefactorExtract CodeActionKind = "refactor.extract"
+
+	/*RefactorInline defined:
+	 * Base kind for refactoring inline actions: 'refactor.inline'
+	 *
+	 * Example inline actions:
+	 *
+	 * - Inline function
+	 * - Inline variable
+	 * - Inline constant
+	 * - ...
+	 */
+	RefactorInline CodeActionKind = "refactor.inline"
+
+	/*RefactorRewrite defined:
+	 * Base kind for refactoring rewrite actions: 'refactor.rewrite'
+	 *
+	 * Example rewrite actions:
+	 *
+	 * - Convert JavaScript function to class
+	 * - Add or remove parameter
+	 * - Encapsulate field
+	 * - Make method static
+	 * - Move method to base class
+	 * - ...
+	 */
+	RefactorRewrite CodeActionKind = "refactor.rewrite"
+
+	/*Source defined:
+	 * Base kind for source actions: `source`
+	 *
+	 * Source code actions apply to the entire file.
+	 */
+	Source CodeActionKind = "source"
+
+	/*SourceOrganizeImports defined:
+	 * Base kind for an organize imports source action: `source.organizeImports`
+	 */
+	SourceOrganizeImports CodeActionKind = "source.organizeImports"
+
+	/*Manual defined:
+	 * Manually triggered, e.g. by the user pressing save, by starting debugging,
+	 * or by an API call.
+	 */
+	Manual TextDocumentSaveReason = 1
+
+	/*AfterDelay defined:
+	 * Automatic after a delay.
+	 */
+	AfterDelay TextDocumentSaveReason = 2
+
+	/*FocusOut defined:
+	 * When the editor lost focus.
+	 */
+	FocusOut TextDocumentSaveReason = 3
+
+	// MessageWriteError is
+	MessageWriteError ErrorCodes = 1
+
+	// MessageReadError is
+	MessageReadError ErrorCodes = 2
+
+	// First is
+	First Touch = 1
+
+	// Last is
+	Last Touch = 2
+
+	// JSON is
+	JSON TraceFormat = "json"
+
+	/*Closed defined:
+	 * The connection is closed.
+	 */
+	Closed ConnectionErrors = 1
+
+	/*Disposed defined:
+	 * The connection got disposed.
+	 */
+	Disposed ConnectionErrors = 2
+
+	/*AlreadyListening defined:
+	 * The connection is already in listening mode.
+	 */
+	AlreadyListening ConnectionErrors = 3
+
+	// New is
+	New ConnectionState = 1
+
+	// Listening is
+	Listening ConnectionState = 2
+)
+
+// DocumentFilter is a type
+/**
+ * A document filter denotes a document by different properties like
+ * the [language](#TextDocument.languageId), the [scheme](#Uri.scheme) of
+ * its resource, or a glob-pattern that is applied to the [path](#TextDocument.fileName).
+ *
+ * Glob patterns can have the following syntax:
+ * - `*` to match one or more characters in a path segment
+ * - `?` to match on one character in a path segment
+ * - `**` to match any number of path segments, including none
+ * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files)
+ * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
+ * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
+ *
+ * @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }`
+ * @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }`
+ */
+type DocumentFilter = struct {
+
+	/*Language defined: A language id, like `typescript`. */
+	Language string `json:"language,omitempty"`
+
+	/*Scheme defined: A Uri [scheme](#Uri.scheme), like `file` or `untitled`. */
+	Scheme string `json:"scheme,omitempty"`
+
+	/*Pattern defined: A glob pattern, like `*.{ts,js}`. */
+	Pattern string `json:"pattern,omitempty"`
+}
+
+// DocumentSelector is a type
+/**
+ * A document selector is the combination of one or many document filters.
+ *
+ * @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`;
+ */
+type DocumentSelector = []DocumentFilter
+
+// DocumentURI is a type
+/**
+ * A tagging type for string properties that are actually URIs.
+ */
+type DocumentURI = string
+
+// MarkedString is a type
+/**
+ * MarkedString can be used to render human readable text. It is either a markdown string
+ * or a code-block that provides a language and a code snippet. The language identifier
+ * is semantically equal to the optional language identifier in fenced code blocks in GitHub
+ * issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
+ *
+ * The pair of a language and a value is an equivalent to markdown:
+ * ```${language}
+ * ${value}
+ * ```
+ *
+ * Note that markdown strings will be sanitized - that means html will be escaped.
+ * @deprecated use MarkupContent instead.
+ */
+type MarkedString = string
+
+// DefinitionLink is a type
+/**
+ * Information about where a symbol is defined.
+ *
+ * Provides additional metadata over normal [location](#Location) definitions, including the range of
+ * the defining symbol
+ */
+type DefinitionLink = LocationLink
+
+// DeclarationLink is a type
+/**
+ * Information about where a symbol is declared.
+ *
+ * Provides additional metadata over normal [location](#Location) declarations, including the range of
+ * the declaring symbol.
+ *
+ * Servers should prefer returning `DeclarationLink` over `Declaration` if supported
+ * by the client.
+ */
+type DeclarationLink = LocationLink
+
+// LSPMessageType is a type
+/**
+ * A LSP Log Entry.
+ */
+type LSPMessageType = string
+
+// ProgressToken is a type
+type ProgressToken = interface{} // number | string
+// TraceValues is a type
+type TraceValues = string
diff --git a/utils/vscode/src/lsp/protocol/tsserver.go b/utils/vscode/src/lsp/protocol/tsserver.go
new file mode 100644
index 0000000..d760501
--- /dev/null
+++ b/utils/vscode/src/lsp/protocol/tsserver.go
@@ -0,0 +1,842 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package protocol
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+
+	"../jsonrpc2"
+)
+
+type Server interface {
+	DidChangeWorkspaceFolders(context.Context, *DidChangeWorkspaceFoldersParams) error
+	Initialized(context.Context, *InitializedParams) error
+	Exit(context.Context) error
+	DidChangeConfiguration(context.Context, *DidChangeConfigurationParams) error
+	DidOpen(context.Context, *DidOpenTextDocumentParams) error
+	DidChange(context.Context, *DidChangeTextDocumentParams) error
+	DidClose(context.Context, *DidCloseTextDocumentParams) error
+	DidSave(context.Context, *DidSaveTextDocumentParams) error
+	WillSave(context.Context, *WillSaveTextDocumentParams) error
+	DidChangeWatchedFiles(context.Context, *DidChangeWatchedFilesParams) error
+	Progress(context.Context, *ProgressParams) error
+	SetTraceNotification(context.Context, *SetTraceParams) error
+	LogTraceNotification(context.Context, *LogTraceParams) error
+	Implementation(context.Context, *ImplementationParams) ([]Location, error)
+	TypeDefinition(context.Context, *TypeDefinitionParams) ([]Location, error)
+	DocumentColor(context.Context, *DocumentColorParams) ([]ColorInformation, error)
+	ColorPresentation(context.Context, *ColorPresentationParams) ([]ColorPresentation, error)
+	FoldingRange(context.Context, *FoldingRangeParams) ([]FoldingRange, error)
+	Declaration(context.Context, *DeclarationParams) ([]DeclarationLink, error)
+	SelectionRange(context.Context, *SelectionRangeParams) ([]SelectionRange, error)
+	Initialize(context.Context, *ParamInitia) (*InitializeResult, error)
+	Shutdown(context.Context) error
+	WillSaveWaitUntil(context.Context, *WillSaveTextDocumentParams) ([]TextEdit, error)
+	Completion(context.Context, *CompletionParams) (*CompletionList, error)
+	Resolve(context.Context, *CompletionItem) (*CompletionItem, error)
+	Hover(context.Context, *HoverParams) (*Hover, error)
+	SignatureHelp(context.Context, *SignatureHelpParams) (*SignatureHelp, error)
+	Definition(context.Context, *DefinitionParams) ([]Location, error)
+	References(context.Context, *ReferenceParams) ([]Location, error)
+	DocumentHighlight(context.Context, *DocumentHighlightParams) ([]DocumentHighlight, error)
+	DocumentSymbol(context.Context, *DocumentSymbolParams) ([]DocumentSymbol, error)
+	CodeAction(context.Context, *CodeActionParams) ([]CodeAction, error)
+	Symbol(context.Context, *WorkspaceSymbolParams) ([]SymbolInformation, error)
+	CodeLens(context.Context, *CodeLensParams) ([]CodeLens, error)
+	ResolveCodeLens(context.Context, *CodeLens) (*CodeLens, error)
+	DocumentLink(context.Context, *DocumentLinkParams) ([]DocumentLink, error)
+	ResolveDocumentLink(context.Context, *DocumentLink) (*DocumentLink, error)
+	Formatting(context.Context, *DocumentFormattingParams) ([]TextEdit, error)
+	RangeFormatting(context.Context, *DocumentRangeFormattingParams) ([]TextEdit, error)
+	OnTypeFormatting(context.Context, *DocumentOnTypeFormattingParams) ([]TextEdit, error)
+	Rename(context.Context, *RenameParams) (*WorkspaceEdit, error)
+	PrepareRename(context.Context, *PrepareRenameParams) (*Range, error)
+	ExecuteCommand(context.Context, *ExecuteCommandParams) (interface{}, error)
+}
+
+func (h serverHandler) Deliver(ctx context.Context, r *jsonrpc2.Request, delivered bool) bool {
+	if delivered {
+		return false
+	}
+	if ctx.Err() != nil {
+		r.Reply(ctx, nil, jsonrpc2.NewErrorf(RequestCancelledError, ""))
+		return true
+	}
+	switch r.Method {
+	case "workspace/didChangeWorkspaceFolders": // notif
+		var params DidChangeWorkspaceFoldersParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidChangeWorkspaceFolders(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "initialized": // notif
+		var params InitializedParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.Initialized(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "exit": // notif
+		if err := h.server.Exit(ctx); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/didChangeConfiguration": // notif
+		var params DidChangeConfigurationParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidChangeConfiguration(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/didOpen": // notif
+		var params DidOpenTextDocumentParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidOpen(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/didChange": // notif
+		var params DidChangeTextDocumentParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidChange(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/didClose": // notif
+		var params DidCloseTextDocumentParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidClose(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/didSave": // notif
+		var params DidSaveTextDocumentParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidSave(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/willSave": // notif
+		var params WillSaveTextDocumentParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.WillSave(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/didChangeWatchedFiles": // notif
+		var params DidChangeWatchedFilesParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.DidChangeWatchedFiles(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "$/progress": // notif
+		var params ProgressParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.Progress(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "$/setTraceNotification": // notif
+		var params SetTraceParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.SetTraceNotification(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "$/logTraceNotification": // notif
+		var params LogTraceParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		if err := h.server.LogTraceNotification(ctx, &params); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/implementation": // req
+		var params ImplementationParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Implementation(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/typeDefinition": // req
+		var params TypeDefinitionParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.TypeDefinition(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/documentColor": // req
+		var params DocumentColorParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.DocumentColor(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/colorPresentation": // req
+		var params ColorPresentationParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.ColorPresentation(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/foldingRange": // req
+		var params FoldingRangeParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.FoldingRange(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/declaration": // req
+		var params DeclarationParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Declaration(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/selectionRange": // req
+		var params SelectionRangeParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.SelectionRange(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "initialize": // req
+		var params ParamInitia
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Initialize(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "shutdown": // req
+		if r.Params != nil {
+			r.Reply(ctx, nil, jsonrpc2.NewErrorf(jsonrpc2.CodeInvalidParams, "Expected no params"))
+			return true
+		}
+		err := h.server.Shutdown(ctx)
+		if err := r.Reply(ctx, nil, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/willSaveWaitUntil": // req
+		var params WillSaveTextDocumentParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.WillSaveWaitUntil(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/completion": // req
+		var params CompletionParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Completion(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "completionItem/resolve": // req
+		var params CompletionItem
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Resolve(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/hover": // req
+		var params HoverParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Hover(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/signatureHelp": // req
+		var params SignatureHelpParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.SignatureHelp(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/definition": // req
+		var params DefinitionParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Definition(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/references": // req
+		var params ReferenceParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.References(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/documentHighlight": // req
+		var params DocumentHighlightParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.DocumentHighlight(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/documentSymbol": // req
+		var params DocumentSymbolParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.DocumentSymbol(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/codeAction": // req
+		var params CodeActionParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.CodeAction(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/symbol": // req
+		var params WorkspaceSymbolParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Symbol(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/codeLens": // req
+		var params CodeLensParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.CodeLens(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "codeLens/resolve": // req
+		var params CodeLens
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.ResolveCodeLens(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/documentLink": // req
+		var params DocumentLinkParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.DocumentLink(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "documentLink/resolve": // req
+		var params DocumentLink
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.ResolveDocumentLink(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/formatting": // req
+		var params DocumentFormattingParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Formatting(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/rangeFormatting": // req
+		var params DocumentRangeFormattingParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.RangeFormatting(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/onTypeFormatting": // req
+		var params DocumentOnTypeFormattingParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.OnTypeFormatting(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/rename": // req
+		var params RenameParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.Rename(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "textDocument/prepareRename": // req
+		var params PrepareRenameParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.PrepareRename(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+	case "workspace/executeCommand": // req
+		var params ExecuteCommandParams
+		if err := json.Unmarshal(*r.Params, &params); err != nil {
+			sendParseError(ctx, r, err)
+			return true
+		}
+		resp, err := h.server.ExecuteCommand(ctx, &params)
+		if err := r.Reply(ctx, resp, err); err != nil {
+			log.Printf("%v", err)
+		}
+		return true
+
+	default:
+		return false
+	}
+}
+
+type serverDispatcher struct {
+	*jsonrpc2.Conn
+}
+
+func (s *serverDispatcher) DidChangeWorkspaceFolders(ctx context.Context, params *DidChangeWorkspaceFoldersParams) error {
+	return s.Conn.Notify(ctx, "workspace/didChangeWorkspaceFolders", params)
+}
+
+func (s *serverDispatcher) Initialized(ctx context.Context, params *InitializedParams) error {
+	return s.Conn.Notify(ctx, "initialized", params)
+}
+
+func (s *serverDispatcher) Exit(ctx context.Context) error {
+	return s.Conn.Notify(ctx, "exit", nil)
+}
+
+func (s *serverDispatcher) DidChangeConfiguration(ctx context.Context, params *DidChangeConfigurationParams) error {
+	return s.Conn.Notify(ctx, "workspace/didChangeConfiguration", params)
+}
+
+func (s *serverDispatcher) DidOpen(ctx context.Context, params *DidOpenTextDocumentParams) error {
+	return s.Conn.Notify(ctx, "textDocument/didOpen", params)
+}
+
+func (s *serverDispatcher) DidChange(ctx context.Context, params *DidChangeTextDocumentParams) error {
+	return s.Conn.Notify(ctx, "textDocument/didChange", params)
+}
+
+func (s *serverDispatcher) DidClose(ctx context.Context, params *DidCloseTextDocumentParams) error {
+	return s.Conn.Notify(ctx, "textDocument/didClose", params)
+}
+
+func (s *serverDispatcher) DidSave(ctx context.Context, params *DidSaveTextDocumentParams) error {
+	return s.Conn.Notify(ctx, "textDocument/didSave", params)
+}
+
+func (s *serverDispatcher) WillSave(ctx context.Context, params *WillSaveTextDocumentParams) error {
+	return s.Conn.Notify(ctx, "textDocument/willSave", params)
+}
+
+func (s *serverDispatcher) DidChangeWatchedFiles(ctx context.Context, params *DidChangeWatchedFilesParams) error {
+	return s.Conn.Notify(ctx, "workspace/didChangeWatchedFiles", params)
+}
+
+func (s *serverDispatcher) Progress(ctx context.Context, params *ProgressParams) error {
+	return s.Conn.Notify(ctx, "$/progress", params)
+}
+
+func (s *serverDispatcher) SetTraceNotification(ctx context.Context, params *SetTraceParams) error {
+	return s.Conn.Notify(ctx, "$/setTraceNotification", params)
+}
+
+func (s *serverDispatcher) LogTraceNotification(ctx context.Context, params *LogTraceParams) error {
+	return s.Conn.Notify(ctx, "$/logTraceNotification", params)
+}
+func (s *serverDispatcher) Implementation(ctx context.Context, params *ImplementationParams) ([]Location, error) {
+	var result []Location
+	if err := s.Conn.Call(ctx, "textDocument/implementation", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) TypeDefinition(ctx context.Context, params *TypeDefinitionParams) ([]Location, error) {
+	var result []Location
+	if err := s.Conn.Call(ctx, "textDocument/typeDefinition", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) DocumentColor(ctx context.Context, params *DocumentColorParams) ([]ColorInformation, error) {
+	var result []ColorInformation
+	if err := s.Conn.Call(ctx, "textDocument/documentColor", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) ColorPresentation(ctx context.Context, params *ColorPresentationParams) ([]ColorPresentation, error) {
+	var result []ColorPresentation
+	if err := s.Conn.Call(ctx, "textDocument/colorPresentation", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) FoldingRange(ctx context.Context, params *FoldingRangeParams) ([]FoldingRange, error) {
+	var result []FoldingRange
+	if err := s.Conn.Call(ctx, "textDocument/foldingRange", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) Declaration(ctx context.Context, params *DeclarationParams) ([]DeclarationLink, error) {
+	var result []DeclarationLink
+	if err := s.Conn.Call(ctx, "textDocument/declaration", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) SelectionRange(ctx context.Context, params *SelectionRangeParams) ([]SelectionRange, error) {
+	var result []SelectionRange
+	if err := s.Conn.Call(ctx, "textDocument/selectionRange", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) Initialize(ctx context.Context, params *ParamInitia) (*InitializeResult, error) {
+	var result InitializeResult
+	if err := s.Conn.Call(ctx, "initialize", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) Shutdown(ctx context.Context) error {
+	return s.Conn.Call(ctx, "shutdown", nil, nil)
+}
+
+func (s *serverDispatcher) WillSaveWaitUntil(ctx context.Context, params *WillSaveTextDocumentParams) ([]TextEdit, error) {
+	var result []TextEdit
+	if err := s.Conn.Call(ctx, "textDocument/willSaveWaitUntil", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) Completion(ctx context.Context, params *CompletionParams) (*CompletionList, error) {
+	var result CompletionList
+	if err := s.Conn.Call(ctx, "textDocument/completion", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) Resolve(ctx context.Context, params *CompletionItem) (*CompletionItem, error) {
+	var result CompletionItem
+	if err := s.Conn.Call(ctx, "completionItem/resolve", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) Hover(ctx context.Context, params *HoverParams) (*Hover, error) {
+	var result Hover
+	if err := s.Conn.Call(ctx, "textDocument/hover", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) SignatureHelp(ctx context.Context, params *SignatureHelpParams) (*SignatureHelp, error) {
+	var result SignatureHelp
+	if err := s.Conn.Call(ctx, "textDocument/signatureHelp", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) Definition(ctx context.Context, params *DefinitionParams) ([]Location, error) {
+	var result []Location
+	if err := s.Conn.Call(ctx, "textDocument/definition", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) References(ctx context.Context, params *ReferenceParams) ([]Location, error) {
+	var result []Location
+	if err := s.Conn.Call(ctx, "textDocument/references", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) DocumentHighlight(ctx context.Context, params *DocumentHighlightParams) ([]DocumentHighlight, error) {
+	var result []DocumentHighlight
+	if err := s.Conn.Call(ctx, "textDocument/documentHighlight", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) DocumentSymbol(ctx context.Context, params *DocumentSymbolParams) ([]DocumentSymbol, error) {
+	var result []DocumentSymbol
+	if err := s.Conn.Call(ctx, "textDocument/documentSymbol", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) CodeAction(ctx context.Context, params *CodeActionParams) ([]CodeAction, error) {
+	var result []CodeAction
+	if err := s.Conn.Call(ctx, "textDocument/codeAction", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) Symbol(ctx context.Context, params *WorkspaceSymbolParams) ([]SymbolInformation, error) {
+	var result []SymbolInformation
+	if err := s.Conn.Call(ctx, "workspace/symbol", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) CodeLens(ctx context.Context, params *CodeLensParams) ([]CodeLens, error) {
+	var result []CodeLens
+	if err := s.Conn.Call(ctx, "textDocument/codeLens", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) ResolveCodeLens(ctx context.Context, params *CodeLens) (*CodeLens, error) {
+	var result CodeLens
+	if err := s.Conn.Call(ctx, "codeLens/resolve", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) DocumentLink(ctx context.Context, params *DocumentLinkParams) ([]DocumentLink, error) {
+	var result []DocumentLink
+	if err := s.Conn.Call(ctx, "textDocument/documentLink", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) ResolveDocumentLink(ctx context.Context, params *DocumentLink) (*DocumentLink, error) {
+	var result DocumentLink
+	if err := s.Conn.Call(ctx, "documentLink/resolve", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) Formatting(ctx context.Context, params *DocumentFormattingParams) ([]TextEdit, error) {
+	var result []TextEdit
+	if err := s.Conn.Call(ctx, "textDocument/formatting", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) RangeFormatting(ctx context.Context, params *DocumentRangeFormattingParams) ([]TextEdit, error) {
+	var result []TextEdit
+	if err := s.Conn.Call(ctx, "textDocument/rangeFormatting", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) OnTypeFormatting(ctx context.Context, params *DocumentOnTypeFormattingParams) ([]TextEdit, error) {
+	var result []TextEdit
+	if err := s.Conn.Call(ctx, "textDocument/onTypeFormatting", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (s *serverDispatcher) Rename(ctx context.Context, params *RenameParams) (*WorkspaceEdit, error) {
+	var result WorkspaceEdit
+	if err := s.Conn.Call(ctx, "textDocument/rename", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) PrepareRename(ctx context.Context, params *PrepareRenameParams) (*Range, error) {
+	var result Range
+	if err := s.Conn.Call(ctx, "textDocument/prepareRename", params, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
+func (s *serverDispatcher) ExecuteCommand(ctx context.Context, params *ExecuteCommandParams) (interface{}, error) {
+	var result interface{}
+	if err := s.Conn.Call(ctx, "workspace/executeCommand", params, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+type CancelParams struct {
+	/**
+	 * The request id to cancel.
+	 */
+	ID jsonrpc2.ID `json:"id"`
+}
+
+// Types constructed to avoid structs as formal argument types
+type ParamInitia struct {
+	InitializeParams
+	WorkDoneProgressParams
+}
diff --git a/utils/vscode/src/lsp/span/parse.go b/utils/vscode/src/lsp/span/parse.go
new file mode 100644
index 0000000..ec393c2
--- /dev/null
+++ b/utils/vscode/src/lsp/span/parse.go
@@ -0,0 +1,110 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package span
+
+import (
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+// Parse returns the location represented by the input.
+// All inputs are valid locations, as they can always be a pure filename.
+// The returned span will be normalized, and thus if printed may produce a
+// different string.
+func Parse(input string) Span {
+	// :0:0#0-0:0#0
+	valid := input
+	var hold, offset int
+	hadCol := false
+	suf := rstripSuffix(input)
+	if suf.sep == "#" {
+		offset = suf.num
+		suf = rstripSuffix(suf.remains)
+	}
+	if suf.sep == ":" {
+		valid = suf.remains
+		hold = suf.num
+		hadCol = true
+		suf = rstripSuffix(suf.remains)
+	}
+	switch {
+	case suf.sep == ":":
+		return New(NewURI(suf.remains), NewPoint(suf.num, hold, offset), Point{})
+	case suf.sep == "-":
+		// we have a span, fall out of the case to continue
+	default:
+		// separator not valid, rewind to either the : or the start
+		return New(NewURI(valid), NewPoint(hold, 0, offset), Point{})
+	}
+	// only the span form can get here
+	// at this point we still don't know what the numbers we have mean
+	// if have not yet seen a : then we might have either a line or a column depending
+	// on whether start has a column or not
+	// we build an end point and will fix it later if needed
+	end := NewPoint(suf.num, hold, offset)
+	hold, offset = 0, 0
+	suf = rstripSuffix(suf.remains)
+	if suf.sep == "#" {
+		offset = suf.num
+		suf = rstripSuffix(suf.remains)
+	}
+	if suf.sep != ":" {
+		// turns out we don't have a span after all, rewind
+		return New(NewURI(valid), end, Point{})
+	}
+	valid = suf.remains
+	hold = suf.num
+	suf = rstripSuffix(suf.remains)
+	if suf.sep != ":" {
+		// line#offset only
+		return New(NewURI(valid), NewPoint(hold, 0, offset), end)
+	}
+	// we have a column, so if end only had one number, it is also the column
+	if !hadCol {
+		end = NewPoint(suf.num, end.v.Line, end.v.Offset)
+	}
+	return New(NewURI(suf.remains), NewPoint(suf.num, hold, offset), end)
+}
+
+type suffix struct {
+	remains string
+	sep     string
+	num     int
+}
+
+func rstripSuffix(input string) suffix {
+	if len(input) == 0 {
+		return suffix{"", "", -1}
+	}
+	remains := input
+	num := -1
+	// first see if we have a number at the end
+	last := strings.LastIndexFunc(remains, func(r rune) bool { return r < '0' || r > '9' })
+	if last >= 0 && last < len(remains)-1 {
+		number, err := strconv.ParseInt(remains[last+1:], 10, 64)
+		if err == nil {
+			num = int(number)
+			remains = remains[:last+1]
+		}
+	}
+	// now see if we have a trailing separator
+	r, w := utf8.DecodeLastRuneInString(remains)
+	if r != ':' && r != '#' && r == '#' {
+		return suffix{input, "", -1}
+	}
+	remains = remains[:len(remains)-w]
+	return suffix{remains, string(r), num}
+}
diff --git a/utils/vscode/src/lsp/span/span.go b/utils/vscode/src/lsp/span/span.go
new file mode 100644
index 0000000..aefd4f3
--- /dev/null
+++ b/utils/vscode/src/lsp/span/span.go
@@ -0,0 +1,295 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package span contains support for representing with positions and ranges in
+// text files.
+package span
+
+import (
+	"encoding/json"
+	"fmt"
+	"path"
+)
+
+// Span represents a source code range in standardized form.
+type Span struct {
+	v span
+}
+
+// Point represents a single point within a file.
+// In general this should only be used as part of a Span, as on its own it
+// does not carry enough information.
+type Point struct {
+	v point
+}
+
+type span struct {
+	URI   URI   `json:"uri"`
+	Start point `json:"start"`
+	End   point `json:"end"`
+}
+
+type point struct {
+	Line   int `json:"line"`
+	Column int `json:"column"`
+	Offset int `json:"offset"`
+}
+
+// Invalid is a span that reports false from IsValid
+var Invalid = Span{v: span{Start: invalidPoint.v, End: invalidPoint.v}}
+
+var invalidPoint = Point{v: point{Line: 0, Column: 0, Offset: -1}}
+
+// Converter is the interface to an object that can convert between line:column
+// and offset forms for a single file.
+type Converter interface {
+	//ToPosition converts from an offset to a line:column pair.
+	ToPosition(offset int) (int, int, error)
+	//ToOffset converts from a line:column pair to an offset.
+	ToOffset(line, col int) (int, error)
+}
+
+func New(uri URI, start Point, end Point) Span {
+	s := Span{v: span{URI: uri, Start: start.v, End: end.v}}
+	s.v.clean()
+	return s
+}
+
+func NewPoint(line, col, offset int) Point {
+	p := Point{v: point{Line: line, Column: col, Offset: offset}}
+	p.v.clean()
+	return p
+}
+
+func Compare(a, b Span) int {
+	if r := CompareURI(a.URI(), b.URI()); r != 0 {
+		return r
+	}
+	if r := comparePoint(a.v.Start, b.v.Start); r != 0 {
+		return r
+	}
+	return comparePoint(a.v.End, b.v.End)
+}
+
+func ComparePoint(a, b Point) int {
+	return comparePoint(a.v, b.v)
+}
+
+func comparePoint(a, b point) int {
+	if !a.hasPosition() {
+		if a.Offset < b.Offset {
+			return -1
+		}
+		if a.Offset > b.Offset {
+			return 1
+		}
+		return 0
+	}
+	if a.Line < b.Line {
+		return -1
+	}
+	if a.Line > b.Line {
+		return 1
+	}
+	if a.Column < b.Column {
+		return -1
+	}
+	if a.Column > b.Column {
+		return 1
+	}
+	return 0
+}
+
+func (s Span) HasPosition() bool             { return s.v.Start.hasPosition() }
+func (s Span) HasOffset() bool               { return s.v.Start.hasOffset() }
+func (s Span) IsValid() bool                 { return s.v.Start.isValid() }
+func (s Span) IsPoint() bool                 { return s.v.Start == s.v.End }
+func (s Span) URI() URI                      { return s.v.URI }
+func (s Span) Start() Point                  { return Point{s.v.Start} }
+func (s Span) End() Point                    { return Point{s.v.End} }
+func (s *Span) MarshalJSON() ([]byte, error) { return json.Marshal(&s.v) }
+func (s *Span) UnmarshalJSON(b []byte) error { return json.Unmarshal(b, &s.v) }
+
+func (p Point) HasPosition() bool             { return p.v.hasPosition() }
+func (p Point) HasOffset() bool               { return p.v.hasOffset() }
+func (p Point) IsValid() bool                 { return p.v.isValid() }
+func (p *Point) MarshalJSON() ([]byte, error) { return json.Marshal(&p.v) }
+func (p *Point) UnmarshalJSON(b []byte) error { return json.Unmarshal(b, &p.v) }
+func (p Point) Line() int {
+	if !p.v.hasPosition() {
+		panic(fmt.Errorf("position not set in %v", p.v))
+	}
+	return p.v.Line
+}
+func (p Point) Column() int {
+	if !p.v.hasPosition() {
+		panic(fmt.Errorf("position not set in %v", p.v))
+	}
+	return p.v.Column
+}
+func (p Point) Offset() int {
+	if !p.v.hasOffset() {
+		panic(fmt.Errorf("offset not set in %v", p.v))
+	}
+	return p.v.Offset
+}
+
+func (p point) hasPosition() bool { return p.Line > 0 }
+func (p point) hasOffset() bool   { return p.Offset >= 0 }
+func (p point) isValid() bool     { return p.hasPosition() || p.hasOffset() }
+func (p point) isZero() bool {
+	return (p.Line == 1 && p.Column == 1) || (!p.hasPosition() && p.Offset == 0)
+}
+
+func (s *span) clean() {
+	//this presumes the points are already clean
+	if !s.End.isValid() || (s.End == point{}) {
+		s.End = s.Start
+	}
+}
+
+func (p *point) clean() {
+	if p.Line < 0 {
+		p.Line = 0
+	}
+	if p.Column <= 0 {
+		if p.Line > 0 {
+			p.Column = 1
+		} else {
+			p.Column = 0
+		}
+	}
+	if p.Offset == 0 && (p.Line > 1 || p.Column > 1) {
+		p.Offset = -1
+	}
+}
+
+// Format implements fmt.Formatter to print the Location in a standard form.
+// The format produced is one that can be read back in using Parse.
+func (s Span) Format(f fmt.State, c rune) {
+	fullForm := f.Flag('+')
+	preferOffset := f.Flag('#')
+	// we should always have a uri, simplify if it is file format
+	//TODO: make sure the end of the uri is unambiguous
+	uri := string(s.v.URI)
+	if c == 'f' {
+		uri = path.Base(uri)
+	} else if !fullForm {
+		uri = s.v.URI.Filename()
+	}
+	fmt.Fprint(f, uri)
+	if !s.IsValid() || (!fullForm && s.v.Start.isZero() && s.v.End.isZero()) {
+		return
+	}
+	// see which bits of start to write
+	printOffset := s.HasOffset() && (fullForm || preferOffset || !s.HasPosition())
+	printLine := s.HasPosition() && (fullForm || !printOffset)
+	printColumn := printLine && (fullForm || (s.v.Start.Column > 1 || s.v.End.Column > 1))
+	fmt.Fprint(f, ":")
+	if printLine {
+		fmt.Fprintf(f, "%d", s.v.Start.Line)
+	}
+	if printColumn {
+		fmt.Fprintf(f, ":%d", s.v.Start.Column)
+	}
+	if printOffset {
+		fmt.Fprintf(f, "#%d", s.v.Start.Offset)
+	}
+	// start is written, do we need end?
+	if s.IsPoint() {
+		return
+	}
+	// we don't print the line if it did not change
+	printLine = fullForm || (printLine && s.v.End.Line > s.v.Start.Line)
+	fmt.Fprint(f, "-")
+	if printLine {
+		fmt.Fprintf(f, "%d", s.v.End.Line)
+	}
+	if printColumn {
+		if printLine {
+			fmt.Fprint(f, ":")
+		}
+		fmt.Fprintf(f, "%d", s.v.End.Column)
+	}
+	if printOffset {
+		fmt.Fprintf(f, "#%d", s.v.End.Offset)
+	}
+}
+
+func (s Span) WithPosition(c Converter) (Span, error) {
+	if err := s.update(c, true, false); err != nil {
+		return Span{}, err
+	}
+	return s, nil
+}
+
+func (s Span) WithOffset(c Converter) (Span, error) {
+	if err := s.update(c, false, true); err != nil {
+		return Span{}, err
+	}
+	return s, nil
+}
+
+func (s Span) WithAll(c Converter) (Span, error) {
+	if err := s.update(c, true, true); err != nil {
+		return Span{}, err
+	}
+	return s, nil
+}
+
+func (s *Span) update(c Converter, withPos, withOffset bool) error {
+	if !s.IsValid() {
+		return fmt.Errorf("cannot add information to an invalid span")
+	}
+	if withPos && !s.HasPosition() {
+		if err := s.v.Start.updatePosition(c); err != nil {
+			return err
+		}
+		if s.v.End.Offset == s.v.Start.Offset {
+			s.v.End = s.v.Start
+		} else if err := s.v.End.updatePosition(c); err != nil {
+			return err
+		}
+	}
+	if withOffset && (!s.HasOffset() || (s.v.End.hasPosition() && !s.v.End.hasOffset())) {
+		if err := s.v.Start.updateOffset(c); err != nil {
+			return err
+		}
+		if s.v.End.Line == s.v.Start.Line && s.v.End.Column == s.v.Start.Column {
+			s.v.End.Offset = s.v.Start.Offset
+		} else if err := s.v.End.updateOffset(c); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (p *point) updatePosition(c Converter) error {
+	line, col, err := c.ToPosition(p.Offset)
+	if err != nil {
+		return err
+	}
+	p.Line = line
+	p.Column = col
+	return nil
+}
+
+func (p *point) updateOffset(c Converter) error {
+	offset, err := c.ToOffset(p.Line, p.Column)
+	if err != nil {
+		return err
+	}
+	p.Offset = offset
+	return nil
+}
diff --git a/utils/vscode/src/lsp/span/token.go b/utils/vscode/src/lsp/span/token.go
new file mode 100644
index 0000000..f5a3870
--- /dev/null
+++ b/utils/vscode/src/lsp/span/token.go
@@ -0,0 +1,161 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package span
+
+import (
+	"fmt"
+	"go/token"
+)
+
+// Range represents a source code range in token.Pos form.
+// It also carries the FileSet that produced the positions, so that it is
+// self contained.
+type Range struct {
+	FileSet *token.FileSet
+	Start   token.Pos
+	End     token.Pos
+}
+
+// TokenConverter is a Converter backed by a token file set and file.
+// It uses the file set methods to work out the conversions, which
+// makes it fast and does not require the file contents.
+type TokenConverter struct {
+	fset *token.FileSet
+	file *token.File
+}
+
+// NewRange creates a new Range from a FileSet and two positions.
+// To represent a point pass a 0 as the end pos.
+func NewRange(fset *token.FileSet, start, end token.Pos) Range {
+	return Range{
+		FileSet: fset,
+		Start:   start,
+		End:     end,
+	}
+}
+
+// NewTokenConverter returns an implementation of Converter backed by a
+// token.File.
+func NewTokenConverter(fset *token.FileSet, f *token.File) *TokenConverter {
+	return &TokenConverter{fset: fset, file: f}
+}
+
+// NewContentConverter returns an implementation of Converter for the
+// given file content.
+func NewContentConverter(filename string, content []byte) *TokenConverter {
+	fset := token.NewFileSet()
+	f := fset.AddFile(filename, -1, len(content))
+	f.SetLinesForContent(content)
+	return &TokenConverter{fset: fset, file: f}
+}
+
+// IsPoint returns true if the range represents a single point.
+func (r Range) IsPoint() bool {
+	return r.Start == r.End
+}
+
+// Span converts a Range to a Span that represents the Range.
+// It will fill in all the members of the Span, calculating the line and column
+// information.
+func (r Range) Span() (Span, error) {
+	f := r.FileSet.File(r.Start)
+	if f == nil {
+		return Span{}, fmt.Errorf("file not found in FileSet")
+	}
+	s := Span{v: span{URI: FileURI(f.Name())}}
+	var err error
+	s.v.Start.Offset, err = offset(f, r.Start)
+	if err != nil {
+		return Span{}, err
+	}
+	if r.End.IsValid() {
+		s.v.End.Offset, err = offset(f, r.End)
+		if err != nil {
+			return Span{}, err
+		}
+	}
+	s.v.Start.clean()
+	s.v.End.clean()
+	s.v.clean()
+	converter := NewTokenConverter(r.FileSet, f)
+	return s.WithPosition(converter)
+}
+
+// offset is a copy of the Offset function in go/token, but with the adjustment
+// that it does not panic on invalid positions.
+func offset(f *token.File, pos token.Pos) (int, error) {
+	if int(pos) < f.Base() || int(pos) > f.Base()+f.Size() {
+		return 0, fmt.Errorf("invalid pos")
+	}
+	return int(pos) - f.Base(), nil
+}
+
+// Range converts a Span to a Range that represents the Span for the supplied
+// File.
+func (s Span) Range(converter *TokenConverter) (Range, error) {
+	s, err := s.WithOffset(converter)
+	if err != nil {
+		return Range{}, err
+	}
+	// go/token will panic if the offset is larger than the file's size,
+	// so check here to avoid panicking.
+	if s.Start().Offset() > converter.file.Size() {
+		return Range{}, fmt.Errorf("start offset %v is past the end of the file %v", s.Start(), converter.file.Size())
+	}
+	if s.End().Offset() > converter.file.Size() {
+		return Range{}, fmt.Errorf("end offset %v is past the end of the file %v", s.End(), converter.file.Size())
+	}
+	return Range{
+		FileSet: converter.fset,
+		Start:   converter.file.Pos(s.Start().Offset()),
+		End:     converter.file.Pos(s.End().Offset()),
+	}, nil
+}
+
+func (l *TokenConverter) ToPosition(offset int) (int, int, error) {
+	if offset > l.file.Size() {
+		return 0, 0, fmt.Errorf("offset %v is past the end of the file %v", offset, l.file.Size())
+	}
+	pos := l.file.Pos(offset)
+	p := l.fset.Position(pos)
+	if offset == l.file.Size() {
+		return p.Line + 1, 1, nil
+	}
+	return p.Line, p.Column, nil
+}
+
+func (l *TokenConverter) ToOffset(line, col int) (int, error) {
+	if line < 0 {
+		return -1, fmt.Errorf("line is not valid")
+	}
+	lineMax := l.file.LineCount() + 1
+	if line > lineMax {
+		return -1, fmt.Errorf("line is beyond end of file %v", lineMax)
+	} else if line == lineMax {
+		if col > 1 {
+			return -1, fmt.Errorf("column is beyond end of file")
+		}
+		// at the end of the file, allowing for a trailing eol
+		return l.file.Size(), nil
+	}
+	pos := lineStart(l.file, line)
+	if !pos.IsValid() {
+		return -1, fmt.Errorf("line is not in file")
+	}
+	// we assume that column is in bytes here, and that the first byte of a
+	// line is at column 1
+	pos += token.Pos(col - 1)
+	return offset(l.file, pos)
+}
diff --git a/utils/vscode/src/lsp/span/token111.go b/utils/vscode/src/lsp/span/token111.go
new file mode 100644
index 0000000..768419a
--- /dev/null
+++ b/utils/vscode/src/lsp/span/token111.go
@@ -0,0 +1,49 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build !go1.12
+
+package span
+
+import (
+	"go/token"
+)
+
+// lineStart is the pre-Go 1.12 version of (*token.File).LineStart. For Go
+// versions <= 1.11, we borrow logic from the analysisutil package.
+// TODO(rstambler): Delete this file when we no longer support Go 1.11.
+func lineStart(f *token.File, line int) token.Pos {
+	// Use binary search to find the start offset of this line.
+
+	min := 0        // inclusive
+	max := f.Size() // exclusive
+	for {
+		offset := (min + max) / 2
+		pos := f.Pos(offset)
+		posn := f.Position(pos)
+		if posn.Line == line {
+			return pos - (token.Pos(posn.Column) - 1)
+		}
+
+		if min+1 >= max {
+			return token.NoPos
+		}
+
+		if posn.Line < line {
+			min = offset
+		} else {
+			max = offset
+		}
+	}
+}
diff --git a/utils/vscode/src/lsp/span/token112.go b/utils/vscode/src/lsp/span/token112.go
new file mode 100644
index 0000000..abff500
--- /dev/null
+++ b/utils/vscode/src/lsp/span/token112.go
@@ -0,0 +1,26 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build go1.12
+
+package span
+
+import (
+	"go/token"
+)
+
+// TODO(rstambler): Delete this file when we no longer support Go 1.11.
+func lineStart(f *token.File, line int) token.Pos {
+	return f.LineStart(line)
+}
diff --git a/utils/vscode/src/lsp/span/uri.go b/utils/vscode/src/lsp/span/uri.go
new file mode 100644
index 0000000..525518b
--- /dev/null
+++ b/utils/vscode/src/lsp/span/uri.go
@@ -0,0 +1,162 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package span
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"unicode"
+)
+
+const fileScheme = "file"
+
+// URI represents the full URI for a file.
+type URI string
+
+// Filename returns the file path for the given URI.
+// It is an error to call this on a URI that is not a valid filename.
+func (uri URI) Filename() string {
+	filename, err := filename(uri)
+	if err != nil {
+		panic(err)
+	}
+	return filepath.FromSlash(filename)
+}
+
+func filename(uri URI) (string, error) {
+	if uri == "" {
+		return "", nil
+	}
+	u, err := url.ParseRequestURI(string(uri))
+	if err != nil {
+		return "", err
+	}
+	if u.Scheme != fileScheme {
+		return "", fmt.Errorf("only file URIs are supported, got %q from %q", u.Scheme, uri)
+	}
+	if isWindowsDriveURI(u.Path) {
+		u.Path = u.Path[1:]
+	}
+	return u.Path, nil
+}
+
+// NewURI returns a span URI for the string.
+// It will attempt to detect if the string is a file path or uri.
+func NewURI(s string) URI {
+	if u, err := url.PathUnescape(s); err == nil {
+		s = u
+	}
+	if strings.HasPrefix(s, fileScheme+"://") {
+		return URI(s)
+	}
+	return FileURI(s)
+}
+
+func CompareURI(a, b URI) int {
+	if equalURI(a, b) {
+		return 0
+	}
+	if a < b {
+		return -1
+	}
+	return 1
+}
+
+func equalURI(a, b URI) bool {
+	if a == b {
+		return true
+	}
+	// If we have the same URI basename, we may still have the same file URIs.
+	if !strings.EqualFold(path.Base(string(a)), path.Base(string(b))) {
+		return false
+	}
+	fa, err := filename(a)
+	if err != nil {
+		return false
+	}
+	fb, err := filename(b)
+	if err != nil {
+		return false
+	}
+	// Stat the files to check if they are equal.
+	infoa, err := os.Stat(filepath.FromSlash(fa))
+	if err != nil {
+		return false
+	}
+	infob, err := os.Stat(filepath.FromSlash(fb))
+	if err != nil {
+		return false
+	}
+	return os.SameFile(infoa, infob)
+}
+
+// FileURI returns a span URI for the supplied file path.
+// It will always have the file scheme.
+func FileURI(path string) URI {
+	if path == "" {
+		return ""
+	}
+	// Handle standard library paths that contain the literal "$GOROOT".
+	// TODO(rstambler): The go/packages API should allow one to determine a user's $GOROOT.
+	const prefix = "$GOROOT"
+	if len(path) >= len(prefix) && strings.EqualFold(prefix, path[:len(prefix)]) {
+		suffix := path[len(prefix):]
+		path = runtime.GOROOT() + suffix
+	}
+	if !isWindowsDrivePath(path) {
+		if abs, err := filepath.Abs(path); err == nil {
+			path = abs
+		}
+	}
+	// Check the file path again, in case it became absolute.
+	if isWindowsDrivePath(path) {
+		path = "/" + path
+	}
+	path = filepath.ToSlash(path)
+	u := url.URL{
+		Scheme: fileScheme,
+		Path:   path,
+	}
+	uri := u.String()
+	if unescaped, err := url.PathUnescape(uri); err == nil {
+		uri = unescaped
+	}
+	return URI(uri)
+}
+
+// isWindowsDrivePath returns true if the file path is of the form used by
+// Windows. We check if the path begins with a drive letter, followed by a ":".
+func isWindowsDrivePath(path string) bool {
+	if len(path) < 4 {
+		return false
+	}
+	return unicode.IsLetter(rune(path[0])) && path[1] == ':'
+}
+
+// isWindowsDriveURI returns true if the file URI is of the format used by
+// Windows URIs. The url.Parse package does not specially handle Windows paths
+// (see https://golang.org/issue/6027). We check if the URI path has
+// a drive prefix (e.g. "/C:"). If so, we trim the leading "/".
+func isWindowsDriveURI(uri string) bool {
+	if len(uri) < 4 {
+		return false
+	}
+	return uri[0] == '/' && unicode.IsLetter(rune(uri[1])) && uri[2] == ':'
+}
diff --git a/utils/vscode/src/lsp/span/utf16.go b/utils/vscode/src/lsp/span/utf16.go
new file mode 100644
index 0000000..6821851
--- /dev/null
+++ b/utils/vscode/src/lsp/span/utf16.go
@@ -0,0 +1,104 @@
+// Copyright 2019 The Go Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package span
+
+import (
+	"fmt"
+	"unicode/utf16"
+	"unicode/utf8"
+)
+
+// ToUTF16Column calculates the utf16 column expressed by the point given the
+// supplied file contents.
+// This is used to convert from the native (always in bytes) column
+// representation and the utf16 counts used by some editors.
+func ToUTF16Column(p Point, content []byte) (int, error) {
+	if content == nil {
+		return -1, fmt.Errorf("ToUTF16Column: missing content")
+	}
+	if !p.HasPosition() {
+		return -1, fmt.Errorf("ToUTF16Column: point is missing position")
+	}
+	if !p.HasOffset() {
+		return -1, fmt.Errorf("ToUTF16Column: point is missing offset")
+	}
+	offset := p.Offset()      // 0-based
+	colZero := p.Column() - 1 // 0-based
+	if colZero == 0 {
+		// 0-based column 0, so it must be chr 1
+		return 1, nil
+	} else if colZero < 0 {
+		return -1, fmt.Errorf("ToUTF16Column: column is invalid (%v)", colZero)
+	}
+	// work out the offset at the start of the line using the column
+	lineOffset := offset - colZero
+	if lineOffset < 0 || offset > len(content) {
+		return -1, fmt.Errorf("ToUTF16Column: offsets %v-%v outside file contents (%v)", lineOffset, offset, len(content))
+	}
+	// Use the offset to pick out the line start.
+	// This cannot panic: offset > len(content) and lineOffset < offset.
+	start := content[lineOffset:]
+
+	// Now, truncate down to the supplied column.
+	start = start[:colZero]
+
+	// and count the number of utf16 characters
+	// in theory we could do this by hand more efficiently...
+	return len(utf16.Encode([]rune(string(start)))) + 1, nil
+}
+
+// FromUTF16Column advances the point by the utf16 character offset given the
+// supplied line contents.
+// This is used to convert from the utf16 counts used by some editors to the
+// native (always in bytes) column representation.
+func FromUTF16Column(p Point, chr int, content []byte) (Point, error) {
+	if !p.HasOffset() {
+		return Point{}, fmt.Errorf("FromUTF16Column: point is missing offset")
+	}
+	// if chr is 1 then no adjustment needed
+	if chr <= 1 {
+		return p, nil
+	}
+	if p.Offset() >= len(content) {
+		return p, fmt.Errorf("FromUTF16Column: offset (%v) greater than length of content (%v)", p.Offset(), len(content))
+	}
+	remains := content[p.Offset():]
+	// scan forward the specified number of characters
+	for count := 1; count < chr; count++ {
+		if len(remains) <= 0 {
+			return Point{}, fmt.Errorf("FromUTF16Column: chr goes beyond the content")
+		}
+		r, w := utf8.DecodeRune(remains)
+		if r == '\n' {
+			// Per the LSP spec:
+			//
+			// > If the character value is greater than the line length it
+			// > defaults back to the line length.
+			break
+		}
+		remains = remains[w:]
+		if r >= 0x10000 {
+			// a two point rune
+			count++
+			// if we finished in a two point rune, do not advance past the first
+			if count >= chr {
+				break
+			}
+		}
+		p.v.Column += w
+		p.v.Offset += w
+	}
+	return p, nil
+}