lsp

Documentation

Index

• func ReadAll(dir string, byFile map[string]*CompilerDiagnostics, verbose int) error
• type CompilerDiagnostics
  • func ReadFile(r io.Reader, verbose int) (cd *CompilerDiagnostics, err error)
  • func ReadPackage(dir string, verbose int) (cds []*CompilerDiagnostics, err error)
• type Diagnostic
• type DiagnosticRelatedInformation
• type DiagnosticSeverity
• type DiagnosticTag
• type DocumentURI
• type Location
• type Position
• type Range
• type VersionHeader

Functions

func ReadAll

func ReadAll(dir string, byFile map[string]*CompilerDiagnostics, verbose int) error

ReadAll opens a directory of directories, where each directory corresponds to a package, and populates a map from (outermost) source file to compiler diagnostics for that file. Indexing is by outermost file for a diagnostic's position.

Types

type CompilerDiagnostics

type CompilerDiagnostics struct {
	Header      *VersionHeader
	Diagnostics []*Diagnostic
}

func ReadFile

func ReadFile(r io.Reader, verbose int) (cd *CompilerDiagnostics, err error)

ReadFile converts the json-encoded contents of a file (reader) into a version header and diagnostics.

func ReadPackage

func ReadPackage(dir string, verbose int) (cds []*CompilerDiagnostics, err error)

ReadPackage opens a directory presumably filled with XXX.json files that corresponds to a compiler/optimization information for a single package, and converts them to their various CompilerDiagnostics. The contents are self-identifying.

type Diagnostic

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"` // always SeverityInformation for optimizer logging.

	/*Code defined:
	 * The diagnostic's code, which usually appear in the user interface.
	 */
	Code string `json:"code,omitempty"` // LSP uses 'number | string' = gopls interface{}, but only string here, e.g. "boundsCheck", "nilcheck", etc.

	/*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"` // "go compiler"

	/*Message defined:
	 * The diagnostic's message. It usually appears in the user interface
	 */
	Message string `json:"message"` // sometimes used, provides additional information.

	/*Tags defined:
	 * Additional metadata about the diagnostic.
	 */
	Tags []DiagnosticTag `json:"tags,omitempty"` // always empty for logging optimizations.

	/*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"`
}

Diagnostic defined:

• Represents a diagnostic, such as a compiler error or warning. Diagnostic objects
• are only valid in the scope of a resource.

type DiagnosticRelatedInformation

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"`
}

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 DiagnosticSeverity

type DiagnosticSeverity uint

DiagnosticSeverity defines constants

const (
	/*SeverityInformation defined:
	 * Reports an information.
	 */
	SeverityInformation DiagnosticSeverity = 3
)

type DiagnosticTag

type DiagnosticTag uint

DiagnosticTag defines constants

type DocumentURI

type DocumentURI string

type Location

type Location struct {
	// URI is
	URI DocumentURI `json:"uri"`

	// Range is
	Range Range `json:"range"`
}

A Location represents a location inside a resource, such as a line inside a text file.

type Position

type Position struct {
	Line      uint `json:"line"`      // gopls uses float64, but json output is the same for integers
	Character uint `json:"character"` // gopls uses float64, but json output is the same for integers
}

type Range

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"` // exclusive
}

A Range in a text document expressed as (zero-based) start and end positions. A range is comparable to a selection in an editor. Therefore the end position is exclusive. 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.

type VersionHeader

type VersionHeader struct {
	Version   int    `json:"version"`
	Package   string `json:"package"`
	Goos      string `json:"goos"`
	Goarch    string `json:"goarch"`
	GcVersion string `json:"gc_version"`
	File      string `json:"file,omitempty"` // LSP requires an enclosing resource, i.e., a file
}