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>

9 files changed, 1009 insertions, 0 deletions

diff --git a/modules/gdscript/tests/scripts/lsp/class.notest.gd b/modules/gdscript/tests/scripts/lsp/class.notest.gd
new file mode 100644
index 0000000000..53d0b14d72
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/class.notest.gd
@@ -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
diff --git a/modules/gdscript/tests/scripts/lsp/enums.notest.gd b/modules/gdscript/tests/scripts/lsp/enums.notest.gd
new file mode 100644
index 0000000000..38b9ec110a
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/enums.notest.gd
@@ -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
diff --git a/modules/gdscript/tests/scripts/lsp/indentation.notest.gd b/modules/gdscript/tests/scripts/lsp/indentation.notest.gd
new file mode 100644
index 0000000000..c25d73a719
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/indentation.notest.gd
@@ -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
diff --git a/modules/gdscript/tests/scripts/lsp/lambdas.notest.gd b/modules/gdscript/tests/scripts/lsp/lambdas.notest.gd
new file mode 100644
index 0000000000..6f5d468eea
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/lambdas.notest.gd
@@ -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)
diff --git a/modules/gdscript/tests/scripts/lsp/local_variables.notest.gd b/modules/gdscript/tests/scripts/lsp/local_variables.notest.gd
new file mode 100644
index 0000000000..b6cc46f7da
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/local_variables.notest.gd
@@ -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
\ No newline at end of file
diff --git a/modules/gdscript/tests/scripts/lsp/properties.notest.gd b/modules/gdscript/tests/scripts/lsp/properties.notest.gd
new file mode 100644
index 0000000000..8dfaee2e5b
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/properties.notest.gd
@@ -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
diff --git a/modules/gdscript/tests/scripts/lsp/scopes.notest.gd b/modules/gdscript/tests/scripts/lsp/scopes.notest.gd
new file mode 100644
index 0000000000..20b8fb9bd7
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/scopes.notest.gd
@@ -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
diff --git a/modules/gdscript/tests/scripts/lsp/shadowing_initializer.notest.gd b/modules/gdscript/tests/scripts/lsp/shadowing_initializer.notest.gd
new file mode 100644
index 0000000000..338000fa0e
--- /dev/null
+++ b/modules/gdscript/tests/scripts/lsp/shadowing_initializer.notest.gd
@@ -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
diff --git a/modules/gdscript/tests/test_lsp.h b/modules/gdscript/tests/test_lsp.h
new file mode 100644
index 0000000000..e57df00e2d
--- /dev/null
+++ b/modules/gdscript/tests/test_lsp.h
@@ -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