Adam Jeniski
3f669b422a
Features: - Generate SCIP index from clojure-lsp dump - Namespace definitions and usages - Var definitions and usages - Namespace alias definitions and usage references - External symbol documentation for hover Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
886 lines
32 KiB
Protocol Buffer
886 lines
32 KiB
Protocol Buffer
// An index contains one or more pieces of information about a given piece of
|
|
// source code or software artifact. Complementary information can be merged
|
|
// together from multiple sources to provide a unified code intelligence
|
|
// experience.
|
|
//
|
|
// Programs producing a file of this format is an "indexer" and may operate
|
|
// somewhere on the spectrum between precision, such as indexes produced by
|
|
// compiler-backed indexers, and heurstics, such as indexes produced by local
|
|
// syntax-directed analysis for scope rules.
|
|
|
|
syntax = "proto3";
|
|
|
|
package scip;
|
|
|
|
option go_package = "github.com/sourcegraph/scip/bindings/go/scip/";
|
|
|
|
// Index represents a complete SCIP index for a workspace this is rooted at a
|
|
// single directory. An Index message payload can have a large memory footprint
|
|
// and it's therefore recommended to emit and consume an Index payload one field
|
|
// value at a time. To permit streaming consumption of an Index payload, the
|
|
// `metadata` field must appear at the start of the stream and must only appear
|
|
// once in the stream. Other field values may appear in any order.
|
|
message Index {
|
|
// Metadata about this index.
|
|
Metadata metadata = 1;
|
|
// Documents that belong to this index.
|
|
repeated Document documents = 2;
|
|
// (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.
|
|
repeated SymbolInformation external_symbols = 3;
|
|
// IMPORTANT: When adding a new field to `Index` here, add a matching
|
|
// function in `IndexVisitor` and update `ParseStreaming`.
|
|
}
|
|
|
|
message Metadata {
|
|
// Which version of this protocol was used to generate this index?
|
|
ProtocolVersion version = 1;
|
|
// Information about the tool that produced this index.
|
|
ToolInfo tool_info = 2;
|
|
// 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.
|
|
string project_root = 3;
|
|
// 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.
|
|
TextEncoding text_document_encoding = 4;
|
|
}
|
|
|
|
enum ProtocolVersion {
|
|
UnspecifiedProtocolVersion = 0;
|
|
}
|
|
|
|
enum TextEncoding {
|
|
UnspecifiedTextEncoding = 0;
|
|
UTF8 = 1;
|
|
UTF16 = 2;
|
|
}
|
|
|
|
message ToolInfo {
|
|
// Name of the indexer that produced this index.
|
|
string name = 1;
|
|
// Version of the indexer that produced this index.
|
|
string version = 2;
|
|
// Command-line arguments that were used to invoke this indexer.
|
|
repeated string arguments = 3;
|
|
}
|
|
|
|
// Document defines the metadata about a source file on disk.
|
|
message Document {
|
|
// 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.
|
|
string language = 4;
|
|
// (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 '..'.
|
|
string relative_path = 1;
|
|
// Occurrences that appear in this file.
|
|
repeated Occurrence occurrences = 2;
|
|
// 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).
|
|
repeated SymbolInformation symbols = 3;
|
|
|
|
// (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.
|
|
string text = 5;
|
|
|
|
// 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 position_encoding = 6;
|
|
}
|
|
|
|
// Encoding used to interpret the 'character' value in source ranges.
|
|
enum PositionEncoding {
|
|
// Default value. This value should not be used by new SCIP indexers
|
|
// so that a consumer can process the SCIP index without ambiguity.
|
|
UnspecifiedPositionEncoding = 0;
|
|
// The 'character' value is interpreted as an offset in terms
|
|
// of UTF-8 code units (i.e. bytes).
|
|
//
|
|
// Example: For the string "🚀 Woo" in UTF-8, the bytes are
|
|
// [240, 159, 154, 128, 32, 87, 111, 111], so the offset for 'W'
|
|
// would be 5.
|
|
UTF8CodeUnitOffsetFromLineStart = 1;
|
|
// The 'character' value is interpreted as an offset in terms
|
|
// of UTF-16 code units (each is 2 bytes).
|
|
//
|
|
// Example: For the string "🚀 Woo", the UTF-16 code units are
|
|
// ['\ud83d', '\ude80', ' ', 'W', 'o', 'o'], so the offset for 'W'
|
|
// would be 3.
|
|
UTF16CodeUnitOffsetFromLineStart = 2;
|
|
// The 'character' value is interpreted as an offset in terms
|
|
// of UTF-32 code units (each is 4 bytes).
|
|
//
|
|
// Example: For the string "🚀 Woo", the UTF-32 code units are
|
|
// ['🚀', ' ', 'W', 'o', 'o'], so the offset for 'W' would be 2.
|
|
UTF32CodeUnitOffsetFromLineStart = 3;
|
|
}
|
|
|
|
// Symbol is similar to a URI, it identifies a class, method, or a local
|
|
// variable. `SymbolInformation` contains rich metadata about symbols such as
|
|
// the docstring.
|
|
//
|
|
// Symbol has a standardized string representation, which can be used
|
|
// interchangeably with `Symbol`. The syntax for Symbol is the following:
|
|
// ```
|
|
// # (<x>)+ stands for one or more repetitions of <x>
|
|
// # (<x>)? stands for zero or one occurrence of <x>
|
|
// <symbol> ::= <scheme> ' ' <package> ' ' (<descriptor>)+ | 'local ' <local-id>
|
|
// <package> ::= <manager> ' ' <package-name> ' ' <version>
|
|
// <scheme> ::= any UTF-8, escape spaces with double space. Must not be empty nor start with 'local'
|
|
// <manager> ::= any UTF-8, escape spaces with double space. Use the placeholder '.' to indicate an empty value
|
|
// <package-name> ::= same as above
|
|
// <version> ::= same as above
|
|
// <descriptor> ::= <namespace> | <type> | <term> | <method> | <type-parameter> | <parameter> | <meta> | <macro>
|
|
// <namespace> ::= <name> '/'
|
|
// <type> ::= <name> '#'
|
|
// <term> ::= <name> '.'
|
|
// <meta> ::= <name> ':'
|
|
// <macro> ::= <name> '!'
|
|
// <method> ::= <name> '(' (<method-disambiguator>)? ').'
|
|
// <type-parameter> ::= '[' <name> ']'
|
|
// <parameter> ::= '(' <name> ')'
|
|
// <name> ::= <identifier>
|
|
// <method-disambiguator> ::= <simple-identifier>
|
|
// <identifier> ::= <simple-identifier> | <escaped-identifier>
|
|
// <simple-identifier> ::= (<identifier-character>)+
|
|
// <identifier-character> ::= '_' | '+' | '-' | '$' | ASCII letter or digit
|
|
// <escaped-identifier> ::= '`' (<escaped-character>)+ '`', must contain at least one non-<identifier-character>
|
|
// <escaped-characters> ::= any UTF-8, escape backticks with double backtick.
|
|
// <local-id> ::= <simple-identifier>
|
|
// ```
|
|
//
|
|
// The list of descriptors for a symbol should together form a fully
|
|
// qualified name for the symbol. That is, it should serve as a unique
|
|
// identifier across the package. Typically, it will include one descriptor
|
|
// for every node in the AST (along the ancestry path) between the root of
|
|
// the file and the node corresponding to the symbol.
|
|
//
|
|
// Local symbols MUST only be used for entities which are local to a Document,
|
|
// and cannot be accessed from outside the Document.
|
|
message Symbol {
|
|
string scheme = 1;
|
|
Package package = 2;
|
|
repeated Descriptor descriptors = 3;
|
|
}
|
|
|
|
// Unit of packaging and distribution.
|
|
//
|
|
// NOTE: This corresponds to a module in Go and JVM languages.
|
|
message Package {
|
|
string manager = 1;
|
|
string name = 2;
|
|
string version = 3;
|
|
}
|
|
|
|
message Descriptor {
|
|
enum Suffix {
|
|
option allow_alias = true;
|
|
UnspecifiedSuffix = 0;
|
|
// Unit of code abstraction and/or namespacing.
|
|
//
|
|
// NOTE: This corresponds to a package in Go and JVM languages.
|
|
Namespace = 1;
|
|
// Use Namespace instead.
|
|
Package = 1 [deprecated=true];
|
|
Type = 2;
|
|
Term = 3;
|
|
Method = 4;
|
|
TypeParameter = 5;
|
|
Parameter = 6;
|
|
// Can be used for any purpose.
|
|
Meta = 7;
|
|
Local = 8;
|
|
Macro = 9;
|
|
}
|
|
string name = 1;
|
|
string disambiguator = 2;
|
|
Suffix suffix = 3;
|
|
// NOTE: If you add new fields here, make sure to update the prepareSlot()
|
|
// function responsible for parsing symbols.
|
|
}
|
|
|
|
// SymbolInformation defines metadata about a symbol, such as the symbol's
|
|
// docstring or what package it's defined it.
|
|
message SymbolInformation {
|
|
// Identifier of this symbol, which can be referenced from `Occurence.symbol`.
|
|
// The string must be formatted according to the grammar in `Symbol`.
|
|
string symbol = 1;
|
|
// (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.
|
|
repeated string documentation = 3;
|
|
// (optional) Relationships to other symbols (e.g., implements, type definition).
|
|
repeated Relationship relationships = 4;
|
|
// 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 kind = 5;
|
|
// (optional) Kind represents the fine-grained category of a symbol, suitable for presenting
|
|
// information about the symbol's meaning in the language.
|
|
//
|
|
// For example:
|
|
// - A Java method would have the kind `Method` while a Go function would
|
|
// have the kind `Function`, even if the symbols for these use the same
|
|
// syntax for the descriptor `SymbolDescriptor.Suffix.Method`.
|
|
// - A Go struct has the symbol kind `Struct` while a Java class has
|
|
// the symbol kind `Class` even if they both have the same descriptor:
|
|
// `SymbolDescriptor.Suffix.Type`.
|
|
//
|
|
// Since Kind is more fine-grained than Suffix:
|
|
// - If two symbols have the same Kind, they should share the same Suffix.
|
|
// - If two symbols have different Suffixes, they should have different Kinds.
|
|
enum Kind {
|
|
UnspecifiedKind = 0;
|
|
// A method which may or may not have a body. For Java, Kotlin etc.
|
|
AbstractMethod = 66;
|
|
// For Ruby's attr_accessor
|
|
Accessor = 72;
|
|
Array = 1;
|
|
// For Alloy
|
|
Assertion = 2;
|
|
AssociatedType = 3;
|
|
// For C++
|
|
Attribute = 4;
|
|
// For Lean
|
|
Axiom = 5;
|
|
Boolean = 6;
|
|
Class = 7;
|
|
// For C++
|
|
Concept = 86;
|
|
Constant = 8;
|
|
Constructor = 9;
|
|
// For Solidity
|
|
Contract = 62;
|
|
// For Haskell
|
|
DataFamily = 10;
|
|
// For C# and F#
|
|
Delegate = 73;
|
|
Enum = 11;
|
|
EnumMember = 12;
|
|
Error = 63;
|
|
Event = 13;
|
|
// For Dart
|
|
Extension = 84;
|
|
// For Alloy
|
|
Fact = 14;
|
|
Field = 15;
|
|
File = 16;
|
|
Function = 17;
|
|
// For 'get' in Swift, 'attr_reader' in Ruby
|
|
Getter = 18;
|
|
// For Raku
|
|
Grammar = 19;
|
|
// For Purescript and Lean
|
|
Instance = 20;
|
|
Interface = 21;
|
|
Key = 22;
|
|
// For Racket
|
|
Lang = 23;
|
|
// For Lean
|
|
Lemma = 24;
|
|
// For solidity
|
|
Library = 64;
|
|
Macro = 25;
|
|
Method = 26;
|
|
// For Ruby
|
|
MethodAlias = 74;
|
|
// Analogous to 'ThisParameter' and 'SelfParameter', but for languages
|
|
// like Go where the receiver doesn't have a conventional name.
|
|
MethodReceiver = 27;
|
|
// Analogous to 'AbstractMethod', for Go.
|
|
MethodSpecification = 67;
|
|
// For Protobuf
|
|
Message = 28;
|
|
// For Dart
|
|
Mixin = 85;
|
|
// For Solidity
|
|
Modifier = 65;
|
|
Module = 29;
|
|
Namespace = 30;
|
|
Null = 31;
|
|
Number = 32;
|
|
Object = 33;
|
|
Operator = 34;
|
|
Package = 35;
|
|
PackageObject = 36;
|
|
Parameter = 37;
|
|
ParameterLabel = 38;
|
|
// For Haskell's PatternSynonyms
|
|
Pattern = 39;
|
|
// For Alloy
|
|
Predicate = 40;
|
|
Property = 41;
|
|
// Analogous to 'Trait' and 'TypeClass', for Swift and Objective-C
|
|
Protocol = 42;
|
|
// Analogous to 'AbstractMethod', for Swift and Objective-C.
|
|
ProtocolMethod = 68;
|
|
// Analogous to 'AbstractMethod', for C++.
|
|
PureVirtualMethod = 69;
|
|
// For Haskell
|
|
Quasiquoter = 43;
|
|
// 'self' in Python, Rust, Swift etc.
|
|
SelfParameter = 44;
|
|
// For 'set' in Swift, 'attr_writer' in Ruby
|
|
Setter = 45;
|
|
// For Alloy, analogous to 'Struct'.
|
|
Signature = 46;
|
|
// For Ruby
|
|
SingletonClass = 75;
|
|
// Analogous to 'StaticMethod', for Ruby.
|
|
SingletonMethod = 76;
|
|
// Analogous to 'StaticField', for C++
|
|
StaticDataMember = 77;
|
|
// For C#
|
|
StaticEvent = 78;
|
|
// For C#
|
|
StaticField = 79;
|
|
// For Java, C#, C++ etc.
|
|
StaticMethod = 80;
|
|
// For C#, TypeScript etc.
|
|
StaticProperty = 81;
|
|
// For C, C++
|
|
StaticVariable = 82;
|
|
String = 48;
|
|
Struct = 49;
|
|
// For Swift
|
|
Subscript = 47;
|
|
// For Lean
|
|
Tactic = 50;
|
|
// For Lean
|
|
Theorem = 51;
|
|
// Method receiver for languages
|
|
// 'this' in JavaScript, C++, Java etc.
|
|
ThisParameter = 52;
|
|
// Analogous to 'Protocol' and 'TypeClass', for Rust, Scala etc.
|
|
Trait = 53;
|
|
// Analogous to 'AbstractMethod', for Rust, Scala etc.
|
|
TraitMethod = 70;
|
|
// Data type definition for languages like OCaml which use `type`
|
|
// rather than separate keywords like `struct` and `enum`.
|
|
Type = 54;
|
|
TypeAlias = 55;
|
|
// Analogous to 'Trait' and 'Protocol', for Haskell, Purescript etc.
|
|
TypeClass = 56;
|
|
// Analogous to 'AbstractMethod', for Haskell, Purescript etc.
|
|
TypeClassMethod = 71;
|
|
// For Haskell
|
|
TypeFamily = 57;
|
|
TypeParameter = 58;
|
|
// For C, C++, Capn Proto
|
|
Union = 59;
|
|
Value = 60;
|
|
Variable = 61;
|
|
// Next = 87;
|
|
// Feel free to open a PR proposing new language-specific kinds.
|
|
}
|
|
// (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.
|
|
string display_name = 6;
|
|
// (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.
|
|
Document signature_documentation = 7;
|
|
// (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.
|
|
string enclosing_symbol = 8;
|
|
}
|
|
|
|
|
|
message Relationship {
|
|
string symbol = 1;
|
|
// 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.
|
|
bool is_reference = 2;
|
|
// 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.
|
|
bool is_implementation = 3;
|
|
// Similar to `references_symbols` but for "Go to type definition".
|
|
bool is_type_definition = 4;
|
|
// 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.
|
|
bool is_definition = 5;
|
|
// Update registerInverseRelationships on adding a new field here.
|
|
}
|
|
|
|
// SymbolRole declares what "role" a symbol has in an occurrence. A role is
|
|
// encoded as a bitset where each bit represents a different role. For example,
|
|
// to determine if the `Import` role is set, test whether the second bit of the
|
|
// enum value is defined. In pseudocode, this can be implemented with the
|
|
// logic: `const isImportRole = (role.value & SymbolRole.Import.value) > 0`.
|
|
enum SymbolRole {
|
|
// This case is not meant to be used; it only exists to avoid an error
|
|
// from the Protobuf code generator.
|
|
UnspecifiedSymbolRole = 0;
|
|
// Is the symbol defined here? If not, then this is a symbol reference.
|
|
Definition = 0x1;
|
|
// Is the symbol imported here?
|
|
Import = 0x2;
|
|
// Is the symbol written here?
|
|
WriteAccess = 0x4;
|
|
// Is the symbol read here?
|
|
ReadAccess = 0x8;
|
|
// Is the symbol in generated code?
|
|
Generated = 0x10;
|
|
// Is the symbol in test code?
|
|
Test = 0x20;
|
|
// Is this a signature for a symbol that is defined elsewhere?
|
|
//
|
|
// Applies to forward declarations for languages like C, C++
|
|
// and Objective-C, as well as `val` declarations in interface
|
|
// files in languages like SML and OCaml.
|
|
ForwardDefinition = 0x40;
|
|
}
|
|
|
|
enum SyntaxKind {
|
|
option allow_alias = true;
|
|
|
|
UnspecifiedSyntaxKind = 0;
|
|
|
|
// Comment, including comment markers and text
|
|
Comment = 1;
|
|
|
|
// `;` `.` `,`
|
|
PunctuationDelimiter = 2;
|
|
// (), {}, [] when used syntactically
|
|
PunctuationBracket = 3;
|
|
|
|
// `if`, `else`, `return`, `class`, etc.
|
|
Keyword = 4;
|
|
IdentifierKeyword = 4 [deprecated=true];
|
|
|
|
// `+`, `*`, etc.
|
|
IdentifierOperator = 5;
|
|
|
|
// non-specific catch-all for any identifier not better described elsewhere
|
|
Identifier = 6;
|
|
// Identifiers builtin to the language: `min`, `print` in Python.
|
|
IdentifierBuiltin = 7;
|
|
// Identifiers representing `null`-like values: `None` in Python, `nil` in Go.
|
|
IdentifierNull = 8;
|
|
// `xyz` in `const xyz = "hello"`
|
|
IdentifierConstant = 9;
|
|
// `var X = "hello"` in Go
|
|
IdentifierMutableGlobal = 10;
|
|
// Parameter definition and references
|
|
IdentifierParameter = 11;
|
|
// Identifiers for variable definitions and references within a local scope
|
|
IdentifierLocal = 12;
|
|
// Identifiers that shadow other identifiers in an outer scope
|
|
IdentifierShadowed = 13;
|
|
// Identifier representing a unit of code abstraction and/or namespacing.
|
|
//
|
|
// NOTE: This corresponds to a package in Go and JVM languages,
|
|
// and a module in languages like Python and JavaScript.
|
|
IdentifierNamespace = 14;
|
|
IdentifierModule = 14 [deprecated=true];
|
|
|
|
// Function references, including calls
|
|
IdentifierFunction = 15;
|
|
// Function definition only
|
|
IdentifierFunctionDefinition = 16;
|
|
|
|
// Macro references, including invocations
|
|
IdentifierMacro = 17;
|
|
// Macro definition only
|
|
IdentifierMacroDefinition = 18;
|
|
|
|
// non-builtin types
|
|
IdentifierType = 19;
|
|
// builtin types only, such as `str` for Python or `int` in Go
|
|
IdentifierBuiltinType = 20;
|
|
|
|
// Python decorators, c-like __attribute__
|
|
IdentifierAttribute = 21;
|
|
|
|
// `\b`
|
|
RegexEscape = 22;
|
|
// `*`, `+`
|
|
RegexRepeated = 23;
|
|
// `.`
|
|
RegexWildcard = 24;
|
|
// `(`, `)`, `[`, `]`
|
|
RegexDelimiter = 25;
|
|
// `|`, `-`
|
|
RegexJoin = 26;
|
|
|
|
// Literal strings: "Hello, world!"
|
|
StringLiteral = 27;
|
|
// non-regex escapes: "\t", "\n"
|
|
StringLiteralEscape = 28;
|
|
// datetimes within strings, special words within a string, `{}` in format strings
|
|
StringLiteralSpecial = 29;
|
|
// "key" in { "key": "value" }, useful for example in JSON
|
|
StringLiteralKey = 30;
|
|
// 'c' or similar, in languages that differentiate strings and characters
|
|
CharacterLiteral = 31;
|
|
// Literal numbers, both floats and integers
|
|
NumericLiteral = 32;
|
|
// `true`, `false`
|
|
BooleanLiteral = 33;
|
|
|
|
// Used for XML-like tags
|
|
Tag = 34;
|
|
// Attribute name in XML-like tags
|
|
TagAttribute = 35;
|
|
// Delimiters for XML-like tags
|
|
TagDelimiter = 36;
|
|
}
|
|
|
|
// Occurrence associates a source position with a symbol and/or highlighting
|
|
// information.
|
|
//
|
|
// If possible, indexers should try to bundle logically related information
|
|
// across occurrences into a single occurrence to reduce payload sizes.
|
|
message Occurrence {
|
|
// Half-open [start, end) range 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.
|
|
//
|
|
// It is allowed for the range to be empty (i.e. start==end).
|
|
//
|
|
// 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.
|
|
repeated int32 range = 1;
|
|
// (optional) The symbol that appears at this position. See
|
|
// `SymbolInformation.symbol` for how to format symbols as strings.
|
|
string symbol = 2;
|
|
// (optional) Bitset containing `SymbolRole`s in this occurrence.
|
|
// See `SymbolRole`'s documentation for how to read and write this field.
|
|
int32 symbol_roles = 3;
|
|
// (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.
|
|
repeated string override_documentation = 4;
|
|
// (optional) What syntax highlighting class should be used for this range?
|
|
SyntaxKind syntax_kind = 5;
|
|
// (optional) Diagnostics that have been reported for this specific range.
|
|
repeated Diagnostic diagnostics = 6;
|
|
// (optional) Using the same encoding as the sibling `range` field, half-open
|
|
// source range 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
|
|
// ```
|
|
repeated int32 enclosing_range = 7;
|
|
}
|
|
|
|
// Represents a diagnostic, such as a compiler error or warning, which should be
|
|
// reported for a document.
|
|
message Diagnostic {
|
|
// Should this diagnostic be reported as an error, warning, info, or hint?
|
|
Severity severity = 1;
|
|
// (optional) Code of this diagnostic, which might appear in the user interface.
|
|
string code = 2;
|
|
// Message of this diagnostic.
|
|
string message = 3;
|
|
// (optional) Human-readable string describing the source of this diagnostic, e.g.
|
|
// 'typescript' or 'super lint'.
|
|
string source = 4;
|
|
repeated DiagnosticTag tags = 5;
|
|
}
|
|
|
|
enum Severity {
|
|
UnspecifiedSeverity = 0;
|
|
Error = 1;
|
|
Warning = 2;
|
|
Information = 3;
|
|
Hint = 4;
|
|
}
|
|
|
|
enum DiagnosticTag {
|
|
UnspecifiedDiagnosticTag = 0;
|
|
Unnecessary = 1;
|
|
Deprecated = 2;
|
|
}
|
|
|
|
// Language standardises names of common programming languages that can be used
|
|
// for the `Document.language` field. The primary purpose of this enum is to
|
|
// prevent a situation where we have a single programming language ends up with
|
|
// multiple string representations. For example, the C++ language uses the name
|
|
// "CPP" in this enum and other names such as "cpp" are incompatible.
|
|
// Feel free to send a pull-request to add missing programming languages.
|
|
enum Language {
|
|
UnspecifiedLanguage = 0;
|
|
ABAP = 60;
|
|
Apex = 96;
|
|
APL = 49;
|
|
Ada = 39;
|
|
Agda = 45;
|
|
AsciiDoc = 86;
|
|
Assembly = 58;
|
|
Awk = 66;
|
|
Bat = 68;
|
|
BibTeX = 81;
|
|
C = 34;
|
|
COBOL = 59;
|
|
CPP = 35; // C++ (the name "CPP" was chosen for consistency with LSP)
|
|
CSS = 26;
|
|
CSharp = 1;
|
|
Clojure = 8;
|
|
Coffeescript = 21;
|
|
CommonLisp = 9;
|
|
Coq = 47;
|
|
CUDA = 97;
|
|
Dart = 3;
|
|
Delphi = 57;
|
|
Diff = 88;
|
|
Dockerfile = 80;
|
|
Dyalog = 50;
|
|
Elixir = 17;
|
|
Erlang = 18;
|
|
FSharp = 42;
|
|
Fish = 65;
|
|
Flow = 24;
|
|
Fortran = 56;
|
|
Git_Commit = 91;
|
|
Git_Config = 89;
|
|
Git_Rebase = 92;
|
|
Go = 33;
|
|
GraphQL = 98;
|
|
Groovy = 7;
|
|
HTML = 30;
|
|
Hack = 20;
|
|
Handlebars = 90;
|
|
Haskell = 44;
|
|
Idris = 46;
|
|
Ini = 72;
|
|
J = 51;
|
|
JSON = 75;
|
|
Java = 6;
|
|
JavaScript = 22;
|
|
JavaScriptReact = 93;
|
|
Jsonnet = 76;
|
|
Julia = 55;
|
|
Justfile = 109;
|
|
Kotlin = 4;
|
|
LaTeX = 83;
|
|
Lean = 48;
|
|
Less = 27;
|
|
Lua = 12;
|
|
Luau = 108;
|
|
Makefile = 79;
|
|
Markdown = 84;
|
|
Matlab = 52;
|
|
Nickel = 110; // https://nickel-lang.org/
|
|
Nix = 77;
|
|
OCaml = 41;
|
|
Objective_C = 36;
|
|
Objective_CPP = 37;
|
|
Pascal = 99;
|
|
PHP = 19;
|
|
PLSQL = 70;
|
|
Perl = 13;
|
|
PowerShell = 67;
|
|
Prolog = 71;
|
|
Protobuf = 100;
|
|
Python = 15;
|
|
R = 54;
|
|
Racket = 11;
|
|
Raku = 14;
|
|
Razor = 62;
|
|
Repro = 102; // Internal language for testing SCIP
|
|
ReST = 85;
|
|
Ruby = 16;
|
|
Rust = 40;
|
|
SAS = 61;
|
|
SCSS = 29;
|
|
SML = 43;
|
|
SQL = 69;
|
|
Sass = 28;
|
|
Scala = 5;
|
|
Scheme = 10;
|
|
ShellScript = 64; // Bash
|
|
Skylark = 78;
|
|
Slang = 107;
|
|
Solidity = 95;
|
|
Svelte = 106;
|
|
Swift = 2;
|
|
Tcl = 101;
|
|
TOML = 73;
|
|
TeX = 82;
|
|
Thrift = 103;
|
|
TypeScript = 23;
|
|
TypeScriptReact = 94;
|
|
Verilog = 104;
|
|
VHDL = 105;
|
|
VisualBasic = 63;
|
|
Vue = 25;
|
|
Wolfram = 53;
|
|
XML = 31;
|
|
XSL = 32;
|
|
YAML = 74;
|
|
Zig = 38;
|
|
// NextLanguage = 111;
|
|
// Steps add a new language:
|
|
// 1. Copy-paste the "NextLanguage = N" line above
|
|
// 2. Increment "NextLanguage = N" to "NextLanguage = N+1"
|
|
// 3. Replace "NextLanguage = N" with the name of the new language.
|
|
// 4. Move the new language to the correct line above using alphabetical order
|
|
// 5. (optional) Add a brief comment behind the language if the name is not self-explanatory
|
|
}
|