@mojir/lits 2.1.2 → 2.1.4

package/dist/testFramework.js

@@ -98,9 +98,15 @@ function getCodeMarker(sourceCodeInfo) {
 }
 
 function getLitsErrorMessage(message, sourceCodeInfo) {
-    var filePathLine = (sourceCodeInfo === null || sourceCodeInfo === void 0 ? void 0 : sourceCodeInfo.filePath) ? "\n".concat(sourceCodeInfo.filePath) : '';
-    var codeLine = (sourceCodeInfo === null || sourceCodeInfo === void 0 ? void 0 : sourceCodeInfo.code) ? "\n".concat(sourceCodeInfo.code) : '';
-    var codeMarker = sourceCodeInfo && codeLine ? "\n".concat(getCodeMarker(sourceCodeInfo)) : '';
+    if (!sourceCodeInfo) {
+        return message;
+    }
+    var location = "".concat(sourceCodeInfo.position.line, ":").concat(sourceCodeInfo.position.column);
+    var filePathLine = sourceCodeInfo.filePath
+        ? "\n".concat(sourceCodeInfo.filePath, ":").concat(location)
+        : "\nLocation ".concat(location);
+    var codeLine = "\n".concat(sourceCodeInfo.code);
+    var codeMarker = "\n".concat(getCodeMarker(sourceCodeInfo));
     return "".concat(message).concat(filePathLine).concat(codeLine).concat(codeMarker);
 }
 var RecurSignal = /** @class */ (function (_super) {
@@ -235,6 +241,7 @@ var functionTypes = [
     'SomePred',
     'Fnull',
     'Builtin',
+    'SpecialBuiltin',
     'NativeJsFunction',
 ];
 var functionTypeSet = new Set(functionTypes);
@@ -406,7 +413,7 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
             return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
         /* v8 ignore next 2 */
         default:
-            throw new Error("Unhandled node type: ".concat(nodeType));
+            throw new LitsError("Unhandled node type: ".concat(nodeType), node[2]);
     }
 }
 
@@ -669,6 +676,10 @@ function isLitsFunction(value) {
         return false;
     return !!value[FUNCTION_SYMBOL];
 }
+function asLitsFunction(value, sourceCodeInfo) {
+    assertLitsFunction(value, sourceCodeInfo);
+    return value;
+}
 function assertLitsFunction(value, sourceCodeInfo) {
     if (!isLitsFunction(value))
         throw getAssertionError('LitsFunction', value, sourceCodeInfo);
@@ -1357,26 +1368,37 @@ var sequenceNormalExpression = {
         paramCount: 1,
     },
     'map': {
-        evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-            var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
-            var executeFunction = _b.executeFunction;
-            assertSeq(seq, sourceCodeInfo);
-            assertLitsFunction(fn, sourceCodeInfo);
-            if (Array.isArray(seq)) {
-                return seq.map(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
+        evaluate: function (params, sourceCodeInfo, contextStack, _a) {
+            var executeFunction = _a.executeFunction;
+            var fn = asLitsFunction(params.at(-1));
+            var seqs = params.slice(0, -1);
+            assertSeq(seqs[0], sourceCodeInfo);
+            var isString = typeof seqs[0] === 'string';
+            var len = seqs[0].length;
+            seqs.slice(1).forEach(function (seq) {
+                if (isString) {
+                    assertString(seq, sourceCodeInfo);
+                }
+                else {
+                    assertArray(seq, sourceCodeInfo);
+                }
+                len = Math.min(len, seq.length);
+            });
+            var paramArray = [];
+            var _loop_1 = function (i) {
+                paramArray.push(seqs.map(function (seq) { return seq[i]; }));
+            };
+            for (var i = 0; i < len; i++) {
+                _loop_1(i);
             }
-            else {
-                return seq
-                    .split('')
-                    .map(function (elem) {
-                    var newVal = executeFunction(fn, [elem], contextStack, sourceCodeInfo);
-                    assertString(newVal, sourceCodeInfo, { char: true });
-                    return newVal;
-                })
-                    .join('');
+            var mapped = paramArray.map(function (p) { return executeFunction(fn, p, contextStack, sourceCodeInfo); });
+            if (!isString) {
+                return mapped;
             }
+            mapped.forEach(function (char) { return assertString(char, sourceCodeInfo); });
+            return mapped.join('');
         },
-        paramCount: 2,
+        paramCount: { min: 2 },
     },
     'pop': {
         evaluate: function (_a, sourceCodeInfo) {
@@ -1926,7 +1948,7 @@ var sequenceNormalExpression = {
             assertSeq(input, sourceCodeInfo);
             if (Array.isArray(input)) {
                 var result = [];
-                var _loop_1 = function (item) {
+                var _loop_2 = function (item) {
                     assertAny(item, sourceCodeInfo);
                     if (!result.some(function (existingItem) { return deepEqual(existingItem, item, sourceCodeInfo); })) {
                         result.push(item);
@@ -1935,7 +1957,7 @@ var sequenceNormalExpression = {
                 try {
                     for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
                         var item = input_1_1.value;
-                        _loop_1(item);
+                        _loop_2(item);
                     }
                 }
                 catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -3771,6 +3793,26 @@ var andSpecialExpression = {
         }
         return value;
     },
+    evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+        var e_2, _a;
+        var value = true;
+        try {
+            for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                var param = params_1_1.value;
+                value = asAny(param, sourceCodeInfo);
+                if (!value)
+                    break;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return value;
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4015,7 +4057,7 @@ var defSpecialExpression = {
         var value = bindingNode[1][1];
         var bindingValue = evaluateNode(value, contextStack);
         var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
-        contextStack.exportValues(values);
+        contextStack.exportValues(values, target[2]);
         return null;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4027,7 +4069,7 @@ var defSpecialExpression = {
         walkDefaults(target, function (defaultNode) {
             addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
         });
-        contextStack.addValues(getAllBindingTargetNames(target));
+        contextStack.addValues(getAllBindingTargetNames(target), target[2]);
         return bindingResult;
     },
 };
@@ -4145,14 +4187,14 @@ var functionSpecialExpression = {
             _b.name = functionSymbol[1],
             _b.evaluatedfunction = evaluatedFunction,
             _b);
-        contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
+        contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
         return null;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var _b, _c;
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         var functionName = node[1][1][1];
-        contextStack.addValues((_b = {}, _b[functionName] = true, _b));
+        contextStack.addValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
         var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
         return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
     },
@@ -4173,7 +4215,7 @@ var defnSpecialExpression = {
             _b.name = functionSymbol[1],
             _b.evaluatedfunction = evaluatedFunctionOverloades,
             _b);
-        contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
+        contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
         return null;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4181,7 +4223,7 @@ var defnSpecialExpression = {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         var functionName = node[1][1][1];
         var fn = node[1][2];
-        contextStack.exportValues((_b = {}, _b[functionName] = true, _b));
+        contextStack.exportValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
         var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
         return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
     },
@@ -4293,7 +4335,7 @@ var letSpecialExpression = {
         var value = bindingNode[1][1];
         var bindingValue = evaluateNode(value, contextStack);
         var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
-        contextStack.addValues(values);
+        contextStack.addValues(values, target[2]);
         return null;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4305,7 +4347,7 @@ var letSpecialExpression = {
         walkDefaults(target, function (defaultNode) {
             addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
         });
-        contextStack.addValues(getAllBindingTargetNames(target));
+        contextStack.addValues(getAllBindingTargetNames(target), target[2]);
         return bindingResult;
     },
 };
@@ -4576,6 +4618,26 @@ var orSpecialExpression = {
         }
         return value;
     },
+    evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+        var e_2, _a;
+        var value = false;
+        try {
+            for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                var param = params_1_1.value;
+                value = asAny(param, sourceCodeInfo);
+                if (value)
+                    break;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return value;
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4594,6 +4656,11 @@ var qqSpecialExpression = {
         var firstResult = evaluateNode(firstNode, contextStack);
         return firstResult !== null && firstResult !== void 0 ? firstResult : (secondNode ? evaluateNode(secondNode, contextStack) : null);
     },
+    evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+        var firstParam = asAny(params[0], sourceCodeInfo);
+        var secondParam = params[1] !== undefined ? asAny(params[1], sourceCodeInfo) : null;
+        return firstParam !== null && firstParam !== void 0 ? firstParam : secondParam;
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols(node[1][1].filter(function (n) { return !!n; }), contextStack, builtin, evaluateNode);
@@ -4608,6 +4675,9 @@ var recurSpecialExpression = {
         var evaluatedParams = params.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
         throw new RecurSignal(evaluatedParams);
     },
+    evaluateAsNormalExpression: function (params) {
+        throw new RecurSignal(params);
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4623,6 +4693,12 @@ var throwSpecialExpression = {
         });
         throw new UserDefinedError(message, node[2]);
     },
+    evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+        var message = asString(params[0], sourceCodeInfo, {
+            nonEmpty: true,
+        });
+        throw new UserDefinedError(message, undefined);
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode);
@@ -4690,6 +4766,24 @@ var arraySpecialExpression = {
         }
         return result;
     },
+    evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+        var e_2, _a;
+        var result = [];
+        try {
+            for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                var param = params_1_1.value;
+                result.push(asAny(param, sourceCodeInfo));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return result;
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4721,6 +4815,16 @@ var objectSpecialExpression = {
         }
         return result;
     },
+    evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+        var result = {};
+        for (var i = 0; i < params.length; i += 2) {
+            var key = params[i];
+            var value = params[i + 1];
+            assertString(key, sourceCodeInfo);
+            result[key] = value !== null && value !== void 0 ? value : null;
+        }
+        return result;
+    },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4964,6 +5068,16 @@ var functionExecutors = {
         var normalExpression = asNonUndefined(allNormalExpressions[fn.normalBuitinSymbolType], sourceCodeInfo);
         return normalExpression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
     },
+    SpecialBuiltin: function (fn, params, sourceCodeInfo, contextStack, _a) {
+        var executeFunction = _a.executeFunction;
+        var specialExpression = asNonUndefined(specialExpressions[fn.specialBuiltinSymbolType], sourceCodeInfo);
+        if (specialExpression.evaluateAsNormalExpression) {
+            return specialExpression.evaluateAsNormalExpression(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
+        }
+        else {
+            throw new LitsError("Special builtin function ".concat(fn.specialBuiltinSymbolType, " is not supported as normal expression."), sourceCodeInfo);
+        }
+    },
 };
 
 function evaluate(ast, contextStack) {
@@ -5019,7 +5133,21 @@ function evaluateReservedSymbol(node) {
 function evaluateNormalExpression(node, contextStack) {
     var sourceCodeInfo = node[2];
     var paramNodes = node[1][1];
-    var params = paramNodes.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
+    var params = [];
+    paramNodes.forEach(function (paramNode) {
+        if (isSpreadNode(paramNode)) {
+            var spreadValue = evaluateNode(paramNode[1], contextStack);
+            if (Array.isArray(spreadValue)) {
+                params.push.apply(params, __spreadArray([], __read(spreadValue), false));
+            }
+            else {
+                throw new LitsError("Spread operator requires an array, got ".concat(valueToString(paramNode)), paramNode[2]);
+            }
+        }
+        else {
+            params.push(evaluateNode(paramNode, contextStack));
+        }
+    });
     if (isNormalExpressionNodeWithName(node)) {
         var nameSymbol = node[1][0];
         if (isNormalBuiltinSymbolNode(nameSymbol)) {
@@ -5121,19 +5249,19 @@ var ContextStackImpl = /** @class */ (function () {
         var contexts = [{}, context];
         return new ContextStackImpl({ contexts: contexts });
     };
-    ContextStackImpl.prototype.exportValues = function (values) {
+    ContextStackImpl.prototype.exportValues = function (values, sourceCodeInfo) {
         var e_1, _a;
         try {
             for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
                 if (this.globalContext[name_1]) {
-                    throw new Error("Cannot redefine exported value \"".concat(name_1, "\""));
+                    throw new LitsError("Cannot redefine exported value \"".concat(name_1, "\""), sourceCodeInfo);
                 }
                 if (specialExpressionKeys.includes(name_1)) {
-                    throw new Error("Cannot shadow special expression \"".concat(name_1, "\""));
+                    throw new LitsError("Cannot shadow special expression \"".concat(name_1, "\""), sourceCodeInfo);
                 }
                 if (normalExpressionKeys.includes(name_1)) {
-                    throw new Error("Cannot shadow builtin function \"".concat(name_1, "\""));
+                    throw new LitsError("Cannot shadow builtin function \"".concat(name_1, "\""), sourceCodeInfo);
                 }
                 this.globalContext[name_1] = { value: value };
             }
@@ -5145,22 +5273,22 @@ var ContextStackImpl = /** @class */ (function () {
             }
             finally { if (e_1) throw e_1.error; }
         }
-        this.addValues(values);
+        this.addValues(values, sourceCodeInfo);
     };
-    ContextStackImpl.prototype.addValues = function (values) {
+    ContextStackImpl.prototype.addValues = function (values, sourceCodeInfo) {
         var e_2, _a;
         var currentContext = this.contexts[0];
         try {
             for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var _d = __read(_c.value, 2), name_2 = _d[0], value = _d[1];
                 if (currentContext[name_2]) {
-                    throw new Error("Cannot redefine value \"".concat(name_2, "\""));
+                    throw new LitsError("Cannot redefine value \"".concat(name_2, "\""), sourceCodeInfo);
                 }
                 if (specialExpressionKeys.includes(name_2)) {
-                    throw new Error("Cannot shadow special expression \"".concat(name_2, "\""));
+                    throw new LitsError("Cannot shadow special expression \"".concat(name_2, "\""), sourceCodeInfo);
                 }
                 if (normalExpressionKeys.includes(name_2)) {
-                    throw new Error("Cannot shadow builtin function \"".concat(name_2, "\""));
+                    throw new LitsError("Cannot shadow builtin function \"".concat(name_2, "\""), sourceCodeInfo);
                 }
                 currentContext[name_2] = { value: toAny(value) };
             }
@@ -5240,18 +5368,36 @@ var ContextStackImpl = /** @class */ (function () {
         return null;
     };
     ContextStackImpl.prototype.evaluateSymbol = function (node) {
-        var _a;
+        var _a, _b;
         if (isSpecialBuiltinSymbolNode(node)) {
-            throw new Error('Special builtin symbols should not be evaluated');
+            var functionType = node[1];
+            switch (functionType) {
+                case specialExpressionTypes['&&']:
+                case specialExpressionTypes['||']:
+                case specialExpressionTypes.array:
+                case specialExpressionTypes.object:
+                case specialExpressionTypes['defined?']:
+                case specialExpressionTypes.recur:
+                case specialExpressionTypes.throw:
+                case specialExpressionTypes['??']:
+                    return _a = {},
+                        _a[FUNCTION_SYMBOL] = true,
+                        _a.functionType = 'SpecialBuiltin',
+                        _a.specialBuiltinSymbolType = functionType,
+                        _a.sourceCodeInfo = node[2],
+                        _a;
+                default:
+                    throw new LitsError("Unknown special builtin symbol type: ".concat(functionType), node[2]);
+            }
         }
         if (isNormalBuiltinSymbolNode(node)) {
             var type = node[1];
-            return _a = {},
-                _a[FUNCTION_SYMBOL] = true,
-                _a.functionType = 'Builtin',
-                _a.normalBuitinSymbolType = type,
-                _a.sourceCodeInfo = node[2],
-                _a;
+            return _b = {},
+                _b[FUNCTION_SYMBOL] = true,
+                _b.functionType = 'Builtin',
+                _b.normalBuitinSymbolType = type,
+                _b.sourceCodeInfo = node[2],
+                _b;
         }
         var lookUpResult = this.lookUp(node);
         if (isContextEntry(lookUpResult))
@@ -5923,7 +6069,7 @@ function withSourceCodeInfo(node, sourceCodeInfo) {
     }
     return node;
 }
-function getPrecedence(operatorSign) {
+function getPrecedence(operatorSign, sourceCodeInfo) {
     switch (operatorSign) {
         case '**': // exponentiation
             return exponentiationPrecedence;
@@ -5962,7 +6108,7 @@ function getPrecedence(operatorSign) {
         // leave room for binaryFunctionalOperatorPrecedence = 1
         /* v8 ignore next 2 */
         default:
-            throw new Error("Unknown binary operator: ".concat(operatorSign));
+            throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
     }
 }
 function createNamedNormalExpressionNode(symbolNode, params, sourceCodeInfo) {
@@ -6095,7 +6241,7 @@ var Parser = /** @class */ (function () {
         while (!this.isAtExpressionEnd()) {
             if (isA_BinaryOperatorToken(operator)) {
                 var name_1 = operator[1];
-                var newPrecedece = getPrecedence(name_1);
+                var newPrecedece = getPrecedence(name_1, operator[2]);
                 if (newPrecedece <= precedence
                     // ** (exponentiation) is right associative
                     && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
@@ -6175,7 +6321,7 @@ var Parser = /** @class */ (function () {
             this.advance();
             var expression = this.parseExpression();
             if (!isRParenToken(this.peek())) {
-                throw new Error('Expected closing parenthesis');
+                throw new LitsError('Expected closing parenthesis', this.peek()[2]);
             }
             this.advance();
             return expression;
@@ -6297,7 +6443,13 @@ var Parser = /** @class */ (function () {
         this.advance();
         var params = [];
         while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            params.push(this.parseExpression());
+            if (isOperatorToken(this.peek(), '...')) {
+                this.advance();
+                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
+            }
+            else {
+                params.push(this.parseExpression());
+            }
             var nextToken = this.peek();
             if (!isOperatorToken(nextToken, ',') && !isRParenToken(nextToken)) {
                 throw new LitsError('Expected comma or closing parenthesis', this.peek()[2]);
@@ -6353,7 +6505,7 @@ var Parser = /** @class */ (function () {
                     throw new LitsError("".concat(type, " is not allowed"), symbol[2]);
                 /* v8 ignore next 2 */
                 default:
-                    throw new Error("Unknown special expression: ".concat(type));
+                    throw new LitsError("Unknown special expression: ".concat(type), symbol[2]);
             }
         }
         else if (isNormalBuiltinSymbolNode(symbol) || isNormalBuiltinSymbolNode(symbol)) {