@mojir/lits 2.1.1 → 2.1.3

package/dist/testFramework.esm.js

@@ -96,9 +96,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) {
@@ -183,12 +189,12 @@ var specialExpressionTypes = {
     '||': 2,
     'array': 3,
     'cond': 4,
-    'def': 5,
+    '0_def': 5,
     'defined?': 6,
-    'defn': 7,
+    '0_defn': 7,
     'do': 8,
     'doseq': 9,
-    'fn': 10,
+    '0_fn': 10,
     'for': 11,
     'function': 12,
     'if': 13,
@@ -233,6 +239,7 @@ var functionTypes = [
     'SomePred',
     'Fnull',
     'Builtin',
+    'SpecialBuiltin',
     'NativeJsFunction',
 ];
 var functionTypeSet = new Set(functionTypes);
@@ -302,25 +309,9 @@ function assertUserDefinedSymbolNode(node, sourceCodeInfo) {
 function isNormalBuiltinSymbolNode(node) {
     return NodeTypes.NormalBuiltinSymbol === node[0];
 }
-function isSpecialBuiltinSymbolNode(node, name) {
-    if (NodeTypes.SpecialBuiltinSymbol !== node[0]) {
-        return false;
-    }
-    {
-        return true;
-    }
+function isSpecialBuiltinSymbolNode(node) {
+    return NodeTypes.SpecialBuiltinSymbol === node[0];
 }
-// export function isNumberNode(node: Node): node is NumberNode {
-//   return node[0] === NodeTypes.Number
-// }
-// export function asNumberNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NumberNode {
-//   assertNumberNode(node, sourceCodeInfo)
-//   return node
-// }
-// export function assertNumberNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NumberNode {
-//   if (!isNumberNode(node))
-//     throw getAssertionError('NumberNode', node, sourceCodeInfo)
-// }
 function isNormalExpressionNode(node) {
     return node[0] === NodeTypes.NormalExpression;
 }
@@ -373,6 +364,7 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
         case NodeTypes.String:
         case NodeTypes.Number:
         case NodeTypes.ReservedSymbol:
+        case NodeTypes.Binding:
             return null;
         case NodeTypes.NormalExpression: {
             var normalExpressionNode = node;
@@ -417,12 +409,9 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
         }
         case NodeTypes.Spread:
             return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
-        case NodeTypes.Binding: {
-            var bindingNode = node;
-            return findUnresolvedSymbolsInNode(bindingNode[1][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]);
     }
 }
 
@@ -689,9 +678,6 @@ function assertLitsFunction(value, sourceCodeInfo) {
     if (!isLitsFunction(value))
         throw getAssertionError('LitsFunction', value, sourceCodeInfo);
 }
-function isBuiltinFunction(value) {
-    return isUnknownRecord(value) && value.functionType === 'Builtin';
-}
 
 function isAny(value) {
     // TODO weak test
@@ -3790,6 +3776,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);
@@ -3881,6 +3887,29 @@ var bindingTargetTypes = {
     array: 14,
 };
 
+function walkDefaults(bindingTarget, onDefault) {
+    var _a;
+    if (bindingTarget[0] === bindingTargetTypes.object) {
+        Object.values(bindingTarget[1][0]).forEach(function (element) {
+            if (element[1][1]) {
+                onDefault(element[1][1]);
+            }
+            walkDefaults(element, onDefault);
+        });
+    }
+    else if (bindingTarget[0] === bindingTargetTypes.array) {
+        for (var index = 0; index < bindingTarget[1][0].length; index += 1) {
+            var element = (_a = bindingTarget[1][0][index]) !== null && _a !== void 0 ? _a : null;
+            if (element === null) {
+                continue;
+            }
+            if (element[1][1]) {
+                onDefault(element[1][1]);
+            }
+            walkDefaults(element, onDefault);
+        }
+    }
+}
 function evalueateBindingNodeValues(target, value, evaluate) {
     var sourceCodeInfo = target[2];
     var record = {};
@@ -4011,7 +4040,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) {
@@ -4020,7 +4049,10 @@ var defSpecialExpression = {
         var target = bindingNode[1][0];
         var value = bindingNode[1][1];
         var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
-        contextStack.addValues(getAllBindingTargetNames(target));
+        walkDefaults(target, function (defaultNode) {
+            addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+        });
+        contextStack.addValues(getAllBindingTargetNames(target), target[2]);
         return bindingResult;
     },
 };
@@ -4138,16 +4170,16 @@ 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 addFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
+        return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
     },
 };
 var defnSpecialExpression = {
@@ -4166,7 +4198,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) {
@@ -4174,9 +4206,9 @@ 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 addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
+        return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
     },
 };
 var fnSpecialExpression = {
@@ -4198,7 +4230,7 @@ var fnSpecialExpression = {
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
         var fn = node[1][1];
-        return addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode);
+        return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode);
     },
 };
 function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode) {
@@ -4223,12 +4255,15 @@ function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evalua
     ];
     return evaluatedFunction;
 }
-function addFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
+function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
     var result = new Set();
     var contextStackWithFunctionName = functionNameContext ? contextStack.create(functionNameContext) : contextStack;
     var newContext = {};
     fn[0].forEach(function (arg) {
         Object.assign(newContext, getAllBindingTargetNames(arg));
+        walkDefaults(arg, function (defaultNode) {
+            addToSet(result, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+        });
     });
     var newContextStack = contextStackWithFunctionName.create(newContext);
     var overloadResult = getUndefinedSymbols(fn[1], newContextStack, builtin, evaluateNode);
@@ -4283,7 +4318,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) {
@@ -4292,7 +4327,10 @@ var letSpecialExpression = {
         var target = bindingNode[1][0];
         var value = bindingNode[1][1];
         var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
-        contextStack.addValues(getAllBindingTargetNames(target));
+        walkDefaults(target, function (defaultNode) {
+            addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+        });
+        contextStack.addValues(getAllBindingTargetNames(target), target[2]);
         return bindingResult;
     },
 };
@@ -4563,6 +4601,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);
@@ -4581,6 +4639,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);
@@ -4595,6 +4658,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);
@@ -4610,6 +4676,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);
@@ -4677,6 +4749,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);
@@ -4708,6 +4798,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);
@@ -4951,6 +5051,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) {
@@ -5006,7 +5116,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)) {
@@ -5108,19 +5232,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 };
             }
@@ -5132,22 +5256,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) };
             }
@@ -5227,24 +5351,40 @@ 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))
             return lookUpResult.value;
-        else if (isBuiltinFunction(lookUpResult))
-            return lookUpResult;
         throw new UndefinedSymbolError(node[1], node[2]);
     };
     return ContextStackImpl;
@@ -5328,10 +5468,10 @@ var nonFunctionOperators = [
     'cond',
     'def',
     'defined?',
-    'defn',
+    // 'defn',
     'do',
     'doseq',
-    'fn',
+    // 'fn',
     'if',
     'let',
     'loop',
@@ -5912,7 +6052,7 @@ function withSourceCodeInfo(node, sourceCodeInfo) {
     }
     return node;
 }
-function getPrecedence(operatorSign) {
+function getPrecedence(operatorSign, sourceCodeInfo) {
     switch (operatorSign) {
         case '**': // exponentiation
             return exponentiationPrecedence;
@@ -5951,7 +6091,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) {
@@ -6084,7 +6224,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)) {
@@ -6164,7 +6304,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;
@@ -6176,10 +6316,7 @@ var Parser = /** @class */ (function () {
                 if (specialExpressionTypes[operatorName] !== undefined) {
                     return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[operatorName]], token[2]);
                 }
-                else if (normalExpressionTypes[operatorName] !== undefined) {
-                    return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
-                }
-                return withSourceCodeInfo([NodeTypes.UserDefinedSymbol, operatorName], token[2]);
+                return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
             }
             if (operatorName === '->') {
                 return this.parseShorthandLamdaFunction();
@@ -6289,7 +6426,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]);
@@ -6339,13 +6482,13 @@ var Parser = /** @class */ (function () {
                     var _b = __read(params, 1), param = _b[0];
                     return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                 }
-                case specialExpressionTypes.fn:
-                case specialExpressionTypes.def:
-                case specialExpressionTypes.defn:
+                case specialExpressionTypes['0_fn']:
+                case specialExpressionTypes['0_def']:
+                case specialExpressionTypes['0_defn']:
                     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)) {
@@ -6369,7 +6512,7 @@ var Parser = /** @class */ (function () {
             }
             this.advance();
             var body = this.parseExpression();
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.fn, [
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
                         functionArguments,
                         [body],
                     ]]], firstToken[2]);
@@ -6452,7 +6595,7 @@ var Parser = /** @class */ (function () {
                 functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, "$".concat(i)], undefined]], firstToken[2]));
             }
         }
-        var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.fn, [
+        var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
                     functionArguments,
                     [exprNode],
                 ]]], firstToken[2]);
@@ -6971,7 +7114,7 @@ var Parser = /** @class */ (function () {
         this.advance();
         if (isSymbolToken(this.peek(), 'let')) {
             var letNode = this.parseLet(asSymbolToken(this.peek()));
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.def, letNode[1][1]]], token[2]);
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], token[2]);
         }
         else if (isReservedSymbolToken(this.peek(), 'function')) {
             this.advance();
@@ -6989,7 +7132,7 @@ var Parser = /** @class */ (function () {
             }
             assertReservedSymbolToken(this.peek(), 'end');
             this.advance();
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.defn, symbol, [
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_defn'], symbol, [
                         functionArguments,
                         body,
                     ]]], token[2]);
@@ -6999,7 +7142,7 @@ var Parser = /** @class */ (function () {
         }
     };
     Parser.prototype.stringToSymbolNode = function (value, sourceCodeInfo) {
-        if (specialExpressionTypes[value] !== undefined) {
+        if (specialExpressionTypes[value] !== undefined && value !== 'fn' && value !== 'def' && value !== 'defn') {
             return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[value]], sourceCodeInfo);
         }
         if (normalExpressionTypes[value] !== undefined) {