scip

type Descriptor struct {
	Name          string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Disambiguator string            `protobuf:"bytes,2,opt,name=disambiguator,proto3" json:"disambiguator,omitempty"`
	Suffix        Descriptor_Suffix `protobuf:"varint,3,opt,name=suffix,proto3,enum=scip.Descriptor_Suffix" json:"suffix,omitempty"`
	// contains filtered or unexported fields
}

type Descriptor_Suffix int32

type Diagnostic struct {

	// Should this diagnostic be reported as an error, warning, info, or hint?
	Severity Severity `protobuf:"varint,1,opt,name=severity,proto3,enum=scip.Severity" json:"severity,omitempty"`
	// (optional) Code of this diagnostic, which might appear in the user interface.
	Code string `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"`
	// Message of this diagnostic.
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	// (optional) Human-readable string describing the source of this diagnostic, e.g.
	// 'typescript' or 'super lint'.
	Source string          `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
	Tags   []DiagnosticTag `protobuf:"varint,5,rep,packed,name=tags,proto3,enum=scip.DiagnosticTag" json:"tags,omitempty"`
	// contains filtered or unexported fields
}

type DiagnosticTag int32

type Document struct {

	// The string ID for the programming language this file is written in.
	// The `Language` enum contains the names of most common programming languages.
	// This field is typed as a string to permit any programming language, including
	// ones that are not specified by the `Language` enum.
	Language string `protobuf:"bytes,4,opt,name=language,proto3" json:"language,omitempty"`
	// (Required) Unique path to the text document.
	//
	//  1. The path must be relative to the directory supplied in the associated
	//     `Metadata.project_root`.
	//  2. The path must not begin with a leading '/'.
	//  3. The path must point to a regular file, not a symbolic link.
	//  4. The path must use '/' as the separator, including on Windows.
	//  5. The path must be canonical; it cannot include empty components ('//'),
	//     or '.' or '..'.
	RelativePath string `protobuf:"bytes,1,opt,name=relative_path,json=relativePath,proto3" json:"relative_path,omitempty"`
	// Occurrences that appear in this file.
	Occurrences []*Occurrence `protobuf:"bytes,2,rep,name=occurrences,proto3" json:"occurrences,omitempty"`
	// Symbols that are "defined" within this document.
	//
	// This should include symbols which technically do not have any definition,
	// but have a reference and are defined by some other symbol (see
	// Relationship.is_definition).
	Symbols []*SymbolInformation `protobuf:"bytes,3,rep,name=symbols,proto3" json:"symbols,omitempty"`
	// (optional) Text contents of the this document. Indexers are not expected to
	// include the text by default. It's preferrable that clients read the text
	// contents from the file system by resolving the absolute path from joining
	// `Index.metadata.project_root` and `Document.relative_path`. This field was
	// introduced to support `SymbolInformation.signature_documentation`, but it
	// can be used for other purposes as well, for example testing or when working
	// with virtual/in-memory documents.
	Text string `protobuf:"bytes,5,opt,name=text,proto3" json:"text,omitempty"`
	// Specifies the encoding used for source ranges in this Document.
	//
	// Usually, this will match the type used to index the string type
	// in the indexer's implementation language in O(1) time.
	//   - For an indexer implemented in JVM/.NET language or JavaScript/TypeScript,
	//     use UTF16CodeUnitOffsetFromLineStart.
	//   - For an indexer implemented in Python,
	//     use UTF32CodeUnitOffsetFromLineStart.
	//   - For an indexer implemented in Go, Rust or C++,
	//     use UTF8ByteOffsetFromLineStart.
	PositionEncoding PositionEncoding `` /* 137-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Index struct {

	// Metadata about this index.
	Metadata *Metadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Documents that belong to this index.
	Documents []*Document `protobuf:"bytes,2,rep,name=documents,proto3" json:"documents,omitempty"`
	// (optional) Symbols that are referenced from this index but are defined in
	// an external package (a separate `Index` message). Leave this field empty
	// if you assume the external package will get indexed separately. If the
	// external package won't get indexed for some reason then you can use this
	// field to provide hover documentation for those external symbols.
	ExternalSymbols []*SymbolInformation `protobuf:"bytes,3,rep,name=external_symbols,json=externalSymbols,proto3" json:"external_symbols,omitempty"`
	// contains filtered or unexported fields
}

type IndexVisitor struct {
	VisitMetadata       func(*Metadata)
	VisitDocument       func(*Document)
	VisitExternalSymbol func(*SymbolInformation)
}

type Language int32

type Metadata struct {

	// Which version of this protocol was used to generate this index?
	Version ProtocolVersion `protobuf:"varint,1,opt,name=version,proto3,enum=scip.ProtocolVersion" json:"version,omitempty"`
	// Information about the tool that produced this index.
	ToolInfo *ToolInfo `protobuf:"bytes,2,opt,name=tool_info,json=toolInfo,proto3" json:"tool_info,omitempty"`
	// URI-encoded absolute path to the root directory of this index. All
	// documents in this index must appear in a subdirectory of this root
	// directory.
	ProjectRoot string `protobuf:"bytes,3,opt,name=project_root,json=projectRoot,proto3" json:"project_root,omitempty"`
	// Text encoding of the source files on disk that are referenced from
	// `Document.relative_path`. This value is unrelated to the `Document.text`
	// field, which is a Protobuf string and hence must be UTF-8 encoded.
	TextDocumentEncoding TextEncoding `` /* 147-byte string literal not displayed */
	// contains filtered or unexported fields
}

type Occurrence struct {

	// Source position of this occurrence. Must be exactly three or four
	// elements:
	//
	//   - Four elements: `[startLine, startCharacter, endLine, endCharacter]`
	//   - Three elements: `[startLine, startCharacter, endCharacter]`. The end line
	//     is inferred to have the same value as the start line.
	//
	// Line numbers and characters are always 0-based. Make sure to increment the
	// line/character values before displaying them in an editor-like UI because
	// editors conventionally use 1-based numbers.
	//
	// The 'character' value is interpreted based on the PositionEncoding for
	// the Document.
	//
	// Historical note: the original draft of this schema had a `Range` message
	// type with `start` and `end` fields of type `Position`, mirroring LSP.
	// Benchmarks revealed that this encoding was inefficient and that we could
	// reduce the total payload size of an index by 50% by using `repeated int32`
	// instead. The `repeated int32` encoding is admittedly more embarrassing to
	// work with in some programming languages but we hope the performance
	// improvements make up for it.
	Range []int32 `protobuf:"varint,1,rep,packed,name=range,proto3" json:"range,omitempty"`
	// (optional) The symbol that appears at this position. See
	// `SymbolInformation.symbol` for how to format symbols as strings.
	Symbol string `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
	// (optional) Bitset containing `SymbolRole`s in this occurrence.
	// See `SymbolRole`'s documentation for how to read and write this field.
	SymbolRoles int32 `protobuf:"varint,3,opt,name=symbol_roles,json=symbolRoles,proto3" json:"symbol_roles,omitempty"`
	// (optional) CommonMark-formatted documentation for this specific range. If
	// empty, the `Symbol.documentation` field is used instead. One example
	// where this field might be useful is when the symbol represents a generic
	// function (with abstract type parameters such as `List<T>`) and at this
	// occurrence we know the exact values (such as `List<String>`).
	//
	// This field can also be used for dynamically or gradually typed languages,
	// which commonly allow for type-changing assignment.
	OverrideDocumentation []string `protobuf:"bytes,4,rep,name=override_documentation,json=overrideDocumentation,proto3" json:"override_documentation,omitempty"`
	// (optional) What syntax highlighting class should be used for this range?
	SyntaxKind SyntaxKind `protobuf:"varint,5,opt,name=syntax_kind,json=syntaxKind,proto3,enum=scip.SyntaxKind" json:"syntax_kind,omitempty"`
	// (optional) Diagnostics that have been reported for this specific range.
	Diagnostics []*Diagnostic `protobuf:"bytes,6,rep,name=diagnostics,proto3" json:"diagnostics,omitempty"`
	// (optional) Using the same encoding as the sibling `range` field, source
	// position of the nearest non-trivial enclosing AST node. This range must
	// enclose the `range` field. Example applications that make use of the
	// enclosing_range field:
	//
	//   - Call hierarchies: to determine what symbols are references from the body
	//     of a function
	//   - Symbol outline: to display breadcrumbs from the cursor position to the
	//     root of the file
	//   - Expand selection: to select the nearest enclosing AST node.
	//   - Highlight range: to indicate the AST expression that is associated with a
	//     hover popover
	//
	// For definition occurrences, the enclosing range should indicate the
	// start/end bounds of the entire definition AST node, including
	// documentation.
	// “`
	// const n = 3
	//
	//	^ range
	//
	// ^^^^^^^^^^^ enclosing_range
	//
	// /** Parses the string into something */
	// ^ enclosing_range start --------------------------------------|
	// function parse(input string): string {                        |
	//
	//	         ^^^^^ range                                          |
	//	    return input.slice(n)                                     |
	//	}                                                             |
	//
	// ^ enclosing_range end <---------------------------------------|
	// “`
	//
	// Any attributes/decorators/attached macros should also be part of the
	// enclosing range.
	//
	// “`python
	// @cache
	// ^ enclosing_range start---------------------|
	// def factorial(n):                           |
	//
	//	return n * factorial(n-1) if n else 1   |
	//
	// < enclosing_range end-----------------------|
	//
	// “`
	//
	// For reference occurrences, the enclosing range should indicate the start/end
	// bounds of the parent expression.
	// “`
	// const a = a.b
	//
	//	  ^ range
	//	^^^ enclosing_range
	//
	// const b = a.b(41).f(42).g(43)
	//
	//	        ^ range
	//	^^^^^^^^^^^^^ enclosing_range
	//
	// “`
	EnclosingRange []int32 `protobuf:"varint,7,rep,packed,name=enclosing_range,json=enclosingRange,proto3" json:"enclosing_range,omitempty"`
	// contains filtered or unexported fields
}

