Add function argument count validation to language service (#31)

* Add function argument count validation to language service
Added getDiagnostics() method to the language service API that validates
function argument counts and returns LSP diagnostics when functions are
called with too few or too many arguments.om>

Author: Copilot

docs/language-service.md

@@ -12,6 +12,10 @@ The library includes a built-in language service that provides IDE-like features
   - **Variable value previews** - Hovers on variables show a truncated JSON preview of the value
   - **Nested path support** - Hovering over `user.name` resolves and shows the value at that path
 - **Syntax Highlighting** - Token-based highlighting for numbers, strings, keywords, operators, etc.
+- **Diagnostics** - Error detection for function argument count validation
+  - **Too few arguments** - Reports when a function is called with fewer arguments than required (e.g., `pow(2)` needs 2 arguments)
+  - **Too many arguments** - Reports when a function is called with more arguments than allowed (e.g., `random(1, 2, 3)` accepts at most 1)
+  - **Variadic functions** - Correctly handles functions that accept unlimited arguments (e.g., `min`, `max`, `coalesce`)
 
 ## Basic Usage
 
@@ -39,6 +43,9 @@ const hover = ls.getHover({
 
 // Get syntax highlighting tokens
 const tokens = ls.getHighlighting(doc);
+
+// Get diagnostics (function argument count errors)
+const diagnostics = ls.getDiagnostics({ textDocument: doc });
 ```
 
 ## Monaco Editor Integration Sample
@@ -56,13 +63,15 @@ Then open http://localhost:8080 in your browser. The sample demonstrates:
 - Hover documentation for functions and variables
 - Live syntax highlighting
 - Real-time expression evaluation
+- **Diagnostics** - Red squiggly underlines for function argument count errors (select the "Diagnostics Demo" example to see this in action)
 
 The sample code is located in `samples/language-service-sample/` and shows how to:
 
 1. Register a custom language with Monaco
 2. Connect the language service to Monaco's completion and hover providers
 3. Apply syntax highlighting using decorations
 4. Create an LSP-compatible text document wrapper for Monaco models
+5. Display diagnostics using Monaco's `setModelMarkers` API
 
 ## Advanced Features
 
@@ -318,6 +327,54 @@ tokens.forEach(token => {
 });
 ```
 
+### ls.getDiagnostics(params)
+
+Returns a list of diagnostics for the given text document. Currently validates function argument counts.
+
+**Parameters:**
+- `params`: `GetDiagnosticsParams`
+  - `textDocument`: `TextDocument` - The text document to analyze
+
+**Returns:** `Diagnostic[]` - Array of LSP-compatible diagnostic objects
+
+**Diagnostic Properties:**
+- `range`: `Range` - The range of the problematic function call
+- `severity`: `DiagnosticSeverity` - The severity level (Error)
+- `message`: `string` - Human-readable description of the issue
+- `source`: `string` - Always `'expr-eval'`
+
+**Example:**
+```js
+const diagnostics = ls.getDiagnostics({ textDocument: doc });
+diagnostics.forEach(d => {
+  console.log(`${d.message} at line ${d.range.start.line}`);
+});
+
+// For expression "pow(2) + random(1, 2, 3)":
+// "Function 'pow' expects at least 2 arguments, but got 1." at line 0
+// "Function 'random' expects at most 1 argument, but got 3." at line 0
+```
+
+**Monaco Editor Integration:**
+```js
+function applyDiagnostics() {
+    const doc = makeTextDocument(model);
+    const diagnostics = ls.getDiagnostics({ textDocument: doc });
+
+    const markers = diagnostics.map(d => ({
+        severity: monaco.MarkerSeverity.Error,
+        message: d.message,
+        startLineNumber: d.range.start.line + 1,
+        startColumn: d.range.start.character + 1,
+        endLineNumber: d.range.end.line + 1,
+        endColumn: d.range.end.character + 1,
+        source: d.source
+    }));
+
+    monaco.editor.setModelMarkers(model, 'expr-eval', markers);
+}
+```
+
 ## TypeScript Types
 
 The library exports the following TypeScript types for use in your applications:
@@ -330,17 +387,21 @@ import type {
   HoverV2,
   GetCompletionsParams,
   GetHoverParams,
+  GetDiagnosticsParams,
   HighlightToken,
-  LanguageServiceOptions
+  LanguageServiceOptions,
+  ArityInfo
 } from '@pro-fa/expr-eval';
 ```
 
-- **`LanguageServiceApi`** - The main language service interface with `getCompletions`, `getHover`, and `getHighlighting` methods
+- **`LanguageServiceApi`** - The main language service interface with `getCompletions`, `getHover`, `getHighlighting`, and `getDiagnostics` methods
 - **`HoverV2`** - Extended Hover type with guaranteed `MarkupContent` for contents (not deprecated string/array formats)
 - **`GetCompletionsParams`** - Parameters for `getCompletions`: `textDocument`, `position`, and optional `variables`
 - **`GetHoverParams`** - Parameters for `getHover`: `textDocument`, `position`, and optional `variables`
+- **`GetDiagnosticsParams`** - Parameters for `getDiagnostics`: `textDocument`
 - **`HighlightToken`** - Syntax highlighting token with `type`, `start`, `end`, and optional `value`
 - **`LanguageServiceOptions`** - Configuration options for creating a language service, including optional `operators` map
+- **`ArityInfo`** - Describes a function's expected argument count with `min` and optional `max` (undefined for variadic functions)
 
 ### LSP Types
 
@@ -354,7 +415,9 @@ import type {
   CompletionItemKind,
   MarkupContent,
   MarkupKind,
-  InsertTextFormat
+  InsertTextFormat,
+  Diagnostic,
+  DiagnosticSeverity
 } from 'vscode-languageserver-types';
 
 import type { TextDocument } from 'vscode-languageserver-textdocument';

index.ts

@@ -43,8 +43,10 @@ export type {
   HoverV2,
   GetCompletionsParams,
   GetHoverParams,
+  GetDiagnosticsParams,
   HighlightToken,
-  LanguageServiceOptions
+  LanguageServiceOptions,
+  ArityInfo
 } from './src/language-service/index.js';
 
 export { createLanguageService, Expression, Parser };

samples/language-service-sample/app.js

@@ -417,6 +417,30 @@ require(['vs/editor/editor.main'], function () {
         highlightDecorations = expressionEditor.deltaDecorations(highlightDecorations, decorations);
     }
 
+    // Diagnostics - show function argument count errors
+    function applyDiagnostics() {
+        const doc = makeTextDocument(expressionModel);
+        const diagnostics = ls.getDiagnostics({ textDocument: doc });
+
+        // Convert LSP diagnostics to Monaco markers
+        const markers = diagnostics.map(d => {
+            const startPos = fromLspPosition(d.range.start);
+            const endPos = fromLspPosition(d.range.end);
+            return {
+                severity: monaco.MarkerSeverity.Error,
+                message: d.message,
+                startLineNumber: startPos.lineNumber,
+                startColumn: startPos.column,
+                endLineNumber: endPos.lineNumber,
+                endColumn: endPos.column,
+                source: d.source || 'expr-eval'
+            };
+        });
+
+        // Set markers on the model
+        monaco.editor.setModelMarkers(expressionModel, 'expr-eval', markers);
+    }
+
     // Syntax highlight JSON
     function syntaxHighlightJson(json) {
         if (typeof json !== 'string') {
@@ -599,6 +623,7 @@ require(['vs/editor/editor.main'], function () {
     // Event listeners for changes
     expressionModel.onDidChangeContent(() => {
         applyHighlighting();
+        applyDiagnostics();
         evaluate();
     });
 

samples/language-service-sample/examples.js

@@ -93,5 +93,15 @@ const exampleCases = [
                 {"rowId": 3, "state": "unchanged", "data": { "InventoryId": 9362, "Description": "Wood", "Weight": { "Unit": "kg", "Amount": 18 } }}
             ]
         }
+    },
+    {
+        id: 'diagnostics-demo',
+        title: 'Diagnostics Demo',
+        description: 'Shows error highlighting for incorrect function arguments',
+        expression: '// Try functions with wrong argument counts:\n// pow() needs 2 args, random() needs 0-1 args\npow(2) + random(1, 2, 3)',
+        context: {
+            x: 5,
+            y: 10
+        }
     }
 ];