Improve error message

jkeylu · jkeylu · commit 043b567d5b08 · 2018-04-19T22:11:20.000+08:00
diff --git a/dist/evil-eval.min.js b/dist/evil-eval.min.js
diff --git a/src/environment.ts b/src/environment.ts
@@ -29,7 +29,7 @@ export default class Environment<T> {
 
         const evaluate = this.evaluateMap[node.type];
         if (!evaluate) {
-            throw new Error();
+            throw new Error(`evil-eval: Node type "${node.type}" is not implemented`);
         }
 
         return evaluate(env);
diff --git a/src/evaluate/es2015.ts b/src/evaluate/es2015.ts
@@ -15,7 +15,7 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {
             } else if (property.key.type === 'Identifier') {
                 key = property.key.name;
             } else {
-                throw new Error();
+                throw new Error(`evil-eval: [ObjectExpression] Unsupported property key type "${property.key.type}"`);
             }
         } else {
             if (property.key.type === 'Identifier') {
@@ -34,109 +34,109 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {
         } else if (property.kind === 'set') {
             Object.defineProperty(obj, key, { set: value });
         } else {
-            throw new Error();
+            throw new Error(`evil-eval: [ObjectExpression] Unsupported property kind "${property.kind}"`);
         }
     }
 
     return obj;
 }
 
 export function ForOfStatement(env: Environment<ESTree.ForOfStatement>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function Super(env: Environment<ESTree.Super>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function SpreadElement(env: Environment<ESTree.SpreadElement>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ArrowFunctionExpression(env: Environment<ESTree.ArrowFunctionExpression>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function YieldExpression(env: Environment<ESTree.YieldExpression>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function TemplateLiteral(env: Environment<ESTree.TemplateLiteral>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function TaggedTemplateExpression(env: Environment<ESTree.TaggedTemplateExpression>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function TemplateElement(env: Environment<ESTree.TemplateElement>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ObjectPattern(env: Environment<ESTree.ObjectPattern>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ArrayPattern(env: Environment<ESTree.ArrayPattern>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function RestElement(env: Environment<ESTree.RestElement>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function AssignmentPattern(env: Environment<ESTree.AssignmentPattern>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ClassBody(env: Environment<ESTree.ClassBody>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function MethodDefinition(env: Environment<ESTree.MethodDefinition>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ClassDeclaration(env: Environment<ESTree.ClassDeclaration>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ClassExpression(env: Environment<ESTree.ClassExpression>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function MetaProperty(env: Environment<ESTree.MetaProperty>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ImportDeclaration(env: Environment<ESTree.ImportDeclaration>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ImportSpecifier(env: Environment<ESTree.ImportSpecifier>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ImportDefaultSpecifier(env: Environment<ESTree.ImportDefaultSpecifier>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ImportNamespaceSpecifier(env: Environment<ESTree.ImportNamespaceSpecifier>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ExportNamedDeclaration(env: Environment<ESTree.ExportNamedDeclaration>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ExportSpecifier(env: Environment<ESTree.ExportSpecifier>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ExportDefaultDeclaration(env: Environment<ESTree.ExportDefaultDeclaration>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ExportAllDeclaration(env: Environment<ESTree.ExportAllDeclaration>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
diff --git a/src/evaluate/es2017.ts b/src/evaluate/es2017.ts
@@ -5,5 +5,5 @@ import Signal from '../signal';
 import Environment from '../environment';
 
 export function AwaitExpression(env: Environment<ESTree.AwaitExpression>) {
-    throw new Error('Not implemented');
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
diff --git a/src/evaluate/es5.ts b/src/evaluate/es5.ts
@@ -65,7 +65,7 @@ export function DebuggerStatement(env: Environment<ESTree.DebuggerStatement>) {
 }
 
 export function WithStatement(env: Environment<ESTree.WithStatement>) {
-    throw new Error(`"${env.node.type}" not implemented`);
+    throw new Error(`evil-eval: "${env.node.type}" not implemented`);
 }
 
 export function ReturnStatement(env: Environment<ESTree.ReturnStatement>) {
@@ -234,7 +234,7 @@ export function ForInStatement(env: Environment<ESTree.ForInStatement>) {
         value = scope.declare(keyName, null, left.kind);
         isConstDeclaration = left.kind === 'const';
     } else {
-        throw new Error();
+        throw new Error(`evil-eval: [ForInStatement] Unsupported left type "${left.type}"`);
     }
 
     for (const key in env.evaluate(right)) {
@@ -271,7 +271,7 @@ export function VariableDeclaration(env: Environment<ESTree.VariableDeclaration>
 }
 
 export function VariableDeclarator(env: Environment<ESTree.VariableDeclarator>) {
-    throw new Error();
+    throw new Error(`evil-eval: [VariableDeclarator] Should not happen`);
 }
 
 export function ThisExpression(env: Environment<ESTree.ThisExpression>) {
@@ -293,7 +293,7 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {
         } else if (property.key.type === 'Identifier') {
             key = property.key.name;
         } else {
-            throw new Error();
+            throw new Error(`evil-eval: [ObjectExpression] Unsupported property key type "${property.key.type}"`);
         }
         obj[key] = env.evaluate(property.value);
     }
@@ -302,7 +302,7 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {
 }
 
 export function Property(env: Environment<ESTree.Property>) {
-    throw new Error();
+    throw new Error(`evil-eval: [Property] Should not happen`);
 }
 
 export function FunctionExpression(env: Environment<ESTree.FunctionExpression>) {
@@ -342,11 +342,11 @@ const UnaryExpressionOperatorEvaluateMap = {
             try {
                 const value = env.scope.get(env.node.argument.name);
                 return value ? typeof value.v : 'undefined';
-            } catch (e) {
-                if (e.message === `${env.node.argument.name} is not defined`) {
+            } catch (err) {
+                if (err.message === `${env.node.argument.name} is not defined`) {
                     return 'undefined';
                 } else {
-                    throw e;
+                    throw err;
                 }
             }
         } else {
diff --git a/src/scope.ts b/src/scope.ts
@@ -42,7 +42,7 @@ export default class Scope {
             return this.constDeclare(name, value);
 
         } else {
-            throw new Error();
+            throw new Error('evil-eval: Invalid Variable Declaration Kind');
         }
     }
 
diff --git a/src/tool.ts b/src/tool.ts
@@ -20,6 +20,6 @@ export function getIdentifierOrMemberExpressionValue(node: ESTree.Pattern | ESTr
         return createMemberValue(obj, name);
 
     } else {
-        throw new Error();
+        throw new Error(`evil-eval: Not support to get value of node type "${node.type}"`);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ export default class Environment<T> {`
`29`	`29`
`30`	`30`	`const evaluate = this.evaluateMap[node.type];`
`31`	`31`	`if (!evaluate) {`
`32`		`- throw new Error();`
	`32`	+ throw new Error(`evil-eval: Node type "${node.type}" is not implemented`);
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`return evaluate(env);`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {`
`15`	`15`	`} else if (property.key.type === 'Identifier') {`
`16`	`16`	`key = property.key.name;`
`17`	`17`	`} else {`
`18`		`- throw new Error();`
	`18`	+ throw new Error(`evil-eval: [ObjectExpression] Unsupported property key type "${property.key.type}"`);
`19`	`19`	`}`
`20`	`20`	`} else {`
`21`	`21`	`if (property.key.type === 'Identifier') {`
`@@ -34,109 +34,109 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {`
`34`	`34`	`} else if (property.kind === 'set') {`
`35`	`35`	`Object.defineProperty(obj, key, { set: value });`
`36`	`36`	`} else {`
`37`		`- throw new Error();`
	`37`	+ throw new Error(`evil-eval: [ObjectExpression] Unsupported property kind "${property.kind}"`);
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`return obj;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`export function ForOfStatement(env: Environment<ESTree.ForOfStatement>) {`
`45`		- throw new Error(`"${env.node.type}" not implemented`);
	`45`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`export function Super(env: Environment<ESTree.Super>) {`
`49`		- throw new Error(`"${env.node.type}" not implemented`);
	`49`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`export function SpreadElement(env: Environment<ESTree.SpreadElement>) {`
`53`		- throw new Error(`"${env.node.type}" not implemented`);
	`53`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`export function ArrowFunctionExpression(env: Environment<ESTree.ArrowFunctionExpression>) {`
`57`		- throw new Error(`"${env.node.type}" not implemented`);
	`57`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`export function YieldExpression(env: Environment<ESTree.YieldExpression>) {`
`61`		- throw new Error(`"${env.node.type}" not implemented`);
	`61`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`export function TemplateLiteral(env: Environment<ESTree.TemplateLiteral>) {`
`65`		- throw new Error(`"${env.node.type}" not implemented`);
	`65`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`export function TaggedTemplateExpression(env: Environment<ESTree.TaggedTemplateExpression>) {`
`69`		- throw new Error(`"${env.node.type}" not implemented`);
	`69`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`export function TemplateElement(env: Environment<ESTree.TemplateElement>) {`
`73`		- throw new Error(`"${env.node.type}" not implemented`);
	`73`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`export function ObjectPattern(env: Environment<ESTree.ObjectPattern>) {`
`77`		- throw new Error(`"${env.node.type}" not implemented`);
	`77`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`export function ArrayPattern(env: Environment<ESTree.ArrayPattern>) {`
`81`		- throw new Error(`"${env.node.type}" not implemented`);
	`81`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`export function RestElement(env: Environment<ESTree.RestElement>) {`
`85`		- throw new Error(`"${env.node.type}" not implemented`);
	`85`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`export function AssignmentPattern(env: Environment<ESTree.AssignmentPattern>) {`
`89`		- throw new Error(`"${env.node.type}" not implemented`);
	`89`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`export function ClassBody(env: Environment<ESTree.ClassBody>) {`
`93`		- throw new Error(`"${env.node.type}" not implemented`);
	`93`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`export function MethodDefinition(env: Environment<ESTree.MethodDefinition>) {`
`97`		- throw new Error(`"${env.node.type}" not implemented`);
	`97`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`export function ClassDeclaration(env: Environment<ESTree.ClassDeclaration>) {`
`101`		- throw new Error(`"${env.node.type}" not implemented`);
	`101`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`export function ClassExpression(env: Environment<ESTree.ClassExpression>) {`
`105`		- throw new Error(`"${env.node.type}" not implemented`);
	`105`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`export function MetaProperty(env: Environment<ESTree.MetaProperty>) {`
`109`		- throw new Error(`"${env.node.type}" not implemented`);
	`109`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`export function ImportDeclaration(env: Environment<ESTree.ImportDeclaration>) {`
`113`		- throw new Error(`"${env.node.type}" not implemented`);
	`113`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`export function ImportSpecifier(env: Environment<ESTree.ImportSpecifier>) {`
`117`		- throw new Error(`"${env.node.type}" not implemented`);
	`117`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`export function ImportDefaultSpecifier(env: Environment<ESTree.ImportDefaultSpecifier>) {`
`121`		- throw new Error(`"${env.node.type}" not implemented`);
	`121`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`export function ImportNamespaceSpecifier(env: Environment<ESTree.ImportNamespaceSpecifier>) {`
`125`		- throw new Error(`"${env.node.type}" not implemented`);
	`125`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`export function ExportNamedDeclaration(env: Environment<ESTree.ExportNamedDeclaration>) {`
`129`		- throw new Error(`"${env.node.type}" not implemented`);
	`129`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`export function ExportSpecifier(env: Environment<ESTree.ExportSpecifier>) {`
`133`		- throw new Error(`"${env.node.type}" not implemented`);
	`133`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`export function ExportDefaultDeclaration(env: Environment<ESTree.ExportDefaultDeclaration>) {`
`137`		- throw new Error(`"${env.node.type}" not implemented`);
	`137`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`export function ExportAllDeclaration(env: Environment<ESTree.ExportAllDeclaration>) {`
`141`		- throw new Error(`"${env.node.type}" not implemented`);
	`141`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`142`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,5 +5,5 @@ import Signal from '../signal';`
`5`	`5`	`import Environment from '../environment';`
`6`	`6`
`7`	`7`	`export function AwaitExpression(env: Environment<ESTree.AwaitExpression>) {`
`8`		`- throw new Error('Not implemented');`
	`8`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ export function DebuggerStatement(env: Environment<ESTree.DebuggerStatement>) {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`export function WithStatement(env: Environment<ESTree.WithStatement>) {`
`68`		- throw new Error(`"${env.node.type}" not implemented`);
	`68`	+ throw new Error(`evil-eval: "${env.node.type}" not implemented`);
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`export function ReturnStatement(env: Environment<ESTree.ReturnStatement>) {`
`@@ -234,7 +234,7 @@ export function ForInStatement(env: Environment<ESTree.ForInStatement>) {`
`234`	`234`	`value = scope.declare(keyName, null, left.kind);`
`235`	`235`	`isConstDeclaration = left.kind === 'const';`
`236`	`236`	`} else {`
`237`		`- throw new Error();`
	`237`	+ throw new Error(`evil-eval: [ForInStatement] Unsupported left type "${left.type}"`);
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`for (const key in env.evaluate(right)) {`
`@@ -271,7 +271,7 @@ export function VariableDeclaration(env: Environment<ESTree.VariableDeclaration>`
`271`	`271`	`}`
`272`	`272`
`273`	`273`	`export function VariableDeclarator(env: Environment<ESTree.VariableDeclarator>) {`
`274`		`- throw new Error();`
	`274`	+ throw new Error(`evil-eval: [VariableDeclarator] Should not happen`);
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`export function ThisExpression(env: Environment<ESTree.ThisExpression>) {`
`@@ -293,7 +293,7 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {`
`293`	`293`	`} else if (property.key.type === 'Identifier') {`
`294`	`294`	`key = property.key.name;`
`295`	`295`	`} else {`
`296`		`- throw new Error();`
	`296`	+ throw new Error(`evil-eval: [ObjectExpression] Unsupported property key type "${property.key.type}"`);
`297`	`297`	`}`
`298`	`298`	`obj[key] = env.evaluate(property.value);`
`299`	`299`	`}`
`@@ -302,7 +302,7 @@ export function ObjectExpression(env: Environment<ESTree.ObjectExpression>) {`
`302`	`302`	`}`
`303`	`303`
`304`	`304`	`export function Property(env: Environment<ESTree.Property>) {`
`305`		`- throw new Error();`
	`305`	+ throw new Error(`evil-eval: [Property] Should not happen`);
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`export function FunctionExpression(env: Environment<ESTree.FunctionExpression>) {`
`@@ -342,11 +342,11 @@ const UnaryExpressionOperatorEvaluateMap = {`
`342`	`342`	`try {`
`343`	`343`	`const value = env.scope.get(env.node.argument.name);`
`344`	`344`	`return value ? typeof value.v : 'undefined';`
`345`		`- } catch (e) {`
`346`		- if (e.message === `${env.node.argument.name} is not defined`) {
	`345`	`+ } catch (err) {`
	`346`	+ if (err.message === `${env.node.argument.name} is not defined`) {
`347`	`347`	`return 'undefined';`
`348`	`348`	`} else {`
`349`		`- throw e;`
	`349`	`+ throw err;`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ export default class Scope {`
`42`	`42`	`return this.constDeclare(name, value);`
`43`	`43`
`44`	`44`	`} else {`
`45`		`- throw new Error();`
	`45`	`+ throw new Error('evil-eval: Invalid Variable Declaration Kind');`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,6 @@ export function getIdentifierOrMemberExpressionValue(node: ESTree.Pattern \| ESTr`
`20`	`20`	`return createMemberValue(obj, name);`
`21`	`21`
`22`	`22`	`} else {`
`23`		`- throw new Error();`
	`23`	+ throw new Error(`evil-eval: Not support to get value of node type "${node.type}"`);
`24`	`24`	`}`
`25`	`25`	`}`