type Package struct {
	Manager string `protobuf:"bytes,1,opt,name=manager,proto3" json:"manager,omitempty"`
	Name    string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type Position struct {
	Line      int32
	Character int32
}

type PositionEncoding int32

type ProtocolVersion int32

type Range struct {
	Start Position
	End   Position
}

type Relationship struct {
	Symbol string `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	// When resolving "Find references", this field documents what other symbols
	// should be included together with this symbol. For example, consider the
	// following TypeScript code that defines two symbols `Animal#sound()` and
	// `Dog#sound()`:
	// “`ts
	//
	//	interface Animal {
	//	          ^^^^^^ definition Animal#
	//	  sound(): string
	//	  ^^^^^ definition Animal#sound()
	//	}
	//
	//	class Dog implements Animal {
	//	      ^^^ definition Dog#, relationships = [{symbol: "Animal#", is_implementation: true}]
	//	  public sound(): string { return "woof" }
	//	         ^^^^^ definition Dog#sound(), references_symbols = Animal#sound(), relationships = [{symbol: "Animal#sound()", is_implementation:true, is_reference: true}]
	//	}
	//
	// const animal: Animal = new Dog()
	//
	//	^^^^^^ reference Animal#
	//
	// console.log(animal.sound())
	//
	//	^^^^^ reference Animal#sound()
	//
	// “`
	// Doing "Find references" on the symbol `Animal#sound()` should return
	// references to the `Dog#sound()` method as well. Vice-versa, doing "Find
	// references" on the `Dog#sound()` method should include references to the
	// `Animal#sound()` method as well.
	IsReference bool `protobuf:"varint,2,opt,name=is_reference,json=isReference,proto3" json:"is_reference,omitempty"`
	// Similar to `is_reference` but for "Find implementations".
	// It's common for `is_implementation` and `is_reference` to both be true but
	// it's not always the case.
	// In the TypeScript example above, observe that `Dog#` has an
	// `is_implementation` relationship with `"Animal#"` but not `is_reference`.
	// This is because "Find references" on the "Animal#" symbol should not return
	// "Dog#". We only want "Dog#" to return as a result for "Find
	// implementations" on the "Animal#" symbol.
	IsImplementation bool `protobuf:"varint,3,opt,name=is_implementation,json=isImplementation,proto3" json:"is_implementation,omitempty"`
	// Similar to `references_symbols` but for "Go to type definition".
	IsTypeDefinition bool `protobuf:"varint,4,opt,name=is_type_definition,json=isTypeDefinition,proto3" json:"is_type_definition,omitempty"`
	// Allows overriding the behavior of "Go to definition" and "Find references"
	// for symbols which do not have a definition of their own or could
	// potentially have multiple definitions.
	//
	// For example, in a language with single inheritance and no field overriding,
	// inherited fields can reuse the same symbol as the ancestor which declares
	// the field. In such a situation, is_definition is not needed.
	//
	// On the other hand, in languages with single inheritance and some form
	// of mixins, you can use is_definition to relate the symbol to the
	// matching symbol in ancestor classes, and is_reference to relate the
	// symbol to the matching symbol in mixins.
	//
	// NOTE: At the moment, due to limitations of the SCIP to LSIF conversion,
	// only global symbols in an index are allowed to use is_definition.
	// The relationship may not get recorded if either symbol is local.
	IsDefinition bool `protobuf:"varint,5,opt,name=is_definition,json=isDefinition,proto3" json:"is_definition,omitempty"` // Update registerInverseRelationships on adding a new field here.
	// contains filtered or unexported fields
}

type Severity int32

type SourceFile struct {
	AbsolutePath string
	RelativePath string
	Text         string
	Lines        []string
}

type Symbol struct {
	Scheme      string        `protobuf:"bytes,1,opt,name=scheme,proto3" json:"scheme,omitempty"`
	Package     *Package      `protobuf:"bytes,2,opt,name=package,proto3" json:"package,omitempty"`
	Descriptors []*Descriptor `protobuf:"bytes,3,rep,name=descriptors,proto3" json:"descriptors,omitempty"`
	// contains filtered or unexported fields
}

type SymbolFormatter struct {
	OnError               func(err error) error
	IncludeScheme         func(scheme string) bool
	IncludePackageManager func(manager string) bool
	IncludePackageName    func(name string) bool
	IncludePackageVersion func(version string) bool
	IncludeDescriptor     func(descriptor string) bool
	IncludeRawDescriptor  func(descriptor *Descriptor) bool
	IncludeDisambiguator  func(disambiguator string) bool
}

type SymbolInformation struct {

	// Identifier of this symbol, which can be referenced from `Occurence.symbol`.
	// The string must be formatted according to the grammar in `Symbol`.
	Symbol string `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	// (optional, but strongly recommended) The markdown-formatted documentation
	// for this symbol. Use `SymbolInformation.signature_documentation` to
	// document the method/class/type signature of this symbol.
	// Due to historical reasons, indexers may include signature documentation in
	// this field by rendering markdown code blocks. New indexers should only
	// include non-code documentation in this field, for example docstrings.
	Documentation []string `protobuf:"bytes,3,rep,name=documentation,proto3" json:"documentation,omitempty"`
	// (optional) Relationships to other symbols (e.g., implements, type definition).
	Relationships []*Relationship `protobuf:"bytes,4,rep,name=relationships,proto3" json:"relationships,omitempty"`
	// The kind of this symbol. Use this field instead of
	// `SymbolDescriptor.Suffix` to determine whether something is, for example, a
	// class or a method.
	Kind SymbolInformation_Kind `protobuf:"varint,5,opt,name=kind,proto3,enum=scip.SymbolInformation_Kind" json:"kind,omitempty"`
	// (optional) The name of this symbol as it should be displayed to the user.
	// For example, the symbol "com/example/MyClass#myMethod(+1)." should have the
	// display name "myMethod". The `symbol` field is not a reliable source of
	// the display name for several reasons:
	//
	//   - Local symbols don't encode the name.
	//   - Some languages have case-insensitive names, so the symbol is all-lowercase.
	//   - The symbol may encode names with special characters that should not be
	//     displayed to the user.
	DisplayName string `protobuf:"bytes,6,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// (optional) The signature of this symbol as it's displayed in API
	// documentation or in hover tooltips. For example, a Java method that adds
	// two numbers this would have `Document.language = "java"` and `Document.text
	// = "void add(int a, int b)". The `language` and `text` fields are required
	// while other fields such as `Documentation.occurrences` can be optionally
	// included to support hyperlinking referenced symbols in the signature.
	SignatureDocumentation *Document `` /* 127-byte string literal not displayed */
	// (optional) The enclosing symbol if this is a local symbol.  For non-local
	// symbols, the enclosing symbol should be parsed from the `symbol` field
	// using the `Descriptor` grammar.
	//
	// The primary use-case for this field is to allow local symbol to be displayed
	// in a symbol hierarchy for API documentation. It's OK to leave this field
	// empty for local variables since local variables usually don't belong in API
	// documentation. However, in the situation that you wish to include a local
	// symbol in the hierarchy, then you can use `enclosing_symbol` to locate the
	// "parent" or "owner" of this local symbol. For example, a Java indexer may
	// choose to use local symbols for private class fields while providing an
	// `enclosing_symbol` to reference the enclosing class to allow the field to
	// be part of the class documentation hierarchy. From the perspective of an
	// author of an indexer, the decision to use a local symbol or global symbol
	// should exclusively be determined whether the local symbol is accessible
	// outside the document, not by the capability to find the enclosing
	// symbol.
	EnclosingSymbol string `protobuf:"bytes,8,opt,name=enclosing_symbol,json=enclosingSymbol,proto3" json:"enclosing_symbol,omitempty"`
	// contains filtered or unexported fields
}

type SymbolInformation_Kind int32

type SymbolRole int32

type SyntaxKind int32

type TextEncoding int32

type ToolInfo struct {

	// Name of the indexer that produced this index.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Version of the indexer that produced this index.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Command-line arguments that were used to invoke this indexer.
	Arguments []string `protobuf:"bytes,3,rep,name=arguments,proto3" json:"arguments,omitempty"`
	// contains filtered or unexported fields
}