// 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
}
