@xano/xanoscript-language-server 11.12.0 → 11.12.1

package/.claude/memory/feedback_no_git.md

@@ -0,0 +1,11 @@
+---
+name: no-git-interactions
+description: User does not want Claude to interact with git (no commits, no staging, no git commands)
+type: feedback
+---
+
+Do not interact with git — no commits, no staging, no git commands. Focus purely on implementation and testing.
+
+**Why:** User manages their own git workflow.
+
+**How to apply:** Skip all git-related steps in plans. When dispatching subagents, explicitly tell them not to run any git commands. Remove commit steps from task instructions.

package/.claude/settings.local.json

@@ -2,35 +2,20 @@
   "permissions": {
     "allow": [
       "Bash(npm test:*)",
-      "Bash(npm run lint)",
-      "Bash(npm run test:*)",
-      "Bash(npx eslint:*)",
-      "Bash(node:*)",
-      "Bash(npm install)",
+      "Bash(git checkout:*)",
+      "Bash(ls:*)",
+      "Bash(npm run lint:*)",
       "Bash(grep:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --all --pretty=format:\"%h %s\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --all -S \"password\\\\|secret\\\\|api_key\\\\|token\" --oneline)",
-      "Bash(xargs file:*)",
       "Bash(find:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log -p --all -S \"webhook\\\\|Bearer\\\\|discord\\\\|slack\\\\|xano_insiders\" -- \"*.xs\" \"*.js\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server ls-files:*)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server status)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server diff --stat)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log --oneline -5)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server add README.md LICENSE package.json lexer/tests/query/valid_sources/basic_query.xs parser/functions/stream/streamFromRequestFn.js parser/functions/stream/streamFromRequestFn.spec.js parser/tests/function/valid_sources/discord_poll_send_to_slack.xs parser/tests/query/valid_sources/all_basics.xs)",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server commit -m \"$\\(cat <<''EOF''\nPrepare package for public npm release as @xano/xanoscript-language-server\n\n- Rename package to @xano/xanoscript-language-server\n- Add MIT LICENSE file\n- Add npm metadata \\(description, repository, author, license, bugs, homepage\\)\n- Remove private flag to allow publishing\n- Sanitize test files: replace internal URLs, IDs, and env var names with placeholders\n- Simplify README maintainer section\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/justinalbrecht/git/xs-language-server log -1 --oneline)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push)",
-      "Bash(npm whoami:*)",
-      "Bash(npm view:*)",
-      "Bash(npm version:*)",
-      "Bash(npm publish:*)",
-      "Bash(wc:*)",
-      "Bash(git push:*)"
-    ],
-    "deny": [],
-    "ask": []
+      "Read(//tmp/**)",
+      "Bash(git stash:*)",
+      "Bash(do)",
+      "Bash(if ! grep -q \"guidFieldAttribute\" \"$f\")",
+      "Bash(then)",
+      "Bash(echo:*)",
+      "Bash(fi)",
+      "Bash(done)",
+      "Bash(npx eslint:*)"
+    ]
   }
 }

package/lexer/cast.js

@@ -23,14 +23,14 @@ export const BoolCastToken = createUniqToken({
 // !array
 export const ArrayCastToken = createUniqToken({
   name: "ArrayCast",
-  pattern: /!array/,
+  pattern: /!array(?!\.)/,
   label: "!array",
 });
 
 // !text
 export const TextCastToken = createUniqToken({
   name: "TextCast",
-  pattern: /!text/,
+  pattern: /!text(?!\.)/,
   label: "!text",
 });
 
@@ -51,7 +51,7 @@ export const DecimalCastToken = createUniqToken({
 // !object
 export const ObjectCastToken = createUniqToken({
   name: "ObjectCast",
-  pattern: /!object/,
+  pattern: /!object(?!\.)/,
   label: "!object",
 });
 

package/lexer/control.js

@@ -1,5 +1,4 @@
 import { Identifier } from "./identifier.js";
-import { IntegerLiteral } from "./literal.js";
 import { createTokenByName, createUniqToken } from "./utils.js";
 
 // conditional
@@ -173,7 +172,6 @@ export const Minus = createUniqToken({
   name: "Minus",
   pattern: /-/,
   label: "-",
-  longer_alt: IntegerLiteral,
 });
 
 // +

package/lexer/literal.js

@@ -24,13 +24,13 @@ export const SingleQuotedStringLiteral = createUniqToken({
 export const FloatLiteral = createUniqToken({
   name: "FloatLiteral",
   label: "floating point number",
-  pattern: /-?\d+\.\d+([eE][+-]?\d+)?/,
+  pattern: /\d+\.\d+([eE][+-]?\d+)?/,
 });
 
 export const IntegerLiteral = createUniqToken({
   name: "IntegerLiteral",
   label: "integer",
-  pattern: /-?\d+/,
+  pattern: /\d+/,
   longer_alt: FloatLiteral,
 });
 

package/lexer/security.js

@@ -51,13 +51,13 @@ export const CreateSecretKeyToken = createTokenByName("create_secret_key", {
 
 // decrypt
 export const DecryptToken = createTokenByName("decrypt", {
-  llt: Identifier,
+  longer_alt: Identifier,
   categories: [Identifier],
 });
 
 // encrypt
 export const EncryptToken = createTokenByName("encrypt", {
-  llt: Identifier,
+  longer_alt: Identifier,
   categories: [Identifier],
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xano/xanoscript-language-server",
-  "version": "11.12.0",
+  "version": "11.12.1",
   "description": "Language Server Protocol implementation for XanoScript",
   "type": "module",
   "main": "server.js",

package/parser/attributes/columnDefaultValueAttribute.js

@@ -1,4 +1,4 @@
-import { EqualToken } from "../../lexer/control.js";
+import { EqualToken, Minus } from "../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -21,8 +21,15 @@ export function columnDefaultValueAttribute($) {
     $.CONSUME(EqualToken); // "="
     $.OR([
       { ALT: () => $.CONSUME(StringLiteral) }, // e.g., "default value"
-      { ALT: () => $.CONSUME(FloatLiteral) }, // e.g., 42.54
-      { ALT: () => $.CONSUME(IntegerLiteral) }, // e.g., 42
+      {
+        ALT: () => {
+          $.OPTION(() => $.CONSUME(Minus));
+          return $.OR1([
+            { ALT: () => $.CONSUME(IntegerLiteral) },
+            { ALT: () => $.CONSUME(FloatLiteral) },
+          ]);
+        },
+      },
       { ALT: () => $.CONSUME(TrueToken) }, // true
       { ALT: () => $.CONSUME(FalseToken) }, // false
       { ALT: () => $.CONSUME(NowToken) }, // now

package/parser/attributes/inputFilterFn.js

@@ -1,5 +1,5 @@
 import { ExclamationToken } from "../../lexer/cast.js";
-import { ColonToken } from "../../lexer/control.js";
+import { ColonToken, Minus } from "../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -36,8 +36,15 @@ export function inputFilterFn($) {
               { ALT: () => $.CONSUME2(Identifier) },
               { ALT: () => $.CONSUME1(StringLiteral) },
               { ALT: () => $.CONSUME1(RegExpToken) },
-              { ALT: () => $.CONSUME1(IntegerLiteral) },
-              { ALT: () => $.CONSUME1(FloatLiteral) },
+              {
+                ALT: () => {
+                  $.OPTION1(() => $.CONSUME(Minus));
+                  $.OR1([
+                    { ALT: () => $.CONSUME(IntegerLiteral) },
+                    { ALT: () => $.CONSUME(FloatLiteral) },
+                  ]);
+                },
+              },
               { ALT: () => $.CONSUME1(FalseToken) },
               { ALT: () => $.CONSUME1(TrueToken) },
             ]);
@@ -52,7 +59,7 @@ export function inputFilterFn($) {
           ) {
             $.addInvalidValueError(
               filter,
-              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`
+              `Filter '${filter.image}' cannot be applied to input of type '${inputTypeToken.image}'`,
             );
           }
         },

package/parser/clauses/flexibleStringClause.js

@@ -1,7 +1,7 @@
 import { EqualToken } from "../../lexer/control.js";
-import { Identifier } from "../../lexer/identifier.js";
 import { StringLiteral } from "../../lexer/literal.js";
 import { MultiLineStringToken } from "../../lexer/multiline.js";
+import { InstructionsToken } from "../../lexer/tool.js";
 
 /**
  * @param {import('../base_parser.js').XanoBaseParser} $
@@ -14,7 +14,7 @@ export function flexibleStringClause($) {
   return (args) => {
     // During parser initialization, args is undefined
     // Use a placeholder token for grammar recording
-    const token = args?.[0] || Identifier;
+    const token = args?.[0] || InstructionsToken;
     const allowEmpty = args?.[1] ?? true;
 
     $.sectionStack.push(token.name + "Clause");

package/parser/clauses/nakedStackFn.js

@@ -20,46 +20,53 @@ export function nakedStackFn($) {
     $.CONSUME(LCurly); // "{"
     $.MANY(() => {
       $.AT_LEAST_ONE1(() => $.CONSUME1(NewlineToken)); // required new line before each clause
-      $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+      // $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
       $.OR([
         { ALT: () => $.CONSUME(CommentToken) },
-        { ALT: () => $.SUBRULE($.aiFn) },
-        { ALT: () => $.SUBRULE($.dbFn) },
-        { ALT: () => $.SUBRULE($.varFn) },
-        { ALT: () => $.SUBRULE($.arrayFn) },
-        { ALT: () => $.SUBRULE($.cloudFn) },
-        { ALT: () => $.SUBRULE($.securityFn) },
-        { ALT: () => $.SUBRULE($.mathFn) },
-        { ALT: () => $.SUBRULE($.textFn) },
-        { ALT: () => $.SUBRULE($.utilFn) },
-        { ALT: () => $.SUBRULE($.preconditionFn) },
-        { ALT: () => $.SUBRULE($.zipFn) },
-        { ALT: () => $.SUBRULE($.objectFn) },
-        { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
-        { ALT: () => $.SUBRULE($.webflowFn) },
-        { ALT: () => $.SUBRULE($.redisFn) },
-        { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
-        { ALT: () => $.SUBRULE($.debugFn) },
-        { ALT: () => $.SUBRULE($.storageFn) },
-        { ALT: () => $.SUBRULE($.streamFn) },
-        { ALT: () => $.SUBRULE($.actionCallFn) },
         {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.toolCallFn),
+          ALT: () => {
+            $.OPTION(() => $.CONSUME(ExclamationToken)); // optional "!" to continue on error
+            $.OR1([
+              { ALT: () => $.SUBRULE($.aiFn) },
+              { ALT: () => $.SUBRULE($.dbFn) },
+              { ALT: () => $.SUBRULE($.varFn) },
+              { ALT: () => $.SUBRULE($.arrayFn) },
+              { ALT: () => $.SUBRULE($.cloudFn) },
+              { ALT: () => $.SUBRULE($.securityFn) },
+              { ALT: () => $.SUBRULE($.mathFn) },
+              { ALT: () => $.SUBRULE($.textFn) },
+              { ALT: () => $.SUBRULE($.utilFn) },
+              { ALT: () => $.SUBRULE($.preconditionFn) },
+              { ALT: () => $.SUBRULE($.zipFn) },
+              { ALT: () => $.SUBRULE($.objectFn) },
+              { ALT: () => $.SUBRULE($.apiFn, { ARGS: [options] }) },
+              { ALT: () => $.SUBRULE($.webflowFn) },
+              { ALT: () => $.SUBRULE($.redisFn) },
+              { ALT: () => $.SUBRULE($.controlFn, { ARGS: [options] }) },
+              { ALT: () => $.SUBRULE($.debugFn) },
+              { ALT: () => $.SUBRULE($.storageFn) },
+              { ALT: () => $.SUBRULE($.streamFn) },
+              { ALT: () => $.SUBRULE($.actionCallFn) },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.toolCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.addonCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.middlewareCallFn),
+              },
+              {
+                GATE: () => options.allowCallStatements,
+                ALT: () => $.SUBRULE($.triggerCallFn),
+              },
+              { ALT: () => $.SUBRULE($.workflowExpectFn) },
+            ]);
+          },
         },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.addonCallFn),
-        },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.middlewareCallFn),
-        },
-        {
-          GATE: () => options.allowCallStatements,
-          ALT: () => $.SUBRULE($.triggerCallFn),
-        },
-        { ALT: () => $.SUBRULE($.workflowExpectFn) },
       ]);
     });
     $.AT_LEAST_ONE2(() => $.CONSUME2(NewlineToken));

package/parser/clauses/nakedStackFn.spec.js

@@ -31,6 +31,16 @@ describe("nakedStack", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("nakedStack accepts a disabled array statement", () => {
+    const parser = parse(`{
+  !array.push $my_array { 
+    value = 1
+  }
+}`);
+    console.log(parser.errors);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("nakedStack accepts a multiline statement", () => {
     const parser = parse(`{
   var $some_var { 

package/parser/clauses/responseClause.spec.js

@@ -27,6 +27,11 @@ describe("responseClause", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("responseClause accepts a string", () => {
+    const parser = parse(`response = "no exception"`);
+    expect(parser.errors).to.be.empty;
+  });
+
   it("responseClause accepts an object", () => {
     const parser = parse(`response = {result1: $x1, x2: $x2}`);
     expect(parser.errors).to.be.empty;

package/parser/definitions/columnDefinition.js

@@ -115,7 +115,11 @@ export function columnDefinition($) {
 
     // Track table reference from FK column definition
     if (captured.table?.value) {
-      $.addReference("table", getVarName(captured.table.value), captured.table.value);
+      $.addReference(
+        "table",
+        getVarName(captured.table.value),
+        captured.table.value,
+      );
     }
 
     if (inputTypeToken.image == "vector" && !captured.size) {
@@ -126,7 +130,8 @@ export function columnDefinition($) {
     }
 
     const inTable = $.sectionStack.includes("tableDeclaration");
-    if (captured.visibility && !inTable) {
+    const inIntput = $.sectionStack.includes("inputClause");
+    if (captured.visibility && !inTable && !inIntput) {
       $.addInvalidValueError(
         nameToken,
         'The "visibility" attribute is only valid within a table schema definition.',

package/parser/functions/array/arrayNoValueAs.js

@@ -25,7 +25,7 @@ export function arrayNoValueAs($) {
       $.CONSUME(RCurly);
     });
     $.CONSUME(AsToken);
-    $.SUBRULE($.variableOnly);
+    $.SUBRULE($.assignableVariableAs);
     $.sectionStack.pop();
   };
 }

package/parser/functions/array/arrayPopFn.js

@@ -1,8 +1,6 @@
 import { PopToken } from "../../../lexer/arrays.js";
 
-// array.pop {
-//   value = "test"
-// } as test
+// array.pop $var as $unit
 /**
  * @param {import('../../base_parser.js').XanoBaseParser} $
  */

package/parser/functions/controls/forEachFn.spec.js

@@ -19,6 +19,14 @@ describe("forEachFn", () => {
     expect(parser.errors).to.be.empty;
   });
 
+  it("forEachFn should warn when using a reserved variable name", () => {
+    const parser = parse(`foreach ([]|push:1|push:2|push:3|push:4) {
+      each as $env
+    }`);
+    expect(parser.errors).to.be.empty;
+    expect(parser.warnings).to.not.be.empty;
+  });
+
   it("forEachFn can also be foreach.remove", () => {
     const parser = parse(`foreach.remove`);
     expect(parser.errors).to.be.empty;

package/parser/functions/controls/preconditionFn.js

@@ -1,4 +1,5 @@
 import { LParent, RParent } from "../../../lexer/control.js";
+import { NewlineToken } from "../../../lexer/tokens.js";
 import { PreconditionToken } from "../../../lexer/util.js";
 
 /**
@@ -13,7 +14,9 @@ export function preconditionFn($) {
     $.sectionStack.push("preconditionFn");
     const tokenFn = $.CONSUME(PreconditionToken); // "precondition"
     $.CONSUME(LParent);
+    $.MANY(() => $.CONSUME(NewlineToken));
     $.SUBRULE($.expressionFn);
+    $.MANY1(() => $.CONSUME1(NewlineToken));
     $.CONSUME(RParent);
     $.SUBRULE($.schemaParseAttributeFn, {
       ARGS: [

package/parser/functions/db/dbExternalDirectQueryFn.js

@@ -14,6 +14,7 @@ export function dbExternalDirectQueryFn($) {
         {
           sql: "[expression]",
           response_type: ["list", "single"],
+          "parser?": "template_engine",
           connection_string: "[expression]",
           "description?": "[string]",
           "disabled?": "[boolean]",

package/parser/functions/db/dbQueryFn.spec.js

@@ -346,4 +346,35 @@ describe("dbQueryFn", () => {
     const parser = parse(`query user as $user`);
     expect(parser.errors).to.be.empty;
   });
+
+  describe("aggregate eval with aggregator pipes", () => {
+    const aggregators = [
+      "avg",
+      "count",
+      "count_distinct",
+      "max",
+      "median",
+      "min",
+      "sum",
+      "to_distinct_list",
+      "to_distinct_list_asc",
+      "to_distinct_list_desc",
+      "to_list",
+      "to_list_asc",
+      "to_list_desc",
+    ];
+
+    for (const agg of aggregators) {
+      it(`dbQueryFn return eval accepts |${agg} aggregator`, () => {
+        const parser = parse(`query user {
+      return = {
+        type: "aggregate"
+        group: {user_name: $db.user.name}
+        eval: {result: $db.user.name|${agg}}
+      }
+    } as $user`);
+        expect(parser.errors).to.be.empty;
+      });
+    }
+  });
 });

package/parser/functions/schema/schemaParseConstantFn.js

@@ -1,4 +1,5 @@
 import { isArray, some } from "lodash-es";
+import { Minus } from "../../../lexer/control.js";
 import {
   FloatLiteral,
   IntegerLiteral,
@@ -37,18 +38,18 @@ export function schemaParseConstantFn($) {
             return $.CONSUME(SingleQuotedStringLiteral); // e.g., 'field instructions'
           },
         },
+
         {
           ALT: () => {
+            $.OPTION(() => $.CONSUME(Minus));
             attributeCapturedType = "number";
-            return $.CONSUME(IntegerLiteral); // e.g., 42
-          },
-        },
-        {
-          ALT: () => {
-            attributeCapturedType = "number";
-            return $.CONSUME(FloatLiteral); // e.g., 42.54
+            return $.OR1([
+              { ALT: () => $.CONSUME(IntegerLiteral) },
+              { ALT: () => $.CONSUME(FloatLiteral) },
+            ]);
           },
         },
+
         {
           ALT: () => {
             attributeCapturedType = "boolean";
@@ -76,7 +77,7 @@ export function schemaParseConstantFn($) {
       const isMatch = matchValueToSchema(
         attributeCapturedType,
         capturedValue.image,
-        schema
+        schema,
       );
 
       if (!isMatch) {
@@ -92,7 +93,7 @@ function matchValueToSchema(attributeCapturedType, value, schema) {
   // schema can be an array of type/values required
   if (isArray(schema)) {
     return some(schema, (s) =>
-      matchValueToSchema(attributeCapturedType, value, s)
+      matchValueToSchema(attributeCapturedType, value, s),
     );
   }
 
@@ -115,7 +116,7 @@ function matchValueToSchema(attributeCapturedType, value, schema) {
       return schemaValue === null;
     default:
       throw new Error(
-        `schemaParseConstantFn called with non-constant attribute: ${schema}`
+        `schemaParseConstantFn called with non-constant attribute: ${schema}`,
       );
   }
 }

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");
       });
     }