Updated the lsp for proper code completion and added a string_add function to the std. As well as made the lsp find the correct path for the std files

Author: TheDevConnor

src/helper/help.h

@@ -28,7 +28,7 @@
 /** Enable debug logs for arena allocator (comment to disable) */
 #define DEBUG_ARENA_ALLOC 1
 
-#define Luma_Compiler_version "v0.1.3"
+#define Luma_Compiler_version "v0.1.4"
 
 /** Error codes returned by the compiler */
 typedef enum {

src/lsp/lsp.h

@@ -237,6 +237,7 @@ bool lsp_document_analyze(LSPDocument *doc, LSPServer *server,
 // MODULE & IMPORT RESOLUTION
 // ============================================================================
 
+void scan_std_library(LSPServer *server);
 void extract_imports(LSPDocument *doc, ArenaAllocator *arena);
 void resolve_imports(LSPServer *server, LSPDocument *doc, BuildConfig *config,
                      GrowableArray *imported_modules);

src/lsp/lsp_features.c

@@ -51,58 +51,128 @@ LSPCompletionItem *lsp_completion(LSPDocument *doc, LSPPosition position,
   GrowableArray completions;
   growable_array_init(&completions, arena, 32, sizeof(LSPCompletionItem));
 
-  // Add keyword snippets
   const struct {
     const char *label;
     const char *snippet;
     const char *detail;
   } keywords[] = {
-      {"const fn",
-       "const ${1:name} -> fn (${2:params}) ${3:Type} {\\n\\t$0\\n}",
+      // Function declarations
+      {"const fn", "const ${1:name} -> fn (${2:params}) ${3:Type} {\n\t$0\n}",
        "Function declaration"},
       {"pub const fn",
-       "pub const ${1:name} -> fn (${2:params}) ${3:Type} {\\n\\t$0\\n}",
+       "pub const ${1:name} -> fn (${2:params}) ${3:Type} {\n\t$0\n}",
        "Public function"},
 
+      // Generic functions
+      {"const fn<T>",
+       "const ${1:name} = fn<${2:T}>(${3:params}) ${4:Type} {\n\t$0\n}",
+       "Generic function"},
+      {"pub const fn<T>",
+       "pub const ${1:name} = fn<${2:T}>(${3:params}) ${4:Type} {\n\t$0\n}",
+       "Public generic function"},
+
+      // Type declarations
       {"const struct",
-       "const ${1:Name} -> struct {\\n\\t${2:field}: ${3:Type}$0,\\n};",
+       "const ${1:Name} -> struct {\n\t${2:field}: ${3:Type}$0,\n};",
        "Struct definition"},
-      {"const enum", "const ${1:Name} -> enum {\\n\\t${2:Variant}$0,\\n};",
+      {"const struct<T>",
+       "const ${1:Name} -> struct<${2:T}> {\n\t${3:field}: ${4:Type}$0,\n};",
+       "Generic struct"},
+      {"const enum", "const ${1:Name} -> enum {\n\t${2:Variant}$0,\n};",
        "Enum definition"},
       {"const var", "const ${1:name}: ${2:Type} = ${3:value};$0",
        "Top-level constant"},
 
-      {"if", "if ${1:condition} {\\n\\t$0\\n}", "If statement"},
-      {"if else", "if ${1:condition} {\\n\\t${2}\\n} else {\\n\\t$0\\n}",
+      // Control flow - if/elif/else
+      {"if", "if (${1:condition}) {\n\t$0\n}", "If statement"},
+      {"if else", "if (${1:condition}) {\n\t${2}\n} else {\n\t$0\n}",
        "If-else statement"},
+      {"elif", "elif (${1:condition}) {\n\t$0\n}", "Elif clause"},
 
-      {"loop", "loop {\\n\\t$0\\n}", "Infinite loop"},
+      // Loop patterns
+      {"loop", "loop {\n\t$0\n}", "Infinite loop"},
+      {"loop while", "loop (${1:condition}) {\n\t$0\n}", "While-style loop"},
       {"loop for",
-       "loop [${1:i}: int = 0](${1:i} < ${2:10}) : (++${1:i}) {\\n\\t$0\\n}",
+       "loop [${1:i}: int = 0](${1:i} < ${2:10}) : (++${1:i}) {\n\t$0\n}",
        "For-style loop"},
+      {"loop for multi",
+       "loop [${1:i}: int = 0, ${2:j}: int = 0](${1:i} < ${3:10}) : (++${1:i}) "
+       "{\n\t$0\n}",
+       "Multi-variable for loop"},
 
-      {"switch", "switch (${1:value}) {\\n\\t${2:case} => ${3:result};$0\\n}",
+      // Switch patterns
+      {"switch", "switch (${1:value}) {\n\t${2:case} -> ${3:result};$0\n}",
        "Switch statement"},
+      {"switch default",
+       "switch (${1:value}) {\n\t${2:case} -> ${3:result};\n\t_ -> "
+       "${4:default};$0\n}",
+       "Switch with default case"},
 
+      // Variable declaration
       {"let", "let ${1:name}: ${2:Type} = ${3:value};$0",
        "Variable declaration"},
 
-      {"defer", "defer free(${1:ptr});$0", "Defer statement"},
-      {"defer block", "defer {\\n\\t${1:cleanup()};\\n\\t$0\\n}",
-       "Defer block"},
+      // Defer patterns
+      {"defer block", "defer {\n\t${1:cleanup()};$0\n}", "Defer block"},
 
-      {"@module", "@module \\\"${1:name}\\\"$0", "Module declaration"},
-      {"@use", "@use \\\"${1:module}\\\" as ${2:alias}$0", "Import module"},
+      // Module system
+      {"@module", "@module \"${1:name}\"$0", "Module declaration"},
+      {"@use", "@use \"${1:module}\" as ${2:alias}$0", "Import module"},
 
+      // Flow control
       {"return", "return ${1:value};$0", "Return statement"},
       {"break", "break;$0", "Break statement"},
       {"continue", "continue;$0", "Continue statement"},
 
-      {"main", "const main -> fn () int {\\n\\t$0\\n\\treturn 0;\\n};",
+      // Common functions
+      {"main", "const main -> fn () int {\n\t$0\n\treturn 0;\n};",
        "Main function"},
       {"outputln", "outputln(${1:message});$0", "Output with newline"},
+      {"output", "output(${1:message});$0", "Output without newline"},
+
+      // Built-in functions
+      {"input", "input<${1:Type}>(\"${2:prompt}\")$0", "Read typed input"},
+      {"system", "system(\"${1:command}\");$0", "Execute system command"},
+
+      // Type operations
       {"cast", "cast<${1:Type}>(${2:value})$0", "Type cast"},
       {"sizeof", "sizeof<${1:Type}>$0", "Size of type"},
+
+      // Memory operations
+      {"alloc", "cast<${1:*Type}>(alloc(${2:size} * sizeof<${3:Type}>))$0",
+       "Allocate memory"},
+      {"alloc defer",
+       "let ${1:ptr}: ${2:*Type} = cast<${2:*Type}>(alloc(${3:size} * "
+       "sizeof<${4:Type}>));\ndefer free(${1:ptr});$0",
+       "Allocate with defer cleanup"},
+
+      // Struct patterns
+      {"struct method", "${1:name} -> fn (${2:params}) ${3:Type} {\n\t$0\n}",
+       "Struct method"},
+      {"struct pub", "pub:\n\t${1:field}: ${2:Type},$0",
+       "Public struct fields"},
+      {"struct priv", "priv:\n\t${1:field}: ${2:Type},$0",
+       "Private struct fields"},
+
+      // Array patterns
+      {"array", "[${1:Type}; ${2:size}]$0", "Array type"},
+      {"array init", "let ${1:arr}: [${2:Type}; ${3:size}] = [${4:values}];$0",
+       "Array initialization"},
+
+      // Pointer patterns
+      {"pointer", "*${1:Type}$0", "Pointer type"},
+      {"address of", "&${1:variable}$0", "Address-of operator"},
+      {"dereference", "*${1:pointer}$0", "Dereference pointer"},
+
+      // Function attributes
+      {"#returns_ownership",
+       "#returns_ownership\nconst ${1:name} -> fn (${2:params}) ${3:*Type} "
+       "{\n\t$0\n}",
+       "Function returns owned pointer"},
+      {"#takes_ownership",
+       "#takes_ownership\nconst ${1:name} -> fn (${2:ptr}: ${3:*Type}) void "
+       "{\n\t$0\n}",
+       "Function takes ownership"},
   };
 
   for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {

src/lsp/lsp_module.c

@@ -8,6 +8,8 @@
 
 #include "lsp.h"
 
+#define LUMA_STD_PATH "/usr/local/lib/luma/std"
+
 // Extract @module declaration from file content
 const char *extract_module_name(const char *content, ArenaAllocator *arena) {
   if (!content)
@@ -217,15 +219,40 @@ void build_module_registry(LSPServer *server, const char *workspace_uri) {
   arena_destroy(&temp_arena);
 }
 
-// Look up module in registry
 const char *lookup_module(LSPServer *server, const char *module_name) {
+  // First check workspace registry
   for (size_t i = 0; i < server->module_registry.count; i++) {
     if (strcmp(server->module_registry.entries[i].module_name, module_name) ==
         0) {
       return server->module_registry.entries[i].file_uri;
     }
   }
 
+  // If not found, check standard library
+  ArenaAllocator temp_arena;
+  arena_allocator_init(&temp_arena, 4096);
+
+  // Build path to std lib module
+  size_t path_len = strlen(LUMA_STD_PATH) + strlen(module_name) + 10;
+  char *std_path = arena_alloc(&temp_arena, path_len, 1);
+  snprintf(std_path, path_len, "%s/%s.lx", LUMA_STD_PATH, module_name);
+
+  // Check if file exists
+  FILE *test = fopen(std_path, "r");
+  if (test) {
+    fclose(test);
+    const char *uri = lsp_path_to_uri(std_path, server->arena);
+    arena_destroy(&temp_arena);
+
+    fprintf(stderr, "[LSP] Found module '%s' in std lib: %s\n", module_name,
+            uri);
+    return uri;
+  }
+
+  arena_destroy(&temp_arena);
+
+  fprintf(stderr, "[LSP] Module '%s' not found in workspace or std lib\n",
+          module_name);
   return NULL;
 }
 

std/string.lx

@@ -218,3 +218,45 @@ pub const atio -> fn (value: *byte) int {
   }
   return num;
 }
+
+pub const string_add -> fn (num1: *byte, num2: *byte) *byte {
+  let len1: int = strlen(num1);
+  let len2: int = strlen(num2);
+  let max_len: int = 0;
+  if (len1 > len2) max_len = len1; else max_len = len2;
+  
+  // Result can be at most max_len + 1 digits
+  let result: *byte = cast<*byte>(alloc(max_len + 2));
+  let carry: int = 0;
+  let result_idx: int = 0;
+  
+  let i1: int = len1 - 1;
+  let i2: int = len2 - 1;
+  
+  // Add digits from right to left
+  loop (i1 >= 0 || i2 >= 0 || carry > 0) {
+    let digit1: int = 0;
+    let digit2: int = 0;
+
+    if (i1 >= 0) digit1 = (cast<int>(num1[i1]) - 48); else digit1 = 0;
+    if (i2 >= 0) digit2 = (cast<int>(num2[i2]) - 48); else digit2 = 0;
+
+    
+    let sum: int = digit1 + digit2 + carry;
+    carry = sum / 10;
+    result[result_idx++] = cast<byte>((sum % 10) + 48);
+    
+    i1--;
+    i2--;
+  }
+  
+  // Reverse the result
+  loop [i: int = 0](i < result_idx / 2) : (++i) {
+    let temp: byte = result[i];
+    result[i] = result[result_idx - 1 - i];
+    result[result_idx - 1 - i] = temp;
+  }
+  
+  result[result_idx] = '\0';
+  return result;
+}