@xano/xanoscript-language-server 11.11.0 → 11.12.1

package/parser/functions/varFn.js

@@ -2,9 +2,14 @@ import { DotToken } from "../../lexer/tokens.js";
 import { UpdateToken, VarToken } from "../../lexer/var.js";
 import {
   ApiBaseUrlVariable,
+  AuthVariable,
   BranchVariable,
   DatasourceVariable,
+  EnvVariable,
+  ErrorVariable,
   HttpHeadersVariable,
+  InputVariable,
+  LongFormVariable,
   RemoteHostVariable,
   RemoteIpVariable,
   RemotePasswordVariable,
@@ -53,16 +58,23 @@ export function varFn($) {
             { ALT: () => $.CONSUME(RequestUriVariable) },
             { ALT: () => $.CONSUME(TenantVariable) },
             { ALT: () => $.CONSUME(WebflowVariable) },
+            // Not recommended but still valid
+            { ALT: () => $.CONSUME(LongFormVariable) },
+            { ALT: () => $.CONSUME(EnvVariable) },
+            { ALT: () => $.CONSUME(AuthVariable) },
+            { ALT: () => $.CONSUME(InputVariable) },
+            { ALT: () => $.CONSUME(ErrorVariable) },
           ]);
+
           if (variable.image) {
             // Check for blacklisted variable names
             const nameWithoutPrefix = variable.image.startsWith("$")
               ? variable.image.slice(1)
               : variable.image;
             if (isBlacklistedVariableName(nameWithoutPrefix)) {
-              $.addInvalidValueError(
-                variable,
+              $.addWarning(
                 `'${variable.image}' is a reserved variable name and should not be used as a variable.`,
+                variable,
               );
             }
             // we can directly add the variable here but

package/parser/functions/varFn.spec.js

@@ -225,16 +225,18 @@ describe("varFn", () => {
         const parser = parse(`var $${name} {
           value = "test"
         }`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
 
       it(`rejects var.update $${name} as variable name (short form)`, () => {
         const parser = parse(`var.update $${name} {
           value = "test"
         }`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -249,30 +251,35 @@ describe("varFn", () => {
     ];
 
     for (const name of separateTokenBlacklisted) {
-      it(`rejects var $${name} as variable name (separate token)`, () => {
+      it(`warns var $${name} as variable name (separate token)`, () => {
         const parser = parse(`var $${name} {
           value = "test"
         }`);
         if (parser.errors.length === 0) {
           console.log(parser.errors, name);
         }
-        expect(parser.errors).to.not.be.empty;
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
 
-      it(`rejects var.update $${name} as variable name (separate token)`, () => {
+      it(`warns var.update $${name} as variable name (separate token)`, () => {
         const parser = parse(`var.update $${name} {
           value = "test"
         }`);
-        expect(parser.errors).to.not.be.empty;
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
     // $var is the LongFormVariable prefix, parser expects a dot after it
-    it("rejects var $var as variable name (long form prefix)", () => {
+    it("warns var $var as variable name (long form prefix)", () => {
       const parser = parse(`var $var {
         value = "test"
       }`);
-      expect(parser.errors).to.not.be.empty;
+      expect(parser.warnings).to.not.be.empty;
+      expect(parser.errors).to.be.empty;
     });
 
     it("accepts a backtick expression as value", () => {
@@ -301,8 +308,9 @@ describe("varFn", () => {
         const parser = parse(`var.update $var.${name} {
           value = "test"
         }`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 

package/parser/generic/asVariable.spec.js

@@ -44,8 +44,9 @@ describe("asVariable", () => {
     for (const name of shortFormBlacklisted) {
       it(`rejects as $${name} (short form)`, () => {
         const parser = parse(`as $${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -62,14 +63,16 @@ describe("asVariable", () => {
     for (const name of separateTokenBlacklisted) {
       it(`rejects as $${name} (separate token)`, () => {
         const parser = parse(`as $${name}`);
-        expect(parser.errors).to.not.be.empty;
+        expect(parser.warnings).to.not.be.empty;
       });
     }
 
     // $var is the LongFormVariable prefix, parser expects a dot after it
+    // FIXME: shoud be a warning, not an error, since it's still a valid variable name (albeit confusing)
     it("rejects as $var (long form prefix)", () => {
       const parser = parse("as $var");
-      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.not.be.empty;
     });
 
     // All blacklisted names should be rejected in long form ($var.name)
@@ -89,25 +92,26 @@ describe("asVariable", () => {
     for (const name of allBlacklisted) {
       it(`rejects as $var.${name} (long form)`, () => {
         const parser = parse(`as $var.${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
     // Ensure valid names still work
     it("accepts as $user", () => {
       const parser = parse("as $user");
-      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.be.empty;
     });
 
     it("accepts as $my_input", () => {
       const parser = parse("as $my_input");
       expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.be.empty;
     });
 
     it("accepts as $var.my_var", () => {
       const parser = parse("as $var.my_var");
-      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.be.empty;
     });
   });
 });

package/parser/generic/assignableVariableAs.js

@@ -1,6 +1,12 @@
-import { MismatchedTokenException } from "chevrotain";
 import { DotToken, Identifier } from "../../lexer/tokens.js";
-import { LongFormVariable, ShortFormVariable } from "../../lexer/variables.js";
+import {
+  AuthVariable,
+  EnvVariable,
+  ErrorVariable,
+  InputVariable,
+  LongFormVariable,
+  ShortFormVariable,
+} from "../../lexer/variables.js";
 import { isBlacklistedVariableName } from "./assignableVariableProperty.js";
 
 /**
@@ -23,10 +29,45 @@ export function assignableVariableAs($) {
       // "$var.users"
       {
         ALT: () => {
-          $.CONSUME(LongFormVariable);
-          $.CONSUME(DotToken);
-          const variable = $.CONSUME(Identifier);
-          variableName = `$${variable.image}`;
+          const variable = $.CONSUME(LongFormVariable);
+          variableName = variable.image;
+          variableToken = variable;
+
+          // Handle optional property access, e.g., "$var.users" because "$var" is a valid
+          // variable name even if it's not recommended and confusing
+          $.OPTION(() => {
+            $.CONSUME(DotToken);
+            const variable = $.CONSUME(Identifier);
+            variableName = `$${variable.image}`;
+            variableToken = variable;
+          });
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(EnvVariable);
+          variableName = variable.image;
+          variableToken = variable;
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(AuthVariable);
+          variableName = variable.image;
+          variableToken = variable;
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(InputVariable);
+          variableName = variable.image;
+          variableToken = variable;
+        },
+      },
+      {
+        ALT: () => {
+          const variable = $.CONSUME(ErrorVariable);
+          variableName = variable.image;
           variableToken = variable;
         },
       },
@@ -38,11 +79,9 @@ export function assignableVariableAs($) {
         ? variableName.slice(1)
         : variableName;
       if (isBlacklistedVariableName(nameWithoutPrefix)) {
-        $.SAVE_ERROR(
-          new MismatchedTokenException(
-            `'${variableName}' is a reserved variable name and cannot be used`,
-            variableToken
-          )
+        $.addWarning(
+          `'${variableToken.image}' is a reserved variable name and should not be used as a variable.`,
+          variableToken,
         );
       }
       $.addVariable(variableName, "unknown", variableToken);

package/parser/generic/assignableVariableAs.spec.js

@@ -25,6 +25,12 @@ describe("assignableVariableAs", () => {
     expect(parser.errors).to.not.be.empty;
   });
 
+  it("assignableVariableAs should warn on $var reserved variable names", () => {
+    const parser = parse("$var");
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+  });
+
   it("assignableVariableAs cannot be a short named variable with sub props", () => {
     const parser = parse("$users.x.y[1].z");
     expect(parser.errors).to.not.be.empty;
@@ -53,13 +59,28 @@ describe("assignableVariableAs", () => {
   // Blacklisted variable names - used in loop contexts (each as $variable)
   describe("blacklisted variable names", () => {
     // These are lexed as ShortFormVariable and need explicit blacklisting
-    const shortFormBlacklisted = ["output", "db", "toolset"];
+    const shortFormBlacklisted = [
+      "output",
+      "db",
+      "toolset",
+      "auth",
+      "input",
+      "env",
+      "response",
+      "output",
+      "var",
+      "db",
+      "error",
+      "toolset",
+      "this",
+    ];
 
     for (const name of shortFormBlacklisted) {
-      it(`rejects $${name} (short form)`, () => {
+      it(`warns on $${name} (short form)`, () => {
         const parser = parse(`$${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -78,10 +99,11 @@ describe("assignableVariableAs", () => {
     ];
 
     for (const name of allBlacklisted) {
-      it(`rejects $var.${name} (long form)`, () => {
+      it(`warns on $var.${name} (long form)`, () => {
         const parser = parse(`$var.${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 

package/parser/generic/assignableVariableProperty.js

@@ -1,11 +1,14 @@
-import { MismatchedTokenException } from "chevrotain";
 import { PipeToken } from "../../lexer/control.js";
 import { DotToken, Identifier, NewlineToken } from "../../lexer/tokens.js";
 import {
   ApiBaseUrlVariable,
+  AuthVariable,
   BranchVariable,
   DatasourceVariable,
+  EnvVariable,
+  ErrorVariable,
   HttpHeadersVariable,
+  InputVariable,
   LongFormVariable,
   RemoteHostVariable,
   RemoteIpVariable,
@@ -78,6 +81,11 @@ export function assignableVariableProperty($) {
               { ALT: () => $.CONSUME(RequestUriVariable) },
               { ALT: () => $.CONSUME(TenantVariable) },
               { ALT: () => $.CONSUME(WebflowVariable) },
+              // Not recommended but still valid
+              { ALT: () => $.CONSUME(EnvVariable) },
+              { ALT: () => $.CONSUME(AuthVariable) },
+              { ALT: () => $.CONSUME(InputVariable) },
+              { ALT: () => $.CONSUME(ErrorVariable) },
             ]);
             variableName = variable.image;
             variableToken = variable;
@@ -86,11 +94,17 @@ export function assignableVariableProperty($) {
         // "$var.users"
         {
           ALT: () => {
-            $.CONSUME(LongFormVariable);
-            $.CONSUME(DotToken);
-            const variable = $.CONSUME(Identifier);
-            variableName = `$${variable.image}`;
+            const variable = $.CONSUME(LongFormVariable);
+            variableName = variable.image;
             variableToken = variable;
+
+            // because we want to allow "$var" we need to optionally consume a dot and an identifier
+            $.OPTION(() => {
+              $.CONSUME(DotToken);
+              const variable = $.CONSUME(Identifier);
+              variableName = `$${variable.image}`;
+              variableToken = variable;
+            });
           },
         },
       ],
@@ -104,11 +118,9 @@ export function assignableVariableProperty($) {
         ? variableName.slice(1)
         : variableName;
       if (isBlacklistedVariableName(nameWithoutPrefix)) {
-        $.SAVE_ERROR(
-          new MismatchedTokenException(
-            `'${variableName}' is a reserved variable name and cannot be used`,
-            variableToken
-          )
+        $.addWarning(
+          `'${variableName}' is a reserved variable name and should not be used`,
+          variableToken,
         );
       }
     }

package/parser/generic/assignableVariableProperty.spec.js

@@ -30,17 +30,21 @@ describe("assignableVariableProperty", () => {
     expect(parser.errors).to.be.empty;
   });
 
-  it("assignableVariableProperty cannot be an env variable", () => {
+  it("assignableVariableProperty should warn on $env variable", () => {
     const parser = parse("$env.my_api_key");
-    expect(parser.errors).to.not.be.empty;
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+    expect(parser.warnings[0].message).to.include("reserved");
   });
 
-  it("assignableVariableProperty cannot be an input variable", () => {
+  it("assignableVariableProperty should warn on $input variable", () => {
     const parser = parse("$input.remote_ip");
-    expect(parser.errors).to.not.be.empty;
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+    expect(parser.warnings[0].message).to.include("reserved");
   });
 
-  it("assignableVariableProperty cannot be a string", () => {
+  it("assignableVariableProperty cannot be an indentifier", () => {
     const parser = parse(`"someting"`);
     expect(parser.errors).to.not.be.empty;
   });
@@ -59,8 +63,9 @@ describe("assignableVariableProperty", () => {
     for (const name of shortFormBlacklisted) {
       it(`rejects $${name} as assignable variable (short form)`, () => {
         const parser = parse(`$${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
@@ -78,14 +83,17 @@ describe("assignableVariableProperty", () => {
     for (const name of separateTokenBlacklisted) {
       it(`rejects $${name} as assignable variable (separate token)`, () => {
         const parser = parse(`$${name}`);
-        expect(parser.errors).to.not.be.empty;
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 
     // $var is the LongFormVariable prefix, parser expects a dot after it
-    it("rejects $var as assignable variable (long form prefix)", () => {
+    it("warns when using $var as assignable variable (long form prefix)", () => {
       const parser = parse("$var");
-      expect(parser.errors).to.not.be.empty;
+      expect(parser.errors).to.be.empty;
+      expect(parser.warnings).to.not.be.empty;
     });
 
     // All blacklisted names should be rejected in long form ($var.name)
@@ -105,8 +113,9 @@ describe("assignableVariableProperty", () => {
     for (const name of allBlacklisted) {
       it(`rejects $var.${name} as assignable variable (long form)`, () => {
         const parser = parse(`$var.${name}`);
-        expect(parser.errors).to.not.be.empty;
-        expect(parser.errors[0].message).to.include("reserved");
+        expect(parser.errors).to.be.empty;
+        expect(parser.warnings).to.not.be.empty;
+        expect(parser.warnings[0].message).to.include("reserved");
       });
     }
 

package/parser/generic/expressionFn.js

@@ -366,8 +366,15 @@ export function simpleExpressionFn($) {
       // Group 1: Literals (fast path - most common, distinct tokens)
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(SingleQuotedStringLiteral) },
-      { ALT: () => $.CONSUME(IntegerLiteral) },
-      { ALT: () => $.CONSUME(FloatLiteral) },
+      {
+        ALT: () => {
+          $.OPTION(() => $.CONSUME(Minus));
+          $.OR1([
+            { ALT: () => $.CONSUME(IntegerLiteral) },
+            { ALT: () => $.CONSUME(FloatLiteral) },
+          ]);
+        },
+      },
       { ALT: () => $.CONSUME(TrueToken) },
       { ALT: () => $.CONSUME(FalseToken) },
       { ALT: () => $.CONSUME(NullToken) },

package/parser/generic/expressionFn.spec.js

@@ -570,6 +570,11 @@ describe("expressionFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("expressionFn accept parenthesis for priority for math", () => {
+    const parser = parse(`(1+2+4)*5-2`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("expressionFn accept math with variable", () => {
     const parser = parse(`2 * $input.a + 2 / $input.b - 2`);
     expect(parser.errors).to.be.empty;

package/parser/generic/filterNames.js

@@ -286,6 +286,15 @@ export const filterNames = [
   "sql_esc",
   "sql_alias",
   "is_uuid",
+  "count_distinct",
+  "median",
+  "to_list",
+  "to_list_asc",
+  "to_list_desc",
+  "to_distinct_list",
+  "to_distinct_list_asc",
+  "to_distinct_list_desc",
+  "lambda",
 ];
 
 // List of input filters allowed for each input type

package/parser/mcp_server_parser.js

@@ -24,10 +24,11 @@ export function mcpServerDeclaration($) {
     // Allow leading comments and newlines before the mcp_server declaration
     $.SUBRULE($.optionalCommentBlockFn);
     const parent = $.CONSUME(McpServerToken); // mcp_server
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "mcp_server");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line

package/parser/mcp_server_trigger_parser.js

@@ -25,10 +25,11 @@ export function mcpServerTriggerDeclaration($) {
     $.SUBRULE($.optionalCommentBlockFn);
 
     const parent = $.CONSUME(McpServerTriggerToken); // mcp_server_trigger
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(StringLiteral) },
       { ALT: () => $.CONSUME(Identifier) },
     ]);
+    $.validateDeclarationName(nameToken, "mcp_server_trigger");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line

package/parser/middleware_parser.js

@@ -28,10 +28,11 @@ export function middlewareDeclaration($) {
     $.SUBRULE($.optionalCommentBlockFn);
 
     const parent = $.CONSUME(MiddlewareToken);
-    $.OR([
+    const nameToken = $.OR([
       { ALT: () => $.CONSUME(Identifier) },
       { ALT: () => $.CONSUME(StringLiteral) },
     ]);
+    $.validateDeclarationName(nameToken, "middleware");
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE(() => $.CONSUME(NewlineToken)); // at least one new line

package/parser/multidoc.js

@@ -6,6 +6,7 @@ import { validateVariables } from "./variableValidator.js";
 
 const SEPARATOR = "\n---\n";
 const SEPARATOR_LENGTH = 5;
+const SEPARATOR_NEWLINES = 2; // number of \n characters in SEPARATOR
 
 /**
  * Find the segment that contains the given global offset.
@@ -38,6 +39,23 @@ export function findSegmentAtOffset(parserResult, offset) {
   return null;
 }
 
+/**
+ * Snapshot a Chevrotain token (or minimal token-like object) into a plain object.
+ * @param {Object|null} token
+ * @returns {Object|null}
+ */
+function snapshotToken(token) {
+  if (!token) return null;
+  return {
+    startOffset: token.startOffset,
+    endOffset: token.endOffset,
+    startLine: token.startLine,
+    startColumn: token.startColumn,
+    image: token.image,
+    tokenTypeName: token.tokenType?.name,
+  };
+}
+
 /**
  * Snapshot parser state into a plain object.
  * Must be called immediately after xanoscriptParser() before parsing next segment,
@@ -49,28 +67,22 @@ function snapshotParser(parser) {
   return {
     errors: parser.errors.map((e) => ({
       message: e.message,
-      token: e.token
-        ? { startOffset: e.token.startOffset, endOffset: e.token.endOffset }
-        : null,
+      token: snapshotToken(e.token),
+      previousToken: snapshotToken(e.previousToken),
     })),
     warnings: parser.warnings.map((w) => ({
       message: w.message,
-      token: w.token
-        ? { startOffset: w.token.startOffset, endOffset: w.token.endOffset }
-        : null,
+      token: snapshotToken(w.token),
     })),
     informations: parser.informations.map((i) => ({
       message: i.message,
-      token: i.token
-        ? { startOffset: i.token.startOffset, endOffset: i.token.endOffset }
-        : null,
+      token: snapshotToken(i.token),
     })),
     hints: parser.hints.map((h) => ({
       message: h.message,
-      token: h.token
-        ? { startOffset: h.token.startOffset, endOffset: h.token.endOffset }
-        : null,
+      token: snapshotToken(h.token),
     })),
+    sectionStack: [...parser.sectionStack],
     __symbolTable: parser.__symbolTable
       ? {
           input: { ...parser.__symbolTable.input },
@@ -94,17 +106,24 @@ function snapshotParser(parser) {
  * Apply a global offset to all position-bearing fields in a parser snapshot.
  * @param {Object} snapshot - The parser state snapshot
  * @param {number} globalOffset - The character offset to add
+ * @param {number} lineOffset - The line number offset to add
  */
-function offsetResult(snapshot, globalOffset) {
+function offsetResult(snapshot, globalOffset, lineOffset) {
   if (globalOffset === 0) return;
 
   const offsetToken = (token) => {
     if (!token) return;
     token.startOffset += globalOffset;
     token.endOffset += globalOffset;
+    if (token.startLine != null) {
+      token.startLine += lineOffset;
+    }
   };
 
-  for (const err of snapshot.errors) offsetToken(err.token);
+  for (const err of snapshot.errors) {
+    offsetToken(err.token);
+    offsetToken(err.previousToken);
+  }
   for (const warn of snapshot.warnings) offsetToken(warn.token);
   for (const info of snapshot.informations) offsetToken(info.token);
   for (const hint of snapshot.hints) offsetToken(hint.token);
@@ -161,6 +180,7 @@ export function multidocParser(text) {
   const segments = text.split(SEPARATOR);
   const results = [];
   let globalOffset = 0;
+  let lineOffset = 0;
 
   for (const segmentText of segments) {
     const parser = xanoscriptParser(segmentText);
@@ -199,8 +219,9 @@ export function multidocParser(text) {
       : null;
     // Deep-copy the snapshot before offsetResult mutates it (needed for hover providers)
     const localSnapshot = JSON.parse(JSON.stringify(snapshot));
-    results.push({ snapshot, localSnapshot, segmentText, segmentSymbolTable, globalOffset });
+    results.push({ snapshot, localSnapshot, segmentText, segmentSymbolTable, globalOffset, lineOffset });
     globalOffset += segmentText.length + SEPARATOR_LENGTH;
+    lineOffset += (segmentText.match(/\n/g) || []).length + SEPARATOR_NEWLINES;
   }
 
   // For now, merge without offsetting (next task)
@@ -221,8 +242,8 @@ export function multidocParser(text) {
     segmentCount: segments.length,
   };
 
-  for (const { snapshot, globalOffset } of results) {
-    offsetResult(snapshot, globalOffset);
+  for (const { snapshot, globalOffset, lineOffset } of results) {
+    offsetResult(snapshot, globalOffset, lineOffset);
     merged.errors.push(...snapshot.errors);
     merged.warnings.push(...snapshot.warnings);
     merged.informations.push(...snapshot.informations);