formatting

2 files changed, 346 insertions, 346 deletions

diff --git a/src/server/semantic_tokens.odin b/src/server/semantic_tokens.odin
index 8f6d66d..1086063 100644
--- a/src/server/semantic_tokens.odin
+++ b/src/server/semantic_tokens.odin
@@ -8,192 +8,192 @@ import "shared:common"
 import "shared:index"
 
 SemanticTokenTypes :: enum {
-	Namespace,
-	Type,
-	Enum,
-	Struct,
-	Parameter,
-	Variable,
-	EnumMember,
-	Function,
-	Member,
-	Keyword,
-	Modifier,
-	Comment,
-	String,
-	Number,
-	Operator,
+    Namespace,
+    Type,
+    Enum,
+    Struct,
+    Parameter,
+    Variable,
+    EnumMember,
+    Function,
+    Member,
+    Keyword,
+    Modifier,
+    Comment,
+    String,
+    Number,
+    Operator,
 };
 
 SemanticTokenModifiers :: enum {
-	None,
-	Declaration,
-	Definition,
-	Deprecated,
+    None,
+    Declaration,
+    Definition,
+    Deprecated,
 };
 
 SemanticTokensClientCapabilities :: struct {
 
-	requests: struct {
-		range: bool,
-	},
+    requests: struct {
+        range: bool,
+    },
 
-	tokenTypes: [] string,
-	tokenModifiers: [] string,
-	formats: [] string,
-	overlappingTokenSupport: bool,
-	multilineTokenSupport: bool,
+    tokenTypes: [] string,
+    tokenModifiers: [] string,
+    formats: [] string,
+    overlappingTokenSupport: bool,
+    multilineTokenSupport: bool,
 };
 
 SemanticTokensLegend :: struct {
-	tokenTypes: [] string,
-	tokenModifiers: [] string,
+    tokenTypes: [] string,
+    tokenModifiers: [] string,
 };
 
 SemanticTokensOptions :: struct {
-	legend: SemanticTokensLegend,
-	range: bool,
-	full: bool,
+    legend: SemanticTokensLegend,
+    range: bool,
+    full: bool,
 };
 
 SemanticTokensParams :: struct {
-	textDocument: TextDocumentIdentifier,
+    textDocument: TextDocumentIdentifier,
 };
 
 SemanticTokensRangeParams :: struct {
-	textDocument: TextDocumentIdentifier,
-	range: common.Range,
+    textDocument: TextDocumentIdentifier,
+    range: common.Range,
 };
 
 SemanticTokens :: struct {
-	data: [] u32,
+    data: [] u32,
 };
 
 SemanticTokenBuilder :: struct {
-	current_function: ^ast.Node,
-	current_start: int,
-	tokens: [dynamic] u32,
+    current_function: ^ast.Node,
+    current_start: int,
+    tokens: [dynamic] u32,
 };
 
 make_token_builder :: proc(allocator := context.temp_allocator) -> SemanticTokenBuilder {
 
-	return {
-		tokens = make([dynamic]u32, context.temp_allocator),
-	};
+    return {
+        tokens = make([dynamic]u32, context.temp_allocator),
+    };
 
 }
 
 get_tokens :: proc(builder: SemanticTokenBuilder) -> SemanticTokens {
-	return {
-		data = builder.tokens[:],
-	};
+    return {
+        data = builder.tokens[:],
+    };
 }
 
 get_semantic_tokens :: proc(document: ^Document) -> SemanticTokens {
 
-	ast_context := make_ast_context(document.ast, document.imports, document.package_name, context.temp_allocator);
-	builder := make_token_builder();
+    ast_context := make_ast_context(document.ast, document.imports, document.package_name, context.temp_allocator);
+    builder := make_token_builder();
 
-	get_globals(document.ast, &ast_context);
+    get_globals(document.ast, &ast_context);
 
-	for decl in document.ast.decls {
-		write_semantic_tokens(cast(^ast.Node)decl, &builder, &ast_context);
-	}
+    for decl in document.ast.decls {
+        write_semantic_tokens(cast(^ast.Node)decl, &builder, &ast_context);
+    }
 
-	return get_tokens(builder);
+    return get_tokens(builder);
 }
 
 write_semantic_node :: proc(builder: ^SemanticTokenBuilder, node: ^ast.Node, src: []byte, type: SemanticTokenTypes, modifier: SemanticTokenModifiers) {
 
-	position := common.get_relative_token_position(node.pos.offset, src, builder.current_start);
+    position := common.get_relative_token_position(node.pos.offset, src, builder.current_start);
 
-	name := common.get_ast_node_string(node, src);
+    name := common.get_ast_node_string(node, src);
 
-	append(&builder.tokens, cast(u32)position.line, cast(u32)position.character, cast(u32)len(name), cast(u32)type, 0);
+    append(&builder.tokens, cast(u32)position.line, cast(u32)position.character, cast(u32)len(name), cast(u32)type, 0);
 
-	builder.current_start = node.pos.offset;
+    builder.current_start = node.pos.offset;
 }
 
 write_semantic_token :: proc(builder: ^SemanticTokenBuilder, token: tokenizer.Token, src: []byte, type: SemanticTokenTypes, modifier: SemanticTokenModifiers) {
 
-	position := common.get_relative_token_position(token.pos.offset, src, builder.current_start);
+    position := common.get_relative_token_position(token.pos.offset, src, builder.current_start);
 
-	append(&builder.tokens, cast(u32)position.line, cast(u32)position.character, cast(u32)len(token.text), cast(u32)type, 0);
+    append(&builder.tokens, cast(u32)position.line, cast(u32)position.character, cast(u32)len(token.text), cast(u32)type, 0);
 
-	builder.current_start = token.pos.offset;
+    builder.current_start = token.pos.offset;
 }
 
 
 write_semantic_token_pos :: proc(builder: ^SemanticTokenBuilder, pos: tokenizer.Pos, name: string, src: []byte, type: SemanticTokenTypes, modifier: SemanticTokenModifiers) {
 
-	position := common.get_relative_token_position(pos.offset, src, builder.current_start);
+    position := common.get_relative_token_position(pos.offset, src, builder.current_start);
 
-	append(&builder.tokens, cast(u32)position.line, cast(u32)position.character, cast(u32)len(name), cast(u32)type, 0);
+    append(&builder.tokens, cast(u32)position.line, cast(u32)position.character, cast(u32)len(name), cast(u32)type, 0);
 
-	builder.current_start = pos.offset;
+    builder.current_start = pos.offset;
 }
 
 
 resolve_and_write_ident :: proc(node: ^ast.Node, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
 
-	n := node.derived.(ast.Ident);
-
-	ast_context.current_package = ast_context.document_package;
-
-	if resolve_ident_is_variable(ast_context, n) {
-		write_semantic_node(builder, node, ast_context.file.src, .Variable, .None);
-	}
-
-	else if symbol, ok := resolve_type_identifier(ast_context, n); ok {
-
-		#partial switch v in symbol.value {
-		case index.SymbolPackageValue:
-			write_semantic_node(builder, node, ast_context.file.src, .Namespace, .None);
-		case index.SymbolStructValue:
-			write_semantic_node(builder, node, ast_context.file.src, .Struct, .None);
-		case index.SymbolEnumValue:
-			write_semantic_node(builder, node, ast_context.file.src, .Enum, .None);
-		case index.SymbolUnionValue:
-			write_semantic_node(builder, node, ast_context.file.src, .Enum, .None);
-		case index.SymbolGenericValue:
-			#partial switch symbol.type {
-			case .Keyword:
-				write_semantic_node(builder, node, ast_context.file.src, .Keyword, .None);
-			}
-		}
-
-	}
-}
+    n := node.derived.(ast.Ident);
 
-resolve_and_write_expr :: proc(expr: ^ast.Expr, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
+    ast_context.current_package = ast_context.document_package;
 
-	ast_context.current_package = ast_context.document_package;
+    if resolve_ident_is_variable(ast_context, n) {
+        write_semantic_node(builder, node, ast_context.file.src, .Variable, .None);
+    }
 
-	if symbol, ok := resolve_type_expression(ast_context, expr); ok {
+    else if symbol, ok := resolve_type_identifier(ast_context, n); ok {
+
+        #partial switch v in symbol.value {
+        case index.SymbolPackageValue:
+            write_semantic_node(builder, node, ast_context.file.src, .Namespace, .None);
+        case index.SymbolStructValue:
+            write_semantic_node(builder, node, ast_context.file.src, .Struct, .None);
+        case index.SymbolEnumValue:
+            write_semantic_node(builder, node, ast_context.file.src, .Enum, .None);
+        case index.SymbolUnionValue:
+            write_semantic_node(builder, node, ast_context.file.src, .Enum, .None);
+        case index.SymbolGenericValue:
+            #partial switch symbol.type {
+            case .Keyword:
+                write_semantic_node(builder, node, ast_context.file.src, .Keyword, .None);
+            }
+        }
 
-		#partial switch v in symbol.value {
-		case index.SymbolPackageValue:
-			write_semantic_node(builder, expr, ast_context.file.src, .Namespace, .None);
-		case index.SymbolStructValue:
-			write_semantic_node(builder, expr, ast_context.file.src, .Struct, .None);
-		case index.SymbolEnumValue:
-			write_semantic_node(builder, expr, ast_context.file.src, .Enum, .None);
-		case index.SymbolUnionValue:
-			write_semantic_node(builder, expr, ast_context.file.src, .Enum, .None);
-		case index.SymbolGenericValue:
-			#partial switch symbol.type {
-			case .Keyword:
-				write_semantic_node(builder, expr, ast_context.file.src, .Keyword, .None);
-			}
-		}
+    }
+}
 
-	}
+resolve_and_write_expr :: proc(expr: ^ast.Expr, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
+
+    ast_context.current_package = ast_context.document_package;
+
+    if symbol, ok := resolve_type_expression(ast_context, expr); ok {
+
+        #partial switch v in symbol.value {
+        case index.SymbolPackageValue:
+            write_semantic_node(builder, expr, ast_context.file.src, .Namespace, .None);
+        case index.SymbolStructValue:
+            write_semantic_node(builder, expr, ast_context.file.src, .Struct, .None);
+        case index.SymbolEnumValue:
+            write_semantic_node(builder, expr, ast_context.file.src, .Enum, .None);
+        case index.SymbolUnionValue:
+            write_semantic_node(builder, expr, ast_context.file.src, .Enum, .None);
+        case index.SymbolGenericValue:
+            #partial switch symbol.type {
+            case .Keyword:
+                write_semantic_node(builder, expr, ast_context.file.src, .Keyword, .None);
+            }
+        }
+
+    }
 
 }
 
 write_semantic_tokens :: proc {
-	write_semantic_tokens_node,
-	write_semantic_tokens_dynamic_array,
+    write_semantic_tokens_node,
+    write_semantic_tokens_dynamic_array,
     write_semantic_tokens_array,
 };
 
@@ -215,49 +215,49 @@ write_semantic_tokens_dynamic_array :: proc(array: $A/[dynamic]^$T, builder: ^Se
 
 write_semantic_tokens_node :: proc(node: ^ast.Node, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
 
-	using ast;
+    using ast;
 
     if node == nil {
         return;
     }
 
-	switch n in node.derived {
-	case Ident:
-		resolve_and_write_ident(node, builder, ast_context);
-	case Selector_Expr:
-		write_semantic_selector(cast(^Selector_Expr)node, builder, ast_context);
-	case Pointer_Type:
-		write_semantic_token_pos(builder, node.pos, "^", ast_context.file.src, .Operator, .None);
-		write_semantic_tokens(n.elem, builder, ast_context);
-	case Value_Decl:
-		write_semantic_tokens_value_decl(n, builder, ast_context);
-	case Block_Stmt:
-		write_semantic_tokens(n.stmts, builder, ast_context);
-	case Expr_Stmt:
-		write_semantic_tokens(n.expr, builder, ast_context);
-	case Range_Stmt:
-		get_locals_at(builder.current_function, node, ast_context);
-		write_semantic_token_pos(builder, n.for_pos, "for", ast_context.file.src, .Keyword, .None);
-		if n.val0 != nil {
-			if ident, ok := n.val0.derived.(Ident); ok {
-				write_semantic_node(builder, n.val0, ast_context.file.src, .Variable, .None);
-			}
-		}
-
-		if n.val1 != nil {
-			if ident, ok := n.val1.derived.(Ident); ok {
-				write_semantic_node(builder, n.val1, ast_context.file.src, .Variable, .None);
-			}
-		}
-
-		write_semantic_token_pos(builder, n.in_pos, "in", ast_context.file.src, .Keyword, .None);
-
-		write_semantic_tokens(n.expr, builder, ast_context);
-
-		write_semantic_tokens(n.body, builder, ast_context);
-	case:
-		//log.infof("unhandled write node %v", n);
-	}
+    switch n in node.derived {
+    case Ident:
+        resolve_and_write_ident(node, builder, ast_context);
+    case Selector_Expr:
+        write_semantic_selector(cast(^Selector_Expr)node, builder, ast_context);
+    case Pointer_Type:
+        write_semantic_token_pos(builder, node.pos, "^", ast_context.file.src, .Operator, .None);
+        write_semantic_tokens(n.elem, builder, ast_context);
+    case Value_Decl:
+        write_semantic_tokens_value_decl(n, builder, ast_context);
+    case Block_Stmt:
+        write_semantic_tokens(n.stmts, builder, ast_context);
+    case Expr_Stmt:
+        write_semantic_tokens(n.expr, builder, ast_context);
+    case Range_Stmt:
+        get_locals_at(builder.current_function, node, ast_context);
+        write_semantic_token_pos(builder, n.for_pos, "for", ast_context.file.src, .Keyword, .None);
+        if n.val0 != nil {
+            if ident, ok := n.val0.derived.(Ident); ok {
+                write_semantic_node(builder, n.val0, ast_context.file.src, .Variable, .None);
+            }
+        }
+
+        if n.val1 != nil {
+            if ident, ok := n.val1.derived.(Ident); ok {
+                write_semantic_node(builder, n.val1, ast_context.file.src, .Variable, .None);
+            }
+        }
+
+        write_semantic_token_pos(builder, n.in_pos, "in", ast_context.file.src, .Keyword, .None);
+
+        write_semantic_tokens(n.expr, builder, ast_context);
+
+        write_semantic_tokens(n.body, builder, ast_context);
+    case:
+        //log.infof("unhandled write node %v", n);
+    }
 
 
 
@@ -265,129 +265,129 @@ write_semantic_tokens_node :: proc(node: ^ast.Node, builder: ^SemanticTokenBuild
 
 write_semantic_tokens_value_decl :: proc(value_decl: ast.Value_Decl, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
 
-	using ast;
+    using ast;
 
-	for name, i in value_decl.names {
-		if ident, ok := name.derived.(Ident); ok {
+    for name, i in value_decl.names {
+        if ident, ok := name.derived.(Ident); ok {
 
-			if value_decl.type != nil {
+            if value_decl.type != nil {
 
-			}
+            }
 
-			else {
+            else {
 
-				if len(value_decl.values) == 1 {
+                if len(value_decl.values) == 1 {
 
-					switch v in value_decl.values[0].derived {
-					case ast.Struct_Type:
-						write_semantic_node(builder, name, ast_context.file.src, .Struct, .None);
-						write_semantic_token_pos(builder, v.pos, "struct", ast_context.file.src, .Keyword, .None);
-					case ast.Enum_Type:
-						write_semantic_node(builder, name, ast_context.file.src, .Enum, .None);
-						write_semantic_token_pos(builder, v.pos, "enum", ast_context.file.src, .Keyword, .None);
-						write_semantic_enum_fields(v, builder, ast_context);
-					case ast.Proc_Lit:
-						write_semantic_node(builder, name, ast_context.file.src, .Function, .None);
-						write_semantic_token_pos(builder, v.pos, "proc", ast_context.file.src, .Keyword, .None);
-						write_semantic_proc_type(v.type, builder, ast_context);
+                    switch v in value_decl.values[0].derived {
+                    case ast.Struct_Type:
+                        write_semantic_node(builder, name, ast_context.file.src, .Struct, .None);
+                        write_semantic_token_pos(builder, v.pos, "struct", ast_context.file.src, .Keyword, .None);
+                    case ast.Enum_Type:
+                        write_semantic_node(builder, name, ast_context.file.src, .Enum, .None);
+                        write_semantic_token_pos(builder, v.pos, "enum", ast_context.file.src, .Keyword, .None);
+                        write_semantic_enum_fields(v, builder, ast_context);
+                    case ast.Proc_Lit:
+                        write_semantic_node(builder, name, ast_context.file.src, .Function, .None);
+                        write_semantic_token_pos(builder, v.pos, "proc", ast_context.file.src, .Keyword, .None);
+                        write_semantic_proc_type(v.type, builder, ast_context);
 
-						last_function := builder.current_function;
-						builder.current_function = value_decl.values[0];
-						get_locals_at(builder.current_function, builder.current_function, ast_context);
-						write_semantic_tokens(v.body, builder, ast_context);
-						builder.current_function = last_function;
-					}
+                        last_function := builder.current_function;
+                        builder.current_function = value_decl.values[0];
+                        get_locals_at(builder.current_function, builder.current_function, ast_context);
+                        write_semantic_tokens(v.body, builder, ast_context);
+                        builder.current_function = last_function;
+                    }
 
-				}
+                }
 
-				else {
+                else {
 
-				}
+                }
 
-			}
+            }
 
-		}
-	}
+        }
+    }
 
 }
 
 write_semantic_proc_type :: proc(node: ^ast.Proc_Type, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
 
-	using ast;
+    using ast;
 
-	if node == nil {
-		return;
-	}
+    if node == nil {
+        return;
+    }
 
-	if node.params != nil {
+    if node.params != nil {
 
-		for param in node.params.list {
+        for param in node.params.list {
 
-			for name in param.names {
+            for name in param.names {
 
-				if ident, ok := name.derived.(Ident); ok {
-					write_semantic_node(builder, name, ast_context.file.src, .Parameter, .None);
-				}
+                if ident, ok := name.derived.(Ident); ok {
+                    write_semantic_node(builder, name, ast_context.file.src, .Parameter, .None);
+                }
 
-			}
+            }
 
-			write_semantic_tokens(param.type, builder, ast_context);
-		}
+            write_semantic_tokens(param.type, builder, ast_context);
+        }
 
-	}
+    }
 
-	if node.results != nil {
+    if node.results != nil {
 
-		for result in node.results.list {
+        for result in node.results.list {
 
 
-			for name in result.names {
+            for name in result.names {
 
-				if ident, ok := name.derived.(Ident); ok {
-					//write_semantic_node(builder, name, ast_context.file.src, .Parameter, .None);
-				}
+                if ident, ok := name.derived.(Ident); ok {
+                    //write_semantic_node(builder, name, ast_context.file.src, .Parameter, .None);
+                }
 
-			}
+            }
 
-			write_semantic_tokens(result.type, builder, ast_context);
+            write_semantic_tokens(result.type, builder, ast_context);
 
-		}
+        }
 
-	}
+    }
 
 }
 
 write_semantic_enum_fields :: proc(node: ast.Enum_Type, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
 
-	using ast;
+    using ast;
 
-	if node.fields == nil {
-		return;
-	}
+    if node.fields == nil {
+        return;
+    }
 
-	for field in node.fields {
+    for field in node.fields {
 
-		if ident, ok := field.derived.(Ident); ok {
-			write_semantic_node(builder, field, ast_context.file.src, .EnumMember, .None);
-		}
+        if ident, ok := field.derived.(Ident); ok {
+            write_semantic_node(builder, field, ast_context.file.src, .EnumMember, .None);
+        }
 
-	}
+    }
 
 }
 
 write_semantic_selector :: proc(selector: ^ast.Selector_Expr, builder: ^SemanticTokenBuilder, ast_context: ^AstContext) {
 
-	using ast;
+    using ast;
 
 
-	if ident, ok := selector.expr.derived.(Ident); ok {
-		resolve_and_write_ident(selector.expr, builder, ast_context); //base
-		resolve_and_write_expr(selector, builder, ast_context); //field
-	}
+    if ident, ok := selector.expr.derived.(Ident); ok {
+        resolve_and_write_ident(selector.expr, builder, ast_context); //base
+        resolve_and_write_expr(selector, builder, ast_context); //field
+    }
 
-	else {
+    else {
 
-	}
+    }
 
 
 
@@ -395,19 +395,19 @@ write_semantic_selector :: proc(selector: ^ast.Selector_Expr, builder: ^Semantic
 
 get_locals_at :: proc(function: ^ast.Node, position: ^ast.Node, ast_context: ^AstContext) {
 
-	clear_locals(ast_context);
+    clear_locals(ast_context);
 
-	if function == nil {
-		return;
-	}
+    if function == nil {
+        return;
+    }
 
-	if position == nil {
-		return;
-	}
+    if position == nil {
+        return;
+    }
 
-	document_position := DocumentPositionContext {
-		position = position.end.offset,
-	};
+    document_position := DocumentPositionContext {
+        position = position.end.offset,
+    };
 
-	get_locals(ast_context.file, function, ast_context, &document_position);
+    get_locals(ast_context.file, function, ast_context, &document_position);
 }
\ No newline at end of file
diff --git a/src/server/types.odin b/src/server/types.odin
index 4d81447..0443cc4 100644
--- a/src/server/types.odin
+++ b/src/server/types.odin
@@ -20,9 +20,9 @@ ResponseParams :: union {
     rawptr,
     common.Location,
     CompletionList,
-	SignatureHelp,
-	[] DocumentSymbol,
-	SemanticTokens,
+    SignatureHelp,
+    [] DocumentSymbol,
+    SemanticTokens,
 };
 
 ResponseMessage :: struct {
@@ -38,8 +38,8 @@ ResponseMessageError :: struct {
 };
 
 ResponseError :: struct {
- 	code: common.Error,
-	message: string,
+     code: common.Error,
+    message: string,
 };
 
 NotificationLoggingParams :: struct {
@@ -48,8 +48,8 @@ NotificationLoggingParams :: struct {
 };
 
 NotificationPublishDiagnosticsParams :: struct {
-	uri: string,
-	diagnostics: [] Diagnostic,
+    uri: string,
+    diagnostics: [] Diagnostic,
 };
 
 NotificationParams :: union {
@@ -83,14 +83,14 @@ ServerCapabilities :: struct {
     textDocumentSync: TextDocumentSyncOptions,
     definitionProvider: bool,
     completionProvider: CompletionOptions,
-	signatureHelpProvider: SignatureHelpOptions,
-	semanticTokensProvider: SemanticTokensOptions,
-	documentSymbolProvider: bool,
+    signatureHelpProvider: SignatureHelpOptions,
+    semanticTokensProvider: SemanticTokensOptions,
+    documentSymbolProvider: bool,
 };
 
 CompletionOptions  :: struct {
     resolveProvider: bool,
-	triggerCharacters: [] string,
+    triggerCharacters: [] string,
 };
 
 HoverClientCapabilities :: struct {
@@ -100,18 +100,18 @@ HoverClientCapabilities :: struct {
 
 DocumentSymbolClientCapabilities :: struct {
 
-	symbolKind: struct {
-		valueSet: [dynamic] SymbolKind,
-	},
+    symbolKind: struct {
+        valueSet: [dynamic] SymbolKind,
+    },
 
-	hierarchicalDocumentSymbolSupport: bool,
+    hierarchicalDocumentSymbolSupport: bool,
 };
 
 TextDocumentClientCapabilities :: struct {
     completion: CompletionClientCapabilities,
     hover: HoverClientCapabilities,
-	signatureHelp: SignatureHelpClientCapabilities,
-	documentSymbol: DocumentSymbolClientCapabilities,
+    signatureHelp: SignatureHelpClientCapabilities,
+    documentSymbol: DocumentSymbolClientCapabilities,
 };
 
 CompletionClientCapabilities :: struct {
@@ -119,22 +119,22 @@ CompletionClientCapabilities :: struct {
 };
 
 ParameterInformationCapabilities :: struct {
-	labelOffsetSupport: bool,
+    labelOffsetSupport: bool,
 };
 
 SignatureInformationCapabilities :: struct {
-	parameterInformation: ParameterInformationCapabilities,
+    parameterInformation: ParameterInformationCapabilities,
 };
 
 SignatureHelpClientCapabilities :: struct {
-	dynamicRegistration: bool,
-	signatureInformation: SignatureInformationCapabilities,
-	contextSupport: bool,
+    dynamicRegistration: bool,
+    signatureInformation: SignatureInformationCapabilities,
+    contextSupport: bool,
 };
 
 SignatureHelpOptions :: struct {
-	triggerCharacters: [] string,
-	retriggerCharacters: [] string,
+    triggerCharacters: [] string,
+    retriggerCharacters: [] string,
 };
 
 ClientCapabilities :: struct {
@@ -142,12 +142,12 @@ ClientCapabilities :: struct {
 };
 
 RangeOptional :: union {
-	common.Range,
+    common.Range,
 };
 
 TextDocumentContentChangeEvent :: struct {
-	range: RangeOptional,
-	text: string,
+    range: RangeOptional,
+    text: string,
 };
 
 Version :: union {
@@ -160,26 +160,26 @@ VersionedTextDocumentIdentifier :: struct  {
 };
 
 TextDocumentIdentifier :: struct {
-	uri: string,
+    uri: string,
 };
 
 TextDocumentItem :: struct {
-	uri: string,
-	text: string,
+    uri: string,
+    text: string,
 };
 
 DiagnosticSeverity :: enum {
     Error = 1,
     Warning = 2,
-	Information = 3,
-	Hint = 4,
+    Information = 3,
+    Hint = 4,
 };
 
 Diagnostic :: struct {
-	range: common.Range,
-	severity: DiagnosticSeverity,
-	code: string,
-	message: string,
+    range: common.Range,
+    severity: DiagnosticSeverity,
+    code: string,
+    message: string,
 };
 
 DidOpenTextDocumentParams :: struct {
@@ -187,12 +187,12 @@ DidOpenTextDocumentParams :: struct {
 };
 
 DocumentSymbolParams :: struct  {
-	textDocument: TextDocumentIdentifier,
+    textDocument: TextDocumentIdentifier,
 };
 
 DidChangeTextDocumentParams :: struct {
-	textDocument: VersionedTextDocumentIdentifier,
-	contentChanges: [dynamic] TextDocumentContentChangeEvent,
+    textDocument: VersionedTextDocumentIdentifier,
+    contentChanges: [dynamic] TextDocumentContentChangeEvent,
 };
 
 DidCloseTextDocumentParams :: struct {
@@ -200,121 +200,121 @@ DidCloseTextDocumentParams :: struct {
 };
 
 TextDocumentPositionParams :: struct {
-	textDocument: TextDocumentIdentifier,
-	position: common.Position,
+    textDocument: TextDocumentIdentifier,
+    position: common.Position,
 };
 
 SignatureHelpParams :: struct {
-	textDocument: TextDocumentIdentifier,
-	position: common.Position,
+    textDocument: TextDocumentIdentifier,
+    position: common.Position,
 };
 
 CompletionParams :: struct {
     textDocument: TextDocumentIdentifier,
-	position: common.Position,
+    position: common.Position,
 };
 
 CompletionItemKind :: enum {
-	Text = 1,
-	Method = 2,
-	Function = 3,
-	Constructor = 4,
-	Field = 5,
-	Variable = 6,
-	Class = 7,
-	Interface = 8,
-	Module = 9,
-	Property = 10,
-	Unit = 11,
-	Value = 12,
-	Enum = 13,
-	Keyword = 14,
-	Snippet = 15,
-	Color = 16,
-	File = 17,
-	Reference = 18,
-	Folder = 19,
-	EnumMember = 20,
-	Constant = 21,
-	Struct = 22,
-	Event = 23,
-	Operator = 24,
-	TypeParameter = 25,
+    Text = 1,
+    Method = 2,
+    Function = 3,
+    Constructor = 4,
+    Field = 5,
+    Variable = 6,
+    Class = 7,
+    Interface = 8,
+    Module = 9,
+    Property = 10,
+    Unit = 11,
+    Value = 12,
+    Enum = 13,
+    Keyword = 14,
+    Snippet = 15,
+    Color = 16,
+    File = 17,
+    Reference = 18,
+    Folder = 19,
+    EnumMember = 20,
+    Constant = 21,
+    Struct = 22,
+    Event = 23,
+    Operator = 24,
+    TypeParameter = 25,
 };
 
 CompletionItem :: struct {
-	label: string,
-	kind: CompletionItemKind,
+    label: string,
+    kind: CompletionItemKind,
 };
 
 CompletionList :: struct {
     isIncomplete: bool,
-	items: [] CompletionItem,
+    items: [] CompletionItem,
 };
 
 TextDocumentSyncOptions :: struct {
-	openClose: bool,
-	change: int,
+    openClose: bool,
+    change: int,
 };
 
 SignatureHelp :: struct {
-	signatures: [] SignatureInformation,
-	activeSignature: int,
-	activeParameter: int,
+    signatures: [] SignatureInformation,
+    activeSignature: int,
+    activeParameter: int,
 };
 
 SignatureInformation :: struct {
-	label: string,
-	parameters: [] ParameterInformation,
+    label: string,
+    parameters: [] ParameterInformation,
 };
 
 ParameterInformation :: struct {
-	label: [2] int,
+    label: [2] int,
 };
 
 OlsConfig :: struct {
-	collections: [dynamic] OlsConfigCollection,
+    collections: [dynamic] OlsConfigCollection,
 };
 
 OlsConfigCollection :: struct {
-	name: string,
-	path: string,
+    name: string,
+    path: string,
 };
 
 SymbolKind :: enum {
-	File = 1,
-	Module = 2,
-	Namespace = 3,
-	Package = 4,
-	Class = 5,
-	Method = 6,
-	Property = 7,
-	Field = 8,
-	Constructor = 9,
-	Enum = 10,
-	Interface = 11,
-	Function = 12,
-	Variable = 13,
-	Constant = 14,
-	String = 15,
-	Number = 16,
-	Boolean = 17,
-	Array = 18,
-	Object = 19,
-	Key = 20,
-	Null = 21,
-	EnumMember = 22,
-	Struct = 23,
-	Event = 24,
-	Operator = 25,
-	TypeParameter = 26,
+    File = 1,
+    Module = 2,
+    Namespace = 3,
+    Package = 4,
+    Class = 5,
+    Method = 6,
+    Property = 7,
+    Field = 8,
+    Constructor = 9,
+    Enum = 10,
+    Interface = 11,
+    Function = 12,
+    Variable = 13,
+    Constant = 14,
+    String = 15,
+    Number = 16,
+    Boolean = 17,
+    Array = 18,
+    Object = 19,
+    Key = 20,
+    Null = 21,
+    EnumMember = 22,
+    Struct = 23,
+    Event = 24,
+    Operator = 25,
+    TypeParameter = 26,
 };
 
 DocumentSymbol :: struct {
-	name: string,
-	//detail?: string,
-	kind: SymbolKind,
-	range: common.Range,
-	selectionRange: common.Range,
-	children: [] DocumentSymbol,
+    name: string,
+    //detail?: string,
+    kind: SymbolKind,
+    range: common.Range,
+    selectionRange: common.Range,
+    children: [] DocumentSymbol,
 };