@mojir/lits 2.1.1 → 2.1.2

package/dist/reference/api.d.ts

@@ -9,7 +9,6 @@ export declare const api: {
     readonly object: readonly ["dissoc", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys"];
     readonly predicate: readonly ["boolean?", "null?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?"];
     readonly regularExpression: readonly ["regexp", "match", "replace", "replace-all"];
-    readonly specialExpressions: readonly ["&&", "||", "def", "let", "fn", "defn", "function", "try", "throw", "if", "unless", "cond", "switch", "do", "recur", "loop", "doseq", "for", "defined?", "??"];
     readonly string: readonly ["string-repeat", "str", "number", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "split-lines", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "capitalize", "blank?"];
     readonly bitwise: readonly ["<<", ">>", ">>>", "~", "&", "bit-and-not", "|", "^", "bit-flip", "bit-clear", "bit-set", "bit-test"];
     readonly assert: readonly ["assert", "assert=", "assert!=", "assert-gt", "assert-lt", "assert-gte", "assert-lte", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-null", "assert-throws", "assert-throws-error", "assert-not-throws"];

package/dist/src/builtin/bindingNode.d.ts

@@ -1,4 +1,5 @@
 import type { Any } from '../interface';
 import { type BindingTarget, type Node } from '../parser/types';
+export declare function walkDefaults(bindingTarget: BindingTarget, onDefault: (Node: Node) => void): void;
 export declare function evalueateBindingNodeValues(target: BindingTarget, value: Any, evaluate: (Node: Node) => Any): Record<string, Any>;
 export declare function getAllBindingTargetNames(bindingTarget: BindingTarget): Record<string, true>;

package/dist/src/builtin/specialExpressionTypes.d.ts

@@ -1,16 +1,15 @@
-import type { SpecialExpressionName, SpecialExpressionType } from '.';
 export declare const specialExpressionTypes: {
     readonly '??': 0;
     readonly '&&': 1;
     readonly '||': 2;
     readonly array: 3;
     readonly cond: 4;
-    readonly def: 5;
+    readonly '0_def': 5;
     readonly 'defined?': 6;
-    readonly defn: 7;
+    readonly '0_defn': 7;
     readonly do: 8;
     readonly doseq: 9;
-    readonly fn: 10;
+    readonly '0_fn': 10;
     readonly for: 11;
     readonly function: 12;
     readonly if: 13;
@@ -24,4 +23,3 @@ export declare const specialExpressionTypes: {
     readonly unless: 21;
 };
 export type SpecialExpressionTypes = typeof specialExpressionTypes;
-export declare function getNameFromSpecialExpressionType(type: SpecialExpressionType): SpecialExpressionName;

package/dist/src/builtin/specialExpressions/def.d.ts

@@ -1,5 +1,5 @@
 import type { BindingNode, SpecialExpressionNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type DefNode = SpecialExpressionNode<[typeof specialExpressionTypes['def'], BindingNode]>;
+export type DefNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_def'], BindingNode]>;
 export declare const defSpecialExpression: BuiltinSpecialExpression<null, DefNode>;

package/dist/src/builtin/specialExpressions/functions.d.ts

@@ -2,9 +2,9 @@ import type { LitsFunction, SpecialExpressionNode, SymbolNode } from '../../pars
 import type { BuiltinSpecialExpression } from '../interface';
 import type { Function } from '../utils';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['defn'], SymbolNode, Function]>;
+export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_defn'], SymbolNode, Function]>;
 export type FunctionNode = SpecialExpressionNode<[typeof specialExpressionTypes['function'], SymbolNode, Function]>;
-export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['fn'], Function]>;
+export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_fn'], Function]>;
 export declare const functionSpecialExpression: BuiltinSpecialExpression<null, FunctionNode>;
 export declare const defnSpecialExpression: BuiltinSpecialExpression<null, DefnNode>;
 export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction, FnNode>;

package/dist/src/typeGuards/astNode.d.ts

@@ -1,4 +1,3 @@
-import type { SpecialExpressionName } from '../builtin';
 import type { ExpressionNode, Node, NormalBuiltinSymbolNode, NormalExpressionNode, NormalExpressionNodeWithName, SpecialBuiltinSymbolNode, SpreadNode, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 export declare function isSymbolNode(node: Node): node is SymbolNode;
@@ -8,11 +7,7 @@ export declare function isUserDefinedSymbolNode(node: Node): node is UserDefined
 export declare function asUserDefinedSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): UserDefinedSymbolNode;
 export declare function assertUserDefinedSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is UserDefinedSymbolNode;
 export declare function isNormalBuiltinSymbolNode(node: Node): node is NormalBuiltinSymbolNode;
-export declare function asNormalBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalBuiltinSymbolNode;
-export declare function assertNormalBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalBuiltinSymbolNode;
-export declare function isSpecialBuiltinSymbolNode(node: Node, name?: SpecialExpressionName): node is SpecialBuiltinSymbolNode;
-export declare function asSpecialBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): SpecialBuiltinSymbolNode;
-export declare function assertSpecialBuiltinSymbolNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is SpecialBuiltinSymbolNode;
+export declare function isSpecialBuiltinSymbolNode(node: Node): node is SpecialBuiltinSymbolNode;
 export declare function isNormalExpressionNode(node: Node): node is NormalExpressionNode;
 export declare function asNormalExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNode;
 export declare function assertNormalExpressionNode(node: Node, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNode;

package/dist/testFramework.esm.js

@@ -183,12 +183,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,
@@ -302,25 +302,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 +357,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,10 +402,7 @@ 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));
     }
@@ -689,9 +671,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
@@ -3881,6 +3860,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 = {};
@@ -4020,6 +4022,9 @@ var defSpecialExpression = {
         var target = bindingNode[1][0];
         var value = bindingNode[1][1];
         var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
+        walkDefaults(target, function (defaultNode) {
+            addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+        });
         contextStack.addValues(getAllBindingTargetNames(target));
         return bindingResult;
     },
@@ -4147,7 +4152,7 @@ var functionSpecialExpression = {
         var functionName = node[1][1][1];
         contextStack.addValues((_b = {}, _b[functionName] = true, _b));
         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 = {
@@ -4176,7 +4181,7 @@ var defnSpecialExpression = {
         var fn = node[1][2];
         contextStack.exportValues((_b = {}, _b[functionName] = true, _b));
         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 +4203,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 +4228,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);
@@ -4292,6 +4300,9 @@ var letSpecialExpression = {
         var target = bindingNode[1][0];
         var value = bindingNode[1][1];
         var bindingResult = getUndefinedSymbols([value], contextStack, builtin, evaluateNode);
+        walkDefaults(target, function (defaultNode) {
+            addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
+        });
         contextStack.addValues(getAllBindingTargetNames(target));
         return bindingResult;
     },
@@ -5243,8 +5254,6 @@ var ContextStackImpl = /** @class */ (function () {
         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 +5337,10 @@ var nonFunctionOperators = [
     'cond',
     'def',
     'defined?',
-    'defn',
+    // 'defn',
     'do',
     'doseq',
-    'fn',
+    // 'fn',
     'if',
     'let',
     'loop',
@@ -6176,10 +6185,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();
@@ -6339,9 +6345,9 @@ 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:
@@ -6369,7 +6375,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 +6458,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 +6977,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 +6995,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 +7005,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) {