Language Server: Improve hovered symbol resolution, fix renaming bugs, implement reference lookup
Co-Authored-By: Ryan Brue <56272643+ryanabx@users.noreply.github.com> Co-Authored-By: BooksBaum <15612932+booksbaum@users.noreply.github.com>
This commit is contained in:
BooksBaum
ryanabx
@@ -0,0 +1,132 @@
|
||||
extends Node
|
||||
|
||||
class Inner1 extends Node:
|
||||
# ^^^^^^ class1 -> class1
|
||||
var member1 := 42
|
||||
# ^^^^^^^ class1:member1 -> class1:member1
|
||||
var member2 : int = 13
|
||||
# ^^^^^^^ class1:member2 -> class1:member2
|
||||
var member3 = 1337
|
||||
# ^^^^^^^ class1:member3 -> class1:member3
|
||||
|
||||
signal changed(old, new)
|
||||
# ^^^^^^^ class1:signal -> class1:signal
|
||||
func my_func(arg1: int, arg2: String, arg3):
|
||||
# | | | | | | ^^^^ class1:func:arg3 -> class1:func:arg3
|
||||
# | | | | ^^^^ class1:func:arg2 -> class1:func:arg2
|
||||
# | | ^^^^ class1:func:arg1 -> class1:func:arg1
|
||||
# ^^^^^^^ class1:func -> class1:func
|
||||
print(arg1, arg2, arg3)
|
||||
# | | | | ^^^^ -> class1:func:arg3
|
||||
# | | ^^^^ -> class1:func:arg2
|
||||
# ^^^^ -> class1:func:arg1
|
||||
changed.emit(arg1, arg3)
|
||||
# | | | ^^^^ -> class1:func:arg3
|
||||
# | ^^^^ -> class1:func:arg1
|
||||
#<^^^^^ -> class1:signal
|
||||
return arg1 + arg2.length() + arg3
|
||||
# | | | | ^^^^ -> class1:func:arg3
|
||||
# | | ^^^^ -> class1:func:arg2
|
||||
# ^^^^ -> class1:func:arg1
|
||||
|
||||
class Inner2:
|
||||
# ^^^^^^ class2 -> class2
|
||||
var member1 := 42
|
||||
# ^^^^^^^ class2:member1 -> class2:member1
|
||||
var member2 : int = 13
|
||||
# ^^^^^^^ class2:member2 -> class2:member2
|
||||
var member3 = 1337
|
||||
# ^^^^^^^ class2:member3 -> class2:member3
|
||||
|
||||
signal changed(old, new)
|
||||
# ^^^^^^^ class2:signal -> class2:signal
|
||||
func my_func(arg1: int, arg2: String, arg3):
|
||||
# | | | | | | ^^^^ class2:func:arg3 -> class2:func:arg3
|
||||
# | | | | ^^^^ class2:func:arg2 -> class2:func:arg2
|
||||
# | | ^^^^ class2:func:arg1 -> class2:func:arg1
|
||||
# ^^^^^^^ class2:func -> class2:func
|
||||
print(arg1, arg2, arg3)
|
||||
# | | | | ^^^^ -> class2:func:arg3
|
||||
# | | ^^^^ -> class2:func:arg2
|
||||
# ^^^^ -> class2:func:arg1
|
||||
changed.emit(arg1, arg3)
|
||||
# | | | ^^^^ -> class2:func:arg3
|
||||
# | ^^^^ -> class2:func:arg1
|
||||
#<^^^^^ -> class2:signal
|
||||
return arg1 + arg2.length() + arg3
|
||||
# | | | | ^^^^ -> class2:func:arg3
|
||||
# | | ^^^^ -> class2:func:arg2
|
||||
# ^^^^ -> class2:func:arg1
|
||||
|
||||
class Inner3 extends Inner2:
|
||||
# | | ^^^^^^ -> class2
|
||||
# ^^^^^^ class3 -> class3
|
||||
var whatever = "foo"
|
||||
# ^^^^^^^^ class3:whatever -> class3:whatever
|
||||
|
||||
func _init():
|
||||
# ^^^^^ class3:init
|
||||
# Note: no self-ref check here: resolves to `Object._init`.
|
||||
# usages of `Inner3.new()` DO resolve to this `_init`
|
||||
pass
|
||||
|
||||
class NestedInInner3:
|
||||
# ^^^^^^^^^^^^^^ class3:nested1 -> class3:nested1
|
||||
var some_value := 42
|
||||
# ^^^^^^^^^^ class3:nested1:some_value -> class3:nested1:some_value
|
||||
|
||||
class AnotherNestedInInner3 extends NestedInInner3:
|
||||
#! | | ^^^^^^^^^^^^^^ -> class3:nested1
|
||||
# ^^^^^^^^^^^^^^^^^^^^^ class3:nested2 -> class3:nested2
|
||||
var another_value := 13
|
||||
# ^^^^^^^^^^^^^ class3:nested2:another_value -> class3:nested2:another_value
|
||||
|
||||
func _ready():
|
||||
var inner1 = Inner1.new()
|
||||
# | | ^^^^^^ -> class1
|
||||
# ^^^^^^ func:class1 -> func:class1
|
||||
var value1 = inner1.my_func(1,"",3)
|
||||
# | | | | ^^^^^^^ -> class1:func
|
||||
# | | ^^^^^^ -> func:class1
|
||||
# ^^^^^^ func:class1:value1 -> func:class1:value1
|
||||
var value2 = inner1.member3
|
||||
# | | | | ^^^^^^^ -> class1:member3
|
||||
# | | ^^^^^^ -> func:class1
|
||||
# ^^^^^^ func:class1:value2 -> func:class1:value2
|
||||
print(value1, value2)
|
||||
# | | ^^^^^^ -> func:class1:value2
|
||||
# ^^^^^^ -> func:class1:value1
|
||||
|
||||
var inner3 = Inner3.new()
|
||||
# | | | | ^^^ -> class3:init
|
||||
# | | ^^^^^^ -> class3
|
||||
# ^^^^^^ func:class3 -> func:class3
|
||||
print(inner3)
|
||||
# ^^^^^^ -> func:class3
|
||||
|
||||
var nested1 = Inner3.NestedInInner3.new()
|
||||
# | | | | ^^^^^^^^^^^^^^ -> class3:nested1
|
||||
# | | ^^^^^^ -> class3
|
||||
# ^^^^^^^ func:class3:nested1 -> func:class3:nested1
|
||||
var value_nested1 = nested1.some_value
|
||||
# | | | | ^^^^^^^^^^ -> class3:nested1:some_value
|
||||
# | | ^^^^^^^ -> func:class3:nested1
|
||||
# ^^^^^^^^^^^^^ func:class3:nested1:value
|
||||
print(value_nested1)
|
||||
# ^^^^^^^^^^^^^ -> func:class3:nested1:value
|
||||
|
||||
var nested2 = Inner3.AnotherNestedInInner3.new()
|
||||
# | | | | ^^^^^^^^^^^^^^^^^^^^^ -> class3:nested2
|
||||
# | | ^^^^^^ -> class3
|
||||
# ^^^^^^^ func:class3:nested2 -> func:class3:nested2
|
||||
var value_nested2 = nested2.some_value
|
||||
# | | | | ^^^^^^^^^^ -> class3:nested1:some_value
|
||||
# | | ^^^^^^^ -> func:class3:nested2
|
||||
# ^^^^^^^^^^^^^ func:class3:nested2:value
|
||||
var another_value_nested2 = nested2.another_value
|
||||
# | | | | ^^^^^^^^^^^^^ -> class3:nested2:another_value
|
||||
# | | ^^^^^^^ -> func:class3:nested2
|
||||
# ^^^^^^^^^^^^^^^^^^^^^ func:class3:nested2:another_value_nested
|
||||
print(value_nested2, another_value_nested2)
|
||||
# | | ^^^^^^^^^^^^^^^^^^^^^ -> func:class3:nested2:another_value_nested
|
||||
# ^^^^^^^^^^^^^ -> func:class3:nested2:value
|
||||
@@ -0,0 +1,26 @@
|
||||
extends Node
|
||||
|
||||
enum {UNIT_NEUTRAL, UNIT_ENEMY, UNIT_ALLY}
|
||||
# | | | | ^^^^^^^^^ enum:unnamed:ally -> enum:unnamed:ally
|
||||
# | | ^^^^^^^^^^ enum:unnamed:enemy -> enum:unnamed:enemy
|
||||
# ^^^^^^^^^^^^ enum:unnamed:neutral -> enum:unnamed:neutral
|
||||
enum Named {THING_1, THING_2, ANOTHER_THING = -1}
|
||||
# | | | | | | ^^^^^^^^^^^^^ enum:named:thing3 -> enum:named:thing3
|
||||
# | | | | ^^^^^^^ enum:named:thing2 -> enum:named:thing2
|
||||
# | | ^^^^^^^ enum:named:thing1 -> enum:named:thing1
|
||||
# ^^^^^ enum:named -> enum:named
|
||||
|
||||
func f(arg):
|
||||
match arg:
|
||||
UNIT_ENEMY: print(UNIT_ENEMY)
|
||||
# | ^^^^^^^^^^ -> enum:unnamed:enemy
|
||||
#<^^^^^^^^ -> enum:unnamed:enemy
|
||||
Named.THING_2: print(Named.THING_2)
|
||||
#! | | | | | ^^^^^^^ -> enum:named:thing2
|
||||
# | | | ^^^^^ -> enum:named
|
||||
#! | ^^^^^^^ -> enum:named:thing2
|
||||
#<^^^ -> enum:named
|
||||
_: print(UNIT_ENEMY, Named.ANOTHER_THING)
|
||||
#! | | | | ^^^^^^^^^^^^^ -> enum:named:thing3
|
||||
# | | ^^^^^ -> enum:named
|
||||
# ^^^^^^^^^^ -> enum:unnamed:enemy
|
||||
@@ -0,0 +1,28 @@
|
||||
extends Node
|
||||
|
||||
var root = 0
|
||||
# ^^^^ 0_indent -> 0_indent
|
||||
|
||||
func a():
|
||||
var alpha: int = root + 42
|
||||
# | | ^^^^ -> 0_indent
|
||||
# ^^^^^ 1_indent -> 1_indent
|
||||
if alpha > 42:
|
||||
# ^^^^^ -> 1_indent
|
||||
var beta := alpha + 13
|
||||
# | | ^^^^ -> 1_indent
|
||||
# ^^^^ 2_indent -> 2_indent
|
||||
if beta > alpha:
|
||||
# | | ^^^^^ -> 1_indent
|
||||
# ^^^^ -> 2_indent
|
||||
var gamma = beta + 1
|
||||
# | | ^^^^ -> 2_indent
|
||||
# ^^^^^ 3_indent -> 3_indent
|
||||
print(gamma)
|
||||
# ^^^^^ -> 3_indent
|
||||
print(beta)
|
||||
# ^^^^ -> 2_indent
|
||||
print(alpha)
|
||||
# ^^^^^ -> 1_indent
|
||||
print(root)
|
||||
# ^^^^ -> 0_indent
|
||||
@@ -0,0 +1,91 @@
|
||||
extends Node
|
||||
|
||||
var lambda_member1 := func(alpha: int, beta): return alpha + beta
|
||||
# | | | | | | | | ^^^^ -> \1:beta
|
||||
# | | | | | | ^^^^^ -> \1:alpha
|
||||
# | | | | ^^^^ \1:beta -> \1:beta
|
||||
# | | ^^^^^ \1:alpha -> \1:alpha
|
||||
# ^^^^^^^^^^^^^^ \1 -> \1
|
||||
|
||||
var lambda_member2 := func(alpha, beta: int) -> int:
|
||||
# | | | | | |
|
||||
# | | | | | |
|
||||
# | | | | ^^^^ \2:beta -> \2:beta
|
||||
# | | ^^^^^ \2:alpha -> \2:alpha
|
||||
# ^^^^^^^^^^^^^^ \2 -> \2
|
||||
return alpha + beta
|
||||
# | | ^^^^ -> \2:beta
|
||||
# ^^^^^ -> \2:alpha
|
||||
|
||||
var lambda_member3 := func add_values(alpha, beta): return alpha + beta
|
||||
# | | | | | | | | ^^^^ -> \3:beta
|
||||
# | | | | | | ^^^^^ -> \3:alpha
|
||||
# | | | | ^^^^ \3:beta -> \3:beta
|
||||
# | | ^^^^^ \3:alpha -> \3:alpha
|
||||
# ^^^^^^^^^^^^^^ \3 -> \3
|
||||
|
||||
var lambda_multiline = func(alpha: int, beta: int) -> int:
|
||||
# | | | | | |
|
||||
# | | | | | |
|
||||
# | | | | ^^^^ \multi:beta -> \multi:beta
|
||||
# | | ^^^^^ \multi:alpha -> \multi:alpha
|
||||
# ^^^^^^^^^^^^^^^^ \multi -> \multi
|
||||
print(alpha + beta)
|
||||
# | | ^^^^ -> \multi:beta
|
||||
# ^^^^^ -> \multi:alpha
|
||||
var tmp = alpha + beta + 42
|
||||
# | | | | ^^^^ -> \multi:beta
|
||||
# | | ^^^^^ -> \multi:alpha
|
||||
# ^^^ \multi:tmp -> \multi:tmp
|
||||
print(tmp)
|
||||
# ^^^ -> \multi:tmp
|
||||
if tmp > 50:
|
||||
# ^^^ -> \multi:tmp
|
||||
tmp += alpha
|
||||
# | ^^^^^ -> \multi:alpha
|
||||
#<^ -> \multi:tmp
|
||||
else:
|
||||
tmp -= beta
|
||||
# | ^^^^ -> \multi:beta
|
||||
#<^ -> \multi:tmp
|
||||
print(tmp)
|
||||
# ^^^ -> \multi:tmp
|
||||
return beta + tmp + alpha
|
||||
# | | | | ^^^^^ -> \multi:alpha
|
||||
# | | ^^^ -> \multi:tmp
|
||||
# ^^^^ -> \multi:beta
|
||||
|
||||
|
||||
var some_name := "foo bar"
|
||||
# ^^^^^^^^^ member:some_name -> member:some_name
|
||||
|
||||
func _ready() -> void:
|
||||
var a = lambda_member1.call(1,2)
|
||||
# ^^^^^^^^^^^^^^ -> \1
|
||||
var b = lambda_member2.call(1,2)
|
||||
# ^^^^^^^^^^^^^^ -> \2
|
||||
var c = lambda_member3.call(1,2)
|
||||
# ^^^^^^^^^^^^^^ -> \3
|
||||
var d = lambda_multiline.call(1,2)
|
||||
# ^^^^^^^^^^^^^^^^ -> \multi
|
||||
print(a,b,c,d)
|
||||
|
||||
var lambda_local = func(alpha, beta): return alpha + beta
|
||||
# | | | | | | | | ^^^^ -> \local:beta
|
||||
# | | | | | | ^^^^^ -> \local:alpha
|
||||
# | | | | ^^^^ \local:beta -> \local:beta
|
||||
# | | ^^^^^ \local:alpha -> \local:alpha
|
||||
# ^^^^^^^^^^^^ \local -> \local
|
||||
|
||||
var value := 42
|
||||
# ^^^^^ local:value -> local:value
|
||||
var lambda_capture = func(): return value + some_name.length()
|
||||
# | | | | ^^^^^^^^^ -> member:some_name
|
||||
# | | ^^^^^ -> local:value
|
||||
# ^^^^^^^^^^^^^^ \capture -> \capture
|
||||
|
||||
var z = lambda_local.call(1,2)
|
||||
# ^^^^^^^^^^^^ -> \local
|
||||
var x = lambda_capture.call()
|
||||
# ^^^^^^^^^^^^^^ -> \capture
|
||||
print(z,x)
|
||||
@@ -0,0 +1,25 @@
|
||||
extends Node
|
||||
|
||||
var member := 2
|
||||
# ^^^^^^ member -> member
|
||||
|
||||
func test_member() -> void:
|
||||
var test := member + 42
|
||||
# | | ^^^^^^ -> member
|
||||
# ^^^^ test -> test
|
||||
test += 3
|
||||
#<^^ -> test
|
||||
member += 5
|
||||
#<^^^^ -> member
|
||||
test = return_arg(test)
|
||||
# | ^^^^ -> test
|
||||
#<^^ -> test
|
||||
print(test)
|
||||
# ^^^^ -> test
|
||||
|
||||
func return_arg(arg: int) -> int:
|
||||
# ^^^ arg -> arg
|
||||
arg += 2
|
||||
#<^ -> arg
|
||||
return arg
|
||||
# ^^^ -> arg
|
||||
@@ -0,0 +1,65 @@
|
||||
extends Node
|
||||
|
||||
var prop1 := 42
|
||||
# ^^^^^ prop1 -> prop1
|
||||
var prop2 : int = 42
|
||||
# ^^^^^ prop2 -> prop2
|
||||
var prop3 := 42:
|
||||
# ^^^^^ prop3 -> prop3
|
||||
get:
|
||||
return prop3 + 13
|
||||
# ^^^^^ -> prop3
|
||||
set(value):
|
||||
# ^^^^^ prop3:value -> prop3:value
|
||||
prop3 = value - 13
|
||||
# | ^^^^^ -> prop3:value
|
||||
#<^^^ -> prop3
|
||||
var prop4: int:
|
||||
# ^^^^^ prop4 -> prop4
|
||||
get:
|
||||
return 42
|
||||
var prop5 := 42:
|
||||
# ^^^^^ prop5 -> prop5
|
||||
set(value):
|
||||
# ^^^^^ prop5:value -> prop5:value
|
||||
prop5 = value - 13
|
||||
# | ^^^^^ -> prop5:value
|
||||
#<^^^ -> prop5
|
||||
|
||||
var prop6:
|
||||
# ^^^^^ prop6 -> prop6
|
||||
get = get_prop6,
|
||||
# ^^^^^^^^^ -> get_prop6
|
||||
set = set_prop6
|
||||
# ^^^^^^^^^ -> set_prop6
|
||||
func get_prop6():
|
||||
# ^^^^^^^^^ get_prop6 -> get_prop6
|
||||
return 42
|
||||
func set_prop6(value):
|
||||
# | | ^^^^^ set_prop6:value -> set_prop6:value
|
||||
# ^^^^^^^^^ set_prop6 -> set_prop6
|
||||
print(value)
|
||||
# ^^^^^ -> set_prop6:value
|
||||
|
||||
var prop7:
|
||||
# ^^^^^ prop7 -> prop7
|
||||
get = get_prop7
|
||||
# ^^^^^^^^^ -> get_prop7
|
||||
func get_prop7():
|
||||
# ^^^^^^^^^ get_prop7 -> get_prop7
|
||||
return 42
|
||||
|
||||
var prop8:
|
||||
# ^^^^^ prop8 -> prop8
|
||||
set = set_prop8
|
||||
# ^^^^^^^^^ -> set_prop8
|
||||
func set_prop8(value):
|
||||
# | | ^^^^^ set_prop8:value -> set_prop8:value
|
||||
# ^^^^^^^^^ set_prop8 -> set_prop8
|
||||
print(value)
|
||||
# ^^^^^ -> set_prop8:value
|
||||
|
||||
const const_var := 42
|
||||
# ^^^^^^^^^ const_var -> const_var
|
||||
static var static_var := 42
|
||||
# ^^^^^^^^^^ static_var -> static_var
|
||||
@@ -0,0 +1,106 @@
|
||||
extends Node
|
||||
|
||||
var member := 2
|
||||
# ^^^^^^ public -> public
|
||||
|
||||
signal some_changed(new_value)
|
||||
# | | ^^^^^^^^^ signal:parameter -> signal:parameter
|
||||
# ^^^^^^^^^^^^ signal -> signal
|
||||
var some_value := 42:
|
||||
# ^^^^^^^^^^ property -> property
|
||||
get:
|
||||
return some_value
|
||||
# ^^^^^^^^^^ -> property
|
||||
set(value):
|
||||
# ^^^^^ property:set:value -> property:set:value
|
||||
some_changed.emit(value)
|
||||
# | ^^^^^ -> property:set:value
|
||||
#<^^^^^^^^^^ -> signal
|
||||
some_value = value
|
||||
# | ^^^^^ -> property:set:value
|
||||
#<^^^^^^^^ -> property
|
||||
|
||||
func v():
|
||||
var value := member + 2
|
||||
# | | ^^^^^^ -> public
|
||||
# ^^^^^ v:value -> v:value
|
||||
print(value)
|
||||
# ^^^^^ -> v:value
|
||||
if value > 0:
|
||||
# ^^^^^ -> v:value
|
||||
var beta := value + 2
|
||||
# | | ^^^^^ -> v:value
|
||||
# ^^^^ v:if:beta -> v:if:beta
|
||||
print(beta)
|
||||
# ^^^^ -> v:if:beta
|
||||
|
||||
for counter in beta:
|
||||
# | | ^^^^ -> v:if:beta
|
||||
# ^^^^^^^ v:if:counter -> v:if:counter
|
||||
print (counter)
|
||||
# ^^^^^^^ -> v:if:counter
|
||||
|
||||
else:
|
||||
for counter in value:
|
||||
# | | ^^^^^ -> v:value
|
||||
# ^^^^^^^ v:else:counter -> v:else:counter
|
||||
print(counter)
|
||||
# ^^^^^^^ -> v:else:counter
|
||||
|
||||
func f():
|
||||
var func1 = func(value): print(value + 13)
|
||||
# | | | | ^^^^^ -> f:func1:value
|
||||
# | | ^^^^^ f:func1:value -> f:func1:value
|
||||
# ^^^^^ f:func1 -> f:func1
|
||||
var func2 = func(value): print(value + 42)
|
||||
# | | | | ^^^^^ -> f:func2:value
|
||||
# | | ^^^^^ f:func2:value -> f:func2:value
|
||||
# ^^^^^ f:func2 -> f:func2
|
||||
|
||||
func1.call(1)
|
||||
#<^^^ -> f:func1
|
||||
func2.call(2)
|
||||
#<^^^ -> f:func2
|
||||
|
||||
func m():
|
||||
var value = 42
|
||||
# ^^^^^ m:value -> m:value
|
||||
|
||||
match value:
|
||||
# ^^^^^ -> m:value
|
||||
13:
|
||||
print(value)
|
||||
# ^^^^^ -> m:value
|
||||
[var start, _, var end]:
|
||||
# | | ^^^ m:match:array:end -> m:match:array:end
|
||||
# ^^^^^ m:match:array:start -> m:match:array:start
|
||||
print(start + end)
|
||||
# | | ^^^ -> m:match:array:end
|
||||
# ^^^^^ -> m:match:array:start
|
||||
{ "name": var name }:
|
||||
# ^^^^ m:match:dict:var -> m:match:dict:var
|
||||
print(name)
|
||||
# ^^^^ -> m:match:dict:var
|
||||
var whatever:
|
||||
# ^^^^^^^^ m:match:var -> m:match:var
|
||||
print(whatever)
|
||||
# ^^^^^^^^ -> m:match:var
|
||||
|
||||
func m2():
|
||||
var value = 42
|
||||
# ^^^^^ m2:value -> m2:value
|
||||
|
||||
match value:
|
||||
# ^^^^^ -> m2:value
|
||||
{ "name": var name }:
|
||||
# ^^^^ m2:match:dict:var -> m2:match:dict:var
|
||||
print(name)
|
||||
# ^^^^ -> m2:match:dict:var
|
||||
[var name, ..]:
|
||||
# ^^^^ m2:match:array:var -> m2:match:array:var
|
||||
print(name)
|
||||
# ^^^^ -> m2:match:array:var
|
||||
var name:
|
||||
# ^^^^ m2:match:var -> m2:match:var
|
||||
print(name)
|
||||
# ^^^^ -> m2:match:var
|
||||
@@ -0,0 +1,56 @@
|
||||
extends Node
|
||||
|
||||
var value := 42
|
||||
# ^^^^^ member:value -> member:value
|
||||
|
||||
func variable():
|
||||
var value = value + 42
|
||||
#! | | ^^^^^ -> member:value
|
||||
# ^^^^^ variable:value -> variable:value
|
||||
print(value)
|
||||
# ^^^^^ -> variable:value
|
||||
|
||||
func array():
|
||||
var value = [1,value,3,value+4]
|
||||
#! | | | | ^^^^^ -> member:value
|
||||
#! | | ^^^^^ -> member:value
|
||||
# ^^^^^ array:value -> array:value
|
||||
print(value)
|
||||
# ^^^^^ -> array:value
|
||||
|
||||
func dictionary():
|
||||
var value = {
|
||||
# ^^^^^ dictionary:value -> dictionary:value
|
||||
"key1": value,
|
||||
#! ^^^^^ -> member:value
|
||||
"key2": 1 + value + 3,
|
||||
#! ^^^^^ -> member:value
|
||||
}
|
||||
print(value)
|
||||
# ^^^^^ -> dictionary:value
|
||||
|
||||
func for_loop():
|
||||
for value in value:
|
||||
# | | ^^^^^ -> member:value
|
||||
# ^^^^^ for:value -> for:value
|
||||
print(value)
|
||||
# ^^^^^ -> for:value
|
||||
|
||||
func for_range():
|
||||
for value in range(5, value):
|
||||
# | | ^^^^^ -> member:value
|
||||
# ^^^^^ for:range:value -> for:range:value
|
||||
print(value)
|
||||
# ^^^^^ -> for:range:value
|
||||
|
||||
func matching():
|
||||
match value:
|
||||
# ^^^^^ -> member:value
|
||||
42: print(value)
|
||||
# ^^^^^ -> member:value
|
||||
[var value, ..]: print(value)
|
||||
# | | ^^^^^ -> match:array:value
|
||||
# ^^^^^ match:array:value -> match:array:value
|
||||
var value: print(value)
|
||||
# | | ^^^^^ -> match:var:value
|
||||
# ^^^^^ match:var:value -> match:var:value
|
||||
@@ -0,0 +1,480 @@
|
||||
/**************************************************************************/
|
||||
/* test_lsp.h */
|
||||
/**************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/**************************************************************************/
|
||||
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
||||
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/**************************************************************************/
|
||||
|
||||
#ifndef TEST_LSP_H
|
||||
#define TEST_LSP_H
|
||||
|
||||
#ifdef TOOLS_ENABLED
|
||||
|
||||
#include "tests/test_macros.h"
|
||||
|
||||
#include "../language_server/gdscript_extend_parser.h"
|
||||
#include "../language_server/gdscript_language_protocol.h"
|
||||
#include "../language_server/gdscript_workspace.h"
|
||||
#include "../language_server/godot_lsp.h"
|
||||
|
||||
#include "core/io/dir_access.h"
|
||||
#include "core/io/file_access_pack.h"
|
||||
#include "core/os/os.h"
|
||||
#include "editor/editor_help.h"
|
||||
#include "editor/editor_node.h"
|
||||
#include "modules/gdscript/gdscript_analyzer.h"
|
||||
#include "modules/regex/regex.h"
|
||||
|
||||
#include "thirdparty/doctest/doctest.h"
|
||||
|
||||
template <>
|
||||
struct doctest::StringMaker<lsp::Position> {
|
||||
static doctest::String convert(const lsp::Position &p_val) {
|
||||
return p_val.to_string().utf8().get_data();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct doctest::StringMaker<lsp::Range> {
|
||||
static doctest::String convert(const lsp::Range &p_val) {
|
||||
return p_val.to_string().utf8().get_data();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct doctest::StringMaker<GodotPosition> {
|
||||
static doctest::String convert(const GodotPosition &p_val) {
|
||||
return p_val.to_string().utf8().get_data();
|
||||
}
|
||||
};
|
||||
|
||||
namespace GDScriptTests {
|
||||
|
||||
// LSP GDScript test scripts are located inside project of other GDScript tests:
|
||||
// Cannot reset `ProjectSettings` (singleton) -> Cannot load another workspace and resources in there.
|
||||
// -> Reuse GDScript test project. LSP specific scripts are then placed inside `lsp` folder.
|
||||
// Access via `res://lsp/my_script.notest.gd`.
|
||||
const String root = "modules/gdscript/tests/scripts/";
|
||||
|
||||
/*
|
||||
* After use:
|
||||
* * `memdelete` returned `GDScriptLanguageProtocol`.
|
||||
* * Call `GDScriptTests::::finish_language`.
|
||||
*/
|
||||
GDScriptLanguageProtocol *initialize(const String &p_root) {
|
||||
Error err = OK;
|
||||
Ref<DirAccess> dir(DirAccess::open(p_root, &err));
|
||||
REQUIRE_MESSAGE(err == OK, "Could not open specified root directory");
|
||||
String absolute_root = dir->get_current_dir();
|
||||
init_language(absolute_root);
|
||||
|
||||
GDScriptLanguageProtocol *proto = memnew(GDScriptLanguageProtocol);
|
||||
|
||||
Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace();
|
||||
workspace->root = absolute_root;
|
||||
// On windows: `C:/...` -> `C%3A/...`.
|
||||
workspace->root_uri = "file:///" + absolute_root.lstrip("/").replace_first(":", "%3A");
|
||||
|
||||
return proto;
|
||||
}
|
||||
|
||||
lsp::Position pos(const int p_line, const int p_character) {
|
||||
lsp::Position p;
|
||||
p.line = p_line;
|
||||
p.character = p_character;
|
||||
return p;
|
||||
}
|
||||
|
||||
lsp::Range range(const lsp::Position p_start, const lsp::Position p_end) {
|
||||
lsp::Range r;
|
||||
r.start = p_start;
|
||||
r.end = p_end;
|
||||
return r;
|
||||
}
|
||||
|
||||
lsp::TextDocumentPositionParams pos_in(const lsp::DocumentUri &p_uri, const lsp::Position p_pos) {
|
||||
lsp::TextDocumentPositionParams params;
|
||||
params.textDocument.uri = p_uri;
|
||||
params.position = p_pos;
|
||||
return params;
|
||||
}
|
||||
|
||||
const lsp::DocumentSymbol *test_resolve_symbol_at(const String &p_uri, const lsp::Position p_pos, const String &p_expected_uri, const String &p_expected_name, const lsp::Range &p_expected_range) {
|
||||
Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace();
|
||||
|
||||
lsp::TextDocumentPositionParams params = pos_in(p_uri, p_pos);
|
||||
const lsp::DocumentSymbol *symbol = workspace->resolve_symbol(params);
|
||||
CHECK(symbol);
|
||||
|
||||
if (symbol) {
|
||||
CHECK_EQ(symbol->uri, p_expected_uri);
|
||||
CHECK_EQ(symbol->name, p_expected_name);
|
||||
CHECK_EQ(symbol->selectionRange, p_expected_range);
|
||||
}
|
||||
|
||||
return symbol;
|
||||
}
|
||||
|
||||
struct InlineTestData {
|
||||
lsp::Range range;
|
||||
String text;
|
||||
String name;
|
||||
String ref;
|
||||
|
||||
static bool try_parse(const Vector<String> &p_lines, const int p_line_number, InlineTestData &r_data) {
|
||||
String line = p_lines[p_line_number];
|
||||
|
||||
RegEx regex = RegEx("^\\t*#[ |]*(?<range>(?<left><)?\\^+)(\\s+(?<name>(?!->)\\S+))?(\\s+->\\s+(?<ref>\\S+))?");
|
||||
Ref<RegExMatch> match = regex.search(line);
|
||||
if (match.is_null()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Find first line without leading comment above current line.
|
||||
int target_line = p_line_number;
|
||||
while (target_line >= 0) {
|
||||
String dedented = p_lines[target_line].lstrip("\t");
|
||||
if (!dedented.begins_with("#")) {
|
||||
break;
|
||||
}
|
||||
target_line--;
|
||||
}
|
||||
if (target_line < 0) {
|
||||
return false;
|
||||
}
|
||||
r_data.range.start.line = r_data.range.end.line = target_line;
|
||||
|
||||
String marker = match->get_string("range");
|
||||
int i = line.find(marker);
|
||||
REQUIRE(i >= 0);
|
||||
r_data.range.start.character = i;
|
||||
if (!match->get_string("left").is_empty()) {
|
||||
// Include `#` (comment char) in range.
|
||||
r_data.range.start.character--;
|
||||
}
|
||||
r_data.range.end.character = i + marker.length();
|
||||
|
||||
String target = p_lines[target_line];
|
||||
r_data.text = target.substr(r_data.range.start.character, r_data.range.end.character - r_data.range.start.character);
|
||||
|
||||
r_data.name = match->get_string("name");
|
||||
r_data.ref = match->get_string("ref");
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
Vector<InlineTestData> read_tests(const String &p_path) {
|
||||
Error err;
|
||||
String source = FileAccess::get_file_as_string(p_path, &err);
|
||||
REQUIRE_MESSAGE(err == OK, vformat("Cannot read '%s'", p_path));
|
||||
|
||||
// Format:
|
||||
// ```gdscript
|
||||
// var foo = bar + baz
|
||||
// # | | | | ^^^ name -> ref
|
||||
// # | | ^^^ -> ref
|
||||
// # ^^^ name
|
||||
//
|
||||
// func my_func():
|
||||
// # ^^^^^^^ name
|
||||
// var value = foo + 42
|
||||
// # ^^^^^ name
|
||||
// print(value)
|
||||
// # ^^^^^ -> ref
|
||||
// ```
|
||||
//
|
||||
// * `^`: Range marker.
|
||||
// * `name`: Unique name. Can contain any characters except whitespace chars.
|
||||
// * `ref`: Reference to unique name.
|
||||
//
|
||||
// Notes:
|
||||
// * If range should include first content-char (which is occupied by `#`): use `<` for next marker.
|
||||
// -> Range expands 1 to left (-> includes `#`).
|
||||
// * Note: Means: Range cannot be single char directly marked by `#`, but must be at least two chars (marked with `#<`).
|
||||
// * Comment must start at same ident as line its marked (-> because of tab alignment...).
|
||||
// * Use spaces to align after `#`! -> for correct alignment
|
||||
// * Between `#` and `^` can be spaces or `|` (to better visualize what's marked below).
|
||||
PackedStringArray lines = source.split("\n");
|
||||
|
||||
PackedStringArray names;
|
||||
Vector<InlineTestData> data;
|
||||
for (int i = 0; i < lines.size(); i++) {
|
||||
InlineTestData d;
|
||||
if (InlineTestData::try_parse(lines, i, d)) {
|
||||
if (!d.name.is_empty()) {
|
||||
// Safety check: names must be unique.
|
||||
if (names.find(d.name) != -1) {
|
||||
FAIL(vformat("Duplicated name '%s' in '%s'. Names must be unique!", d.name, p_path));
|
||||
}
|
||||
names.append(d.name);
|
||||
}
|
||||
|
||||
data.append(d);
|
||||
}
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
void test_resolve_symbol(const String &p_uri, const InlineTestData &p_test_data, const Vector<InlineTestData> &p_all_data) {
|
||||
if (p_test_data.ref.is_empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
SUBCASE(vformat("Can resolve symbol '%s' at %s to '%s'", p_test_data.text, p_test_data.range.to_string(), p_test_data.ref).utf8().get_data()) {
|
||||
const InlineTestData *target = nullptr;
|
||||
for (int i = 0; i < p_all_data.size(); i++) {
|
||||
if (p_all_data[i].name == p_test_data.ref) {
|
||||
target = &p_all_data[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
REQUIRE_MESSAGE(target, vformat("No target for ref '%s'", p_test_data.ref));
|
||||
|
||||
Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace();
|
||||
lsp::Position pos = p_test_data.range.start;
|
||||
|
||||
SUBCASE("start of identifier") {
|
||||
pos.character = p_test_data.range.start.character;
|
||||
test_resolve_symbol_at(p_uri, pos, p_uri, target->text, target->range);
|
||||
}
|
||||
|
||||
SUBCASE("inside identifier") {
|
||||
pos.character = (p_test_data.range.end.character + p_test_data.range.start.character) / 2;
|
||||
test_resolve_symbol_at(p_uri, pos, p_uri, target->text, target->range);
|
||||
}
|
||||
|
||||
SUBCASE("end of identifier") {
|
||||
pos.character = p_test_data.range.end.character;
|
||||
test_resolve_symbol_at(p_uri, pos, p_uri, target->text, target->range);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Vector<InlineTestData> filter_ref_towards(const Vector<InlineTestData> &p_data, const String &p_name) {
|
||||
Vector<InlineTestData> res;
|
||||
|
||||
for (const InlineTestData &d : p_data) {
|
||||
if (d.ref == p_name) {
|
||||
res.append(d);
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
void test_resolve_symbols(const String &p_uri, const Vector<InlineTestData> &p_test_data, const Vector<InlineTestData> &p_all_data) {
|
||||
for (const InlineTestData &d : p_test_data) {
|
||||
test_resolve_symbol(p_uri, d, p_all_data);
|
||||
}
|
||||
}
|
||||
|
||||
void assert_no_errors_in(const String &p_path) {
|
||||
Error err;
|
||||
String source = FileAccess::get_file_as_string(p_path, &err);
|
||||
REQUIRE_MESSAGE(err == OK, vformat("Cannot read '%s'", p_path));
|
||||
|
||||
GDScriptParser parser;
|
||||
err = parser.parse(source, p_path, true);
|
||||
REQUIRE_MESSAGE(err == OK, vformat("Errors while parsing '%s'", p_path));
|
||||
|
||||
GDScriptAnalyzer analyzer(&parser);
|
||||
err = analyzer.analyze();
|
||||
REQUIRE_MESSAGE(err == OK, vformat("Errors while analyzing '%s'", p_path));
|
||||
}
|
||||
|
||||
inline lsp::Position lsp_pos(int line, int character) {
|
||||
lsp::Position p;
|
||||
p.line = line;
|
||||
p.character = character;
|
||||
return p;
|
||||
}
|
||||
|
||||
void test_position_roundtrip(lsp::Position p_lsp, GodotPosition p_gd, const PackedStringArray &p_lines) {
|
||||
GodotPosition actual_gd = GodotPosition::from_lsp(p_lsp, p_lines);
|
||||
CHECK_EQ(p_gd, actual_gd);
|
||||
lsp::Position actual_lsp = p_gd.to_lsp(p_lines);
|
||||
CHECK_EQ(p_lsp, actual_lsp);
|
||||
}
|
||||
|
||||
// Note:
|
||||
// * Cursor is BETWEEN chars
|
||||
// * `va|r` -> cursor between `a`&`r`
|
||||
// * `var`
|
||||
// ^
|
||||
// -> Character on `r` -> cursor between `a`&`r`s for tests:
|
||||
// * Line & Char:
|
||||
// * LSP: both 0-based
|
||||
// * Godot: both 1-based
|
||||
TEST_SUITE("[Modules][GDScript][LSP]") {
|
||||
TEST_CASE("Can convert positions to and from Godot") {
|
||||
String code = R"(extends Node
|
||||
|
||||
var member := 42
|
||||
|
||||
func f():
|
||||
var value := 42
|
||||
return value + member)";
|
||||
PackedStringArray lines = code.split("\n");
|
||||
|
||||
SUBCASE("line after end") {
|
||||
lsp::Position lsp = lsp_pos(7, 0);
|
||||
GodotPosition gd(8, 1);
|
||||
test_position_roundtrip(lsp, gd, lines);
|
||||
}
|
||||
SUBCASE("first char in first line") {
|
||||
lsp::Position lsp = lsp_pos(0, 0);
|
||||
GodotPosition gd(1, 1);
|
||||
test_position_roundtrip(lsp, gd, lines);
|
||||
}
|
||||
|
||||
SUBCASE("with tabs") {
|
||||
// On `v` in `value` in `var value := ...`.
|
||||
lsp::Position lsp = lsp_pos(5, 6);
|
||||
GodotPosition gd(6, 13);
|
||||
test_position_roundtrip(lsp, gd, lines);
|
||||
}
|
||||
|
||||
SUBCASE("doesn't fail with column outside of character length") {
|
||||
lsp::Position lsp = lsp_pos(2, 100);
|
||||
GodotPosition::from_lsp(lsp, lines);
|
||||
|
||||
GodotPosition gd(3, 100);
|
||||
gd.to_lsp(lines);
|
||||
}
|
||||
|
||||
SUBCASE("doesn't fail with line outside of line length") {
|
||||
lsp::Position lsp = lsp_pos(200, 100);
|
||||
GodotPosition::from_lsp(lsp, lines);
|
||||
|
||||
GodotPosition gd(300, 100);
|
||||
gd.to_lsp(lines);
|
||||
}
|
||||
|
||||
SUBCASE("special case: negative line for root class") {
|
||||
GodotPosition gd(-1, 0);
|
||||
lsp::Position expected = lsp_pos(0, 0);
|
||||
lsp::Position actual = gd.to_lsp(lines);
|
||||
CHECK_EQ(actual, expected);
|
||||
}
|
||||
SUBCASE("special case: lines.length() + 1 for root class") {
|
||||
GodotPosition gd(lines.size() + 1, 0);
|
||||
lsp::Position expected = lsp_pos(lines.size(), 0);
|
||||
lsp::Position actual = gd.to_lsp(lines);
|
||||
CHECK_EQ(actual, expected);
|
||||
}
|
||||
}
|
||||
TEST_CASE("[workspace][resolve_symbol]") {
|
||||
GDScriptLanguageProtocol *proto = initialize(root);
|
||||
REQUIRE(proto);
|
||||
Ref<GDScriptWorkspace> workspace = GDScriptLanguageProtocol::get_singleton()->get_workspace();
|
||||
|
||||
{
|
||||
String path = "res://lsp/local_variables.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
SUBCASE("Can get correct ranges for public variables") {
|
||||
Vector<InlineTestData> test_data = filter_ref_towards(all_test_data, "member");
|
||||
test_resolve_symbols(uri, test_data, all_test_data);
|
||||
}
|
||||
SUBCASE("Can get correct ranges for local variables") {
|
||||
Vector<InlineTestData> test_data = filter_ref_towards(all_test_data, "test");
|
||||
test_resolve_symbols(uri, test_data, all_test_data);
|
||||
}
|
||||
SUBCASE("Can get correct ranges for local parameters") {
|
||||
Vector<InlineTestData> test_data = filter_ref_towards(all_test_data, "arg");
|
||||
test_resolve_symbols(uri, test_data, all_test_data);
|
||||
}
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for indented variables") {
|
||||
String path = "res://lsp/indentation.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for scopes") {
|
||||
String path = "res://lsp/scopes.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for lambda") {
|
||||
String path = "res://lsp/lambdas.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for inner class") {
|
||||
String path = "res://lsp/class.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for inner class") {
|
||||
String path = "res://lsp/enums.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for shadowing & shadowed variables") {
|
||||
String path = "res://lsp/shadowing_initializer.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
SUBCASE("Can get correct ranges for properties and getter/setter") {
|
||||
String path = "res://lsp/properties.notest.gd";
|
||||
assert_no_errors_in(path);
|
||||
String uri = workspace->get_file_uri(path);
|
||||
Vector<InlineTestData> all_test_data = read_tests(path);
|
||||
test_resolve_symbols(uri, all_test_data, all_test_data);
|
||||
}
|
||||
|
||||
memdelete(proto);
|
||||
finish_language();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace GDScriptTests
|
||||
|
||||
#endif // TOOLS_ENABLED
|
||||
|
||||
#endif // TEST_LSP_H
|
||||
Reference in New Issue
Block a user