Add completion and hover information for builtin types

1 files changed, 102 insertions, 96 deletions

diff --git a/src/server/documentation.odin b/src/server/documentation.odin
index ac1227f..5615e6c 100644
--- a/src/server/documentation.odin
+++ b/src/server/documentation.odin
@@ -7,103 +7,109 @@ import "core:odin/ast"
 import path "core:path/slashpath"
 import "core:strings"
 
-keywords_docs: map[string]struct{} = {
-	"typeid"        = {},
-	"string"        = {},
-	"cstring"       = {},
-	"int"           = {},
-	"uint"          = {},
-	"u8"            = {},
-	"i8"            = {},
-	"u16"           = {},
-	"i16"           = {},
-	"u32"           = {},
-	"i32"           = {},
-	"u64"           = {},
-	"i64"           = {},
-	"u128"          = {},
-	"i128"          = {},
-	"f16"           = {},
-	"f32"           = {},
-	"f64"           = {},
-	"bool"          = {},
-	"rawptr"        = {},
-	"any"           = {},
-	"b8"            = {},
-	"b16"           = {},
-	"b32"           = {},
-	"b64"           = {},
-	"true"          = {},
-	"false"         = {},
-	"nil"           = {},
-	"byte"          = {},
-	"rune"          = {},
-	"f16be"         = {},
-	"f16le"         = {},
-	"f32be"         = {},
-	"f32le"         = {},
-	"f64be"         = {},
-	"f64le"         = {},
-	"i16be"         = {},
-	"i16le"         = {},
-	"i32be"         = {},
-	"i32le"         = {},
-	"i64be"         = {},
-	"i64le"         = {},
-	"u16be"         = {},
-	"u16le"         = {},
-	"u32be"         = {},
-	"u32le"         = {},
-	"u64be"         = {},
-	"u64le"         = {},
-	"i128be"        = {},
-	"i128le"        = {},
-	"u128be"        = {},
-	"u128le"        = {},
-	"complex32"     = {},
-	"complex64"     = {},
-	"complex128"    = {},
-	"quaternion64"  = {},
-	"quaternion128" = {},
-	"quaternion256" = {},
-	"uintptr"       = {},
+// Docs taken from https://pkg.odin-lang.org/base/builtin
+keywords_docs: map[string]string = {
+	"typeid"        = "```odin\ntypeid :: typeid\n```\n`typeid` is a unique identifier for an Odin type at runtime. It can be mapped to relevant type information through `type_info_of`.",
+	"string"        = "```odin\nstring :: string\n```\n`string` is the set of all strings of 8-bit bytes, conventionally but not necessarily representing UTF-8 encoding text. A `string` may be empty but not `nil`. Elements of `string` type are immutable and indexable.",
+	"cstring"       = "```odin\ncstring :: cstring\n```\n`cstring` is the set of all strings of 8-bit bytes terminated with a NUL (0) byte, conventionally but not necessarily representing UTF-8 encoding text. A `cstring` may be empty or `nil`. Elements of `cstring` type are immutable but not indexable.",
+	"int"           = "```odin\nint :: int\n```\n`int` is a signed integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for say, `i32`.",
+	"uint"          = "```odin\nuint :: uint\n```\n`uint` is an unsigned integer type that is at least 32 bits in size. It is a distinct type, however, and not an alias for say, `u32`.",
+	"u8"            = "```odin\nu8 :: u8\n```\n`u8` is the set of all unsigned 8-bit integers. Range 0 through 255.",
+	"i8"            = "```odin\ni8 :: i8\n```\n`i8` is the set of all signed 8-bit integers. Range -128 through 127.",
+	"u16"           = "```odin\nu16 :: u16\n```\n`u16` is the set of all unsigned 16-bit integers with native endianness. Range 0 through 65535.",
+	"i16"           = "```odin\ni16 :: i16\n```\n`i16` is the set of all signed 16-bit integers with native endianness. Range -32768 through 32767.",
+	"u32"           = "```odin\nu32 :: u32\n```\n`u32` is the set of all unsigned 32-bit integers with native endianness. Range 0 through 4294967295.",
+	"i32"           = "```odin\ni32 :: i32\n```\n`i32` is the set of all signed 32-bit integers with native endianness. Range -2147483648 through 2147483647.",
+	"u64"           = "```odin\nu64 :: u64\n```\n`u64` is the set of all unsigned 64-bit integers with native endianness. Range 0 through 18446744073709551615.",
+	"i64"           = "```odin\ni64 :: i64\n```\n`i64` is the set of all signed 64-bit integers with native endianness. Range -9223372036854775808 through 9223372036854775807.",
+	"u128"          = "```odin\nu128 :: u128\n```\n`u128` is the set of all unsigned 128-bit integers with native endianness. Range 0 through 340282366920938463463374607431768211455.",
+	"i128"          = "```odin\ni128 :: i128\n```\n`i128` is the set of all signed 128-bit integers with native endianness. Range -170141183460469231731687303715884105728 through 170141183460469231731687303715884105727.",
+	"f16"           = "```odin\nf16 :: f16\n```\n`f16` is the set of all IEEE-754 16-bit floating-point numbers with native endianness.",
+	"f32"           = "```odin\nf32 :: f32\n```\n`f32` is the set of all IEEE-754 32-bit floating-point numbers with native endianness.",
+	"f64"           = "```odin\nf64 :: f64\n```\n`f64` is the set of all IEEE-754 64-bit floating-point numbers with native endianness.",
+	"bool"          = "```odin\nbool :: bool  :: bool\n`bool` is ```\n`bool` is the set of boolean values, `false` and `true`. This is distinct to `b8`. `bool` has a size of 1 byte (8 bits).",
+	"any"           = "```odin\nany :: any\n```\n`any` is reference any data type at runtime. Internally it contains a pointer to the underlying data and its relevant `typeid`. This is a very useful construct in order to have a runtime type safe printing procedure.\n\nNote: The `any` value is only valid for as long as the underlying data is still valid. Passing a literal to an `any` will allocate the literal in the current stack frame.\n\nNote: It is highly recommend that you do not use this unless you know what you are doing. Its primary use is for printing procedures.",
+	"b8"            = "```odin\nb8 :: b8\n```\n`b8` is the set of boolean values, `false` and `true`. This is distinct to `bool`. `b8` has a size of 1 byte (8 bits).",
+	"b16"           = "```odin\nb16 :: b16\n```\n`b16` is the set of boolean values, `false` and `true`. `b16` has a size of 2 bytes (16 bits).",
+	"b32"           = "```odin\nb32 :: b32\n```\n`b32` is the set of boolean values, `false` and `true`. `b32` has a size of 4 bytes (32 bits).",
+	"b64"           = "```odin\nb64 :: b64\n```\n`b64` is the set of boolean values, `false` and `true`. `b64` has a size of 8 bytes (64 bits).",
+	"true"          = "```odin\ntrue :: 0 == 0 // untyped boolean\n```",
+	"false"         = "```odin\nfalse :: 0 != 0 // untyped boolean\n```",
+	"nil"           = "```odin\nnil :: ... // untyped nil \n```\n`nil` is a predeclared identifier representing the zero value for a pointer, multi-pointer, enum, bit_set, slice, dynamic array, map, procedure, any, typeid, cstring, union, #soa array, #soa pointer, #relative type.",
+	"byte"          = "```odin\nbyte :: u8\n```\n`byte` is an alias for `u8` and is equivalent to `u8` in all ways. It is used as a convention to distinguish values from 8-bit unsigned integer values.",
+	"rune"          = "```odin\nrune :: rune\n```\n`rune` is the set of all Unicode code points. It is internally the same as i32 but distinct.",
+	"f16be"         = "```odin\nf16be :: f16be\n```\n`f16be` is the set of all IEEE-754 16-bit floating-point numbers with big endianness.",
+	"f16le"         = "```odin\nf16le :: f16le\n```\n`f16le` is the set of all IEEE-754 16-bit floating-point numbers with little endianness.",
+	"f32be"         = "```odin\nf32be :: f32be\n```\n`f32be` is the set of all IEEE-754 32-bit floating-point numbers with big endianness.",
+	"f32le"         = "```odin\nf32le :: f32le\n```\n`f32le` is the set of all IEEE-754 32-bit floating-point numbers with little endianness.",
+	"f64be"         = "```odin\nf64be :: f64be\n```\n`f64be` is the set of all IEEE-754 64-bit floating-point numbers with big endianness.",
+	"f64le"         = "```odin\nf64le :: f64le\n```\n`f64le` is the set of all IEEE-754 64-bit floating-point numbers with little endianness.",
+	"i16be"         = "```odin\ni16be :: i16be\n```\n`i16be` is the set of all signed 16-bit integers with big endianness. Range -32768 through 32767.",
+	"i16le"         = "```odin\ni16le :: i16le\n```\n`i16le` is the set of all signed 16-bit integers with little endianness. Range -32768 through 32767.",
+	"i32be"         = "```odin\ni32be :: i32be\n```\n`i32be` is the set of all signed 32-bit integers with big endianness. Range -2147483648 through 2147483647.",
+	"i32le"         = "```odin\ni32le :: i32le\n```\n`i32le` is the set of all signed 32-bit integers with little endianness. Range -2147483648 through 2147483647.",
+	"i64be"         = "```odin\ni64be :: i64be\n```\n`i64be` is the set of all signed 64-bit integers with big endianness. Range -9223372036854775808 through 9223372036854775807.",
+	"i64le"         = "```odin\ni64le :: i64le\n```\n`i64le` is the set of all signed 64-bit integers with little endianness. Range -9223372036854775808 through 9223372036854775807.",
+	"u16be"         = "```odin\nu16be :: u16be\n```\n`u16be` is the set of all unsigned 16-bit integers with big endianness. Range 0 through 65535.",
+	"u16le"         = "```odin\nu16le :: u16le\n```\n`u16le` is the set of all unsigned 16-bit integers with little endianness. Range 0 through 65535.",
+	"u32be"         = "```odin\nu32be :: u32be\n```\n`u32be` is the set of all unsigned 32-bit integers with big endianness. Range 0 through 4294967295.",
+	"u32le"         = "```odin\nu32le :: u32le\n```\n`u32le` is the set of all unsigned 32-bit integers with little endianness. Range 0 through 4294967295.",
+	"u64be"         = "```odin\nu64be :: u64be\n```\n`u64be` is the set of all unsigned 64-bit integers with big endianness. Range 0 through 18446744073709551615.",
+	"u64le"         = "```odin\nu64le :: u64le\n```\n`u64le` is the set of all unsigned 64-bit integers with little endianness. Range 0 through 18446744073709551615.",
+	"i128be"        = "```odin\ni128be :: i128be\n```\n`i128be` is the set of all signed 128-bit integers with big endianness. Range -170141183460469231731687303715884105728 through 170141183460469231731687303715884105727.",
+	"i128le"        = "```odin\ni128le :: i128le\n```\n`i128le` is the set of all signed 128-bit integers with little endianness. Range -170141183460469231731687303715884105728 through 170141183460469231731687303715884105727.",
+	"u128be"        = "```odin\nu128be :: u128be\n```\n`u128be` is the set of all unsigned 128-bit integers with big endianness. Range 0 through 340282366920938463463374607431768211455.",
+	"u128le"        = "```odin\nu128le :: u128le\n```\n`u128le` is the set of all unsigned 128-bit integers with little endianness. Range 0 through 340282366920938463463374607431768211455.",
+	"complex32"     = "```odin\ncomplex32 :: complex32\n```\n`complex32` is the set of all complex numbers with `f16` real and imaginary parts.",
+	"complex64"     = "```odin\ncomplex64 :: complex64\n```\n`complex64` is the set of all complex numbers with `f32` real and imaginary parts.",
+	"complex128"    = "```odin\ncomplex128 :: complex128\n```\n`complex128` is the set of all complex numbers with `f64` real and imaginary parts.",
+	"quaternion64"  = "```odin\nquaternion64 :: quaternion64\n```\n`quaternion64` is the set of all complex numbers with `f16` real and imaginary (i, j, & k) parts.",
+	"quaternion128" = "```odin\nquaternion128 :: quaternion128\n```\n`quaternion128` is the set of all complex numbers with `f32` real and imaginary (i, j, & k) parts.",
+	"quaternion256" = "```odin\nquaternion256 :: quaternion256\n```\n`quaternion256` is the set of all complex numbers with `f64` real and imaginary (i, j, & k) parts.",
+	"uintptr"       = "```odin\nuintptr :: uintptr\n```\n`uintptr` is an unsigned integer type that is large enough to hold the bit pattern of any pointer.",
+	"rawptr"        = "```odin\nrawptr :: rawptr\n```\n`rawptr` is a pointer to an arbitrary type. It is equivalent to void * in C.",
 	// taken from https://github.com/odin-lang/Odin/wiki/Keywords-and-Operators
-	"asm"           = {},
-	"auto_cast"     = {},
-	"bit_field"     = {},
-	"bit_set"       = {},
-	"break"         = {},
-	"case"          = {},
-	"cast"          = {},
-	"context"       = {},
-	"continue"      = {},
-	"defer"         = {},
-	"distinct"      = {},
-	"do"            = {},
-	"dynamic"       = {},
-	"else"          = {},
-	"enum"          = {},
-	"fallthrough"   = {},
-	"for"           = {},
-	"foreign"       = {},
-	"if"            = {},
-	"import"        = {},
-	"in"            = {},
-	"map"           = {},
-	"not_in"        = {},
-	"or_else"       = {},
-	"or_return"     = {},
-	"package"       = {},
-	"proc"          = {},
-	"return"        = {},
-	"struct"        = {},
-	"switch"        = {},
-	"transmute"     = {},
-	"typeid"        = {},
-	"union"         = {},
-	"using"         = {},
-	"when"          = {},
-	"where"         = {},
+	"asm"           = "",
+	"auto_cast"     = "```odin\nauto_cast v```\nAutomatically casts an expression `v` to the destination’s type if possible.",
+	"bit_field"     = "",
+	"bit_set"       = "",
+	"break"         = "",
+	"case"          = "",
+	"cast"          = "```odin\ncast(T)v\n```\nConverts the value `v` to the type `T`.",
+	"const"         = "",
+	"context"       = "```odin\nruntime.context: Context\n```\nThe context variable is local to each scope. It is copy-on-write and is implicitly passed by pointer to any procedure call in that scope (if the procedure has the Odin calling convention).",
+	"continue"      = "",
+	"defer"         = "",
+	"distinct"      = "```odin\ndistinct T\n```\nCreate a new type with the same underlying semantics as `T`",
+	"do"            = "",
+	"dynamic"       = "",
+	"else"          = "",
+	"enum"          = "",
+	"fallthrough"   = "",
+	"for"           = "",
+	"foreign"       = "",
+	"if"            = "",
+	"import"        = "",
+	"in"            = "",
+	"inline"        = "",
+	"map"           = "",
+	"not_in"        = "",
+	"or_break"      = "",
+	"or_continue"   = "",
+	"or_else"       = "",
+	"or_return"     = "",
+	"opaque"        = "",
+	"package"       = "",
+	"proc"          = "",
+	"return"        = "",
+	"struct"        = "",
+	"switch"        = "",
+	"transmute"     = "```odin\ntransmute(T)v\n```\nBitwise cast between 2 types of the same size.",
+	"typeid"        = "",
+	"union"         = "",
+	"using"         = "",
+	"when"          = "",
+	"where"         = "",
 }
 
 // Adds signature and docs information to the provided symbol