@mojir/lits 2.0.8 → 2.0.10

package/dist/testFramework.js

@@ -3126,7 +3126,7 @@ var mathNormalExpression = {
     },
 };
 
-var version = "2.0.8";
+var version = "2.0.10";
 
 var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
 var xyRegexp = /[xy]/g;
@@ -4341,6 +4341,7 @@ var andSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4368,42 +4369,30 @@ var andSpecialExpression = {
     },
 };
 
-var commentSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseToken = _a.parseToken;
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'comment',
-            p: [],
-            token: undefined,
-        };
-        var tkn = asToken(tokenStream.tokens[parseState.position]);
-        while (!isRParenToken(tkn)) {
-            node.p.push(parseToken(tokenStream, parseState));
-            tkn = asToken(tokenStream.tokens[parseState.position]);
-        }
-        parseState.position += 1;
-        node.token = getTokenDebugData(firstToken) && firstToken;
-        return node;
-    },
-    evaluate: function () { return null; },
-    findUnresolvedIdentifiers: function () { return new Set(); },
-};
-
-var condSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
+function getCommonParser(name) {
+    return function (tokenStream, parseState, firstToken, _a) {
         var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
         var params = parseTokensUntilClosingBracket(tokenStream, parseState);
         assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
+        return {
             t: AstNodeType.SpecialExpression,
-            n: 'cond',
+            n: name,
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertEvenNumberOfParams(node);
-        return node;
-    },
+    };
+}
+
+var commentSpecialExpression = {
+    parse: getCommonParser('comment'),
+    validateParameterCount: function () { return undefined; },
+    evaluate: function () { return null; },
+    findUnresolvedIdentifiers: function () { return new Set(); },
+};
+
+var condSpecialExpression = {
+    parse: getCommonParser('cond'),
+    validateParameterCount: function (node) { return assertEvenNumberOfParams(node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4432,19 +4421,8 @@ var condSpecialExpression = {
 };
 
 var declaredSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'declared?',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams(1, node);
-        return node;
-    },
+    parse: getCommonParser('declared?'),
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack) {
         var lookUpResult = contextStack.lookUp(node.p[0]);
         return lookUpResult !== null;
@@ -4489,9 +4467,9 @@ var defSpecialExpression = {
             token: getTokenDebugData(firstToken) && firstToken,
         };
         assertSymbolNode(node.p[0], (_b = getTokenDebugData(node.token)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
-        assertNumberOfParams(2, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4527,9 +4505,9 @@ var defsSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(2, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(2, node); },
     evaluate: function (node, contextStack, _a) {
         var _b, _c;
         var evaluateAstNode = _a.evaluateAstNode, builtin = _a.builtin;
@@ -4557,23 +4535,8 @@ var defsSpecialExpression = {
 };
 
 var doSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseToken = _a.parseToken;
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'do',
-            p: [],
-            token: undefined,
-        };
-        var tkn = asToken(tokenStream.tokens[parseState.position]);
-        while (!isRParenToken(tkn)) {
-            node.p.push(parseToken(tokenStream, parseState));
-            tkn = asToken(tokenStream.tokens[parseState.position]);
-        }
-        parseState.position += 1;
-        node.token = getTokenDebugData(firstToken) && firstToken;
-        return node;
-    },
+    parse: getCommonParser('do'),
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -4650,6 +4613,7 @@ var defnSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4691,6 +4655,7 @@ var defnsSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c, _d;
@@ -4734,6 +4699,7 @@ var fnSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -4965,19 +4931,8 @@ function parseFunctionArguments(tokenStream, parseState, parsers) {
 }
 
 var ifSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'if',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 2, max: 3 }, node);
-        return node;
-    },
+    parse: getCommonParser('if'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5016,9 +4971,9 @@ var ifLetSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams({ min: 1, max: 2 }, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5048,19 +5003,8 @@ var ifLetSpecialExpression = {
 };
 
 var ifNotSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'if-not',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 2, max: 3 }, node);
-        return node;
-    },
+    parse: getCommonParser('if-not'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 2, max: 3 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5097,6 +5041,7 @@ var letSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b, e_2, _c;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5168,6 +5113,7 @@ var loopSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5431,9 +5377,9 @@ var forSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(1, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, helpers) { return evaluateLoop(true, node, contextStack, helpers.evaluateAstNode); },
     findUnresolvedIdentifiers: function (node, contextStack, _a) {
         var findUnresolvedIdentifiers = _a.findUnresolvedIdentifiers, builtin = _a.builtin;
@@ -5453,9 +5399,9 @@ var doseqSpecialExpression = {
             p: params,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(1, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, helpers) {
         evaluateLoop(false, node, contextStack, helpers.evaluateAstNode);
         return null;
@@ -5467,18 +5413,8 @@ var doseqSpecialExpression = {
 };
 
 var orSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'or',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        return node;
-    },
+    parse: getCommonParser('or'),
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5507,19 +5443,8 @@ var orSpecialExpression = {
 };
 
 var qqSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: '??',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 1, max: 2 }, node);
-        return node;
-    },
+    parse: getCommonParser('??'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1, max: 2 }, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5551,6 +5476,7 @@ var recurSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var evaluateAstNode = _a.evaluateAstNode;
         var params = node.p.map(function (paramNode) { return evaluateAstNode(paramNode, contextStack); });
@@ -5563,19 +5489,8 @@ var recurSpecialExpression = {
 };
 
 var throwSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'throw',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams(1, node);
-        return node;
-    },
+    parse: getCommonParser('throw'),
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var _b, _c;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5591,19 +5506,8 @@ var throwSpecialExpression = {
 };
 
 var timeSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'time!',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams(1, node);
-        return node;
-    },
+    parse: getCommonParser('time!'),
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var evaluateAstNode = _a.evaluateAstNode;
         var param = node.p[0];
@@ -5644,9 +5548,9 @@ var trySpecialExpression = {
             e: error,
             token: getTokenDebugData(firstToken) && firstToken,
         };
-        assertNumberOfParams(1, node);
         return node;
     },
+    validateParameterCount: function (node) { return assertNumberOfParams(1, node); },
     evaluate: function (node, contextStack, _a) {
         var _b;
         var _c;
@@ -5676,19 +5580,8 @@ var trySpecialExpression = {
 };
 
 var whenSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 1 }, node);
-        return node;
-    },
+    parse: getCommonParser('when'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var _c;
@@ -5738,6 +5631,7 @@ var whenFirstSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var _c;
@@ -5799,6 +5693,7 @@ var whenLetSpecialExpression = {
         };
         return node;
     },
+    validateParameterCount: function () { return undefined; },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var evaluateAstNode = _a.evaluateAstNode;
@@ -5837,19 +5732,8 @@ var whenLetSpecialExpression = {
 };
 
 var whenNotSpecialExpression = {
-    parse: function (tokenStream, parseState, firstToken, _a) {
-        var parseTokensUntilClosingBracket = _a.parseTokensUntilClosingBracket;
-        var params = parseTokensUntilClosingBracket(tokenStream, parseState);
-        assertRParenToken(tokenStream.tokens[parseState.position++]);
-        var node = {
-            t: AstNodeType.SpecialExpression,
-            n: 'when-not',
-            p: params,
-            token: getTokenDebugData(firstToken) && firstToken,
-        };
-        assertNumberOfParams({ min: 1 }, node);
-        return node;
-    },
+    parse: getCommonParser('when-not'),
+    validateParameterCount: function (node) { return assertNumberOfParams({ min: 1 }, node); },
     evaluate: function (node, contextStack, _a) {
         var e_1, _b;
         var _c;
@@ -7077,6 +6961,7 @@ function parseString(tokenStream, parseState) {
 }
 
 var exponentiationPrecedence = 9;
+var placeholderRegexp$1 = /^\$([1-9]\d?)?$/;
 function getPrecedence(operator) {
     var operatorSign = operator[1];
     switch (operatorSign) {
@@ -7309,7 +7194,7 @@ var AlgebraicParser = /** @class */ (function () {
         // Parentheses
         if (isLParenToken(token)) {
             var positionBefore = this.parseState.position;
-            var lamdaFunction = this.parseLamdaFunction();
+            var lamdaFunction = this.parseLambdaFunction();
             if (lamdaFunction) {
                 return lamdaFunction;
             }
@@ -7330,6 +7215,9 @@ var AlgebraicParser = /** @class */ (function () {
                 var operand = this.parseOperand();
                 return fromUnaryAlgebraicToAstNode(token, operand);
             }
+            else if (operatorName === '=>') {
+                return this.parseShorthandLamdaFunction();
+            }
             else {
                 throw new Error("Unknown unary operator: ".concat(operatorName));
             }
@@ -7445,7 +7333,7 @@ var AlgebraicParser = /** @class */ (function () {
         };
     };
     AlgebraicParser.prototype.parseFunctionCall = function (symbol) {
-        var _a, _b;
+        var _a, _b, _c;
         var params = [];
         this.advance();
         while (!this.isAtEnd() && !isRParenToken(this.peek())) {
@@ -7477,13 +7365,17 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'when':
                     case 'when-not':
                     case 'do':
-                    case 'throw':
-                        return {
+                    case 'time!':
+                    case 'throw': {
+                        var node_1 = {
                             t: AstNodeType.SpecialExpression,
                             n: name_1,
                             p: params,
                             token: getTokenDebugData(symbol.token) && symbol.token,
                         };
+                        builtin.specialExpressions[node_1.n].validateParameterCount(node_1);
+                        return node_1;
+                    }
                     case 'def':
                     case 'defs':
                     case 'let':
@@ -7496,7 +7388,6 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'try':
                     case 'recur':
                     case 'loop':
-                    case 'time!':
                     case 'doseq':
                     case 'for':
                         throw new Error("Special expression ".concat(name_1, " is not available in algebraic notation"));
@@ -7504,7 +7395,12 @@ var AlgebraicParser = /** @class */ (function () {
                         throw new Error("Unknown special expression: ".concat(name_1));
                 }
             }
-            return createNamedNormalExpressionNode(symbol.v, params, symbol.token);
+            var node = createNamedNormalExpressionNode(symbol.v, params, symbol.token);
+            var builtinExpression = builtin.normalExpressions[node.n];
+            if (builtinExpression) {
+                (_c = builtinExpression.validate) === null || _c === void 0 ? void 0 : _c.call(builtinExpression, __assign(__assign({}, node), { p: withoutCommentNodes(node.p) }));
+            }
+            return node;
         }
         else {
             return {
@@ -7515,7 +7411,7 @@ var AlgebraicParser = /** @class */ (function () {
             };
         }
     };
-    AlgebraicParser.prototype.parseLamdaFunction = function () {
+    AlgebraicParser.prototype.parseLambdaFunction = function () {
         var _a;
         var firstToken = this.peek();
         this.advance();
@@ -7574,6 +7470,62 @@ var AlgebraicParser = /** @class */ (function () {
             token: getTokenDebugData(firstToken) && firstToken,
         };
     };
+    AlgebraicParser.prototype.parseShorthandLamdaFunction = function () {
+        var _a, _b, _c, _d;
+        var firstToken = this.peek();
+        this.advance();
+        var startPos = this.parseState.position;
+        var exprNode = this.parseExpression();
+        var endPos = this.parseState.position - 1;
+        var arity = 0;
+        var percent1 = 'NOT_SET'; // referring to argument bindings. % = NAKED, %1, %2, %3, etc = WITH_1
+        for (var pos = startPos; pos <= endPos; pos += 1) {
+            var tkn = this.tokenStream.tokens[pos];
+            if (isA_SymbolToken(tkn)) {
+                var match = placeholderRegexp$1.exec(tkn[1]);
+                if (match) {
+                    var number = (_a = match[1]) !== null && _a !== void 0 ? _a : '1';
+                    if (number === '1') {
+                        var mixedPercent1 = (!match[1] && percent1 === 'WITH_1') || (match[1] && percent1 === 'NAKED');
+                        if (mixedPercent1)
+                            throw new LitsError('Please make up your mind, either use $ or $1', (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                        percent1 = match[1] ? 'WITH_1' : 'NAKED';
+                    }
+                    arity = Math.max(arity, Number(number));
+                    if (arity > 20)
+                        throw new LitsError('Can\'t specify more than 20 arguments', (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
+                }
+            }
+            if (isA_OperatorToken(tkn, '=>')) {
+                throw new LitsError('Nested shortcut functions are not allowed', (_d = getTokenDebugData(firstToken)) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+            }
+        }
+        var mandatoryArguments = [];
+        for (var i = 1; i <= arity; i += 1) {
+            if (i === 1 && percent1 === 'NAKED')
+                mandatoryArguments.push('$');
+            else
+                mandatoryArguments.push("$".concat(i));
+        }
+        var args = {
+            b: [],
+            m: mandatoryArguments,
+        };
+        var node = {
+            t: AstNodeType.SpecialExpression,
+            n: 'fn',
+            p: [],
+            o: [
+                {
+                    as: args,
+                    b: [exprNode],
+                    a: args.m.length,
+                },
+            ],
+            token: getTokenDebugData(firstToken) && firstToken,
+        };
+        return node;
+    };
     AlgebraicParser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
     };
@@ -7817,7 +7769,7 @@ function parseSpecialExpression(tokenStream, parseState) {
     var firstToken = asLParenToken(tokenStream.tokens[parseState.position++]);
     var nameToken = asP_SymbolToken(tokenStream.tokens[parseState.position++]);
     var expressionName = nameToken[1];
-    var parse = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo).parse;
+    var _b = asNonUndefined(builtin.specialExpressions[expressionName], (_a = getTokenDebugData(nameToken)) === null || _a === void 0 ? void 0 : _a.sourceCodeInfo), parse = _b.parse, validateParameterCount = _b.validateParameterCount;
     var node = parse(tokenStream, parseState, firstToken, {
         parseExpression: parseExpression,
         parseTokensUntilClosingBracket: parseTokensUntilClosingBracket,
@@ -7826,6 +7778,7 @@ function parseSpecialExpression(tokenStream, parseState) {
         parseBindings: parseBindings,
         parseArgument: parseArgument,
     });
+    validateParameterCount(node);
     return node;
 }
 function parsePolishToken(tokenStream, parseState) {