Create README.md

[idiomatic.git] / visitor.js

diff --git a/visitor.js b/visitor.js
index 61d26809dfeb49a17a59ad1fc4096c0b4bc0ee3b..777385fc7ee9a896f3e73fc0b2874024042c153b 100644 (file)
--- a/visitor.js
+++ b/visitor.js
@@ -3,74 +3,74 @@ let log = false ? console.log : () => null
 let doit = () => null
 
 const rules = {
-  Program({body}) {body.map(walk)},
-  VariableDeclaration({kind,declarations}) {declarations.map(walk)},
-  VariableDeclarator({id,init}) {walk(id);if(init)walk(init)},
+  Program({body}) {body.map(step)},
+  VariableDeclaration({kind,declarations}) {declarations.map(step)},
+  VariableDeclarator({id,init}) {step(id);if(init)step(init)},
   Identifier({start,name}) {doit(name); log(start,name)},
-  CallExpression({callee}) {walk(callee); arguments[0]['arguments'].map(walk)},
-  NewExpression({callee}) {walk(callee); arguments[0]['arguments'].map(walk)},
-  FunctionExpression({params,body}) {params.map(walk); walk(body)},
-  MemberExpression({object,property}) {walk(object); walk(property)},
-  ObjectPattern({properties}) {properties.map(walk)},
-  ExpressionStatement({expression}) {walk(expression)},
-  IfStatement({test,consequent}) {walk(test); walk(consequent)},
-  BlockStatement({body}) {body.map(walk)},
-  ReturnStatement({argument}) {if(argument)walk(argument)},
+  CallExpression({callee}) {step(callee); arguments[0]['arguments'].map(step)},
+  NewExpression({callee}) {step(callee); arguments[0]['arguments'].map(step)},
+  FunctionExpression({params,body}) {params.map(step); step(body)},
+  MemberExpression({object,property}) {step(object); step(property)},
+  ObjectPattern({properties}) {properties.map(step)},
+  ExpressionStatement({expression}) {step(expression)},
+  IfStatement({test,consequent}) {step(test); step(consequent)},
+  BlockStatement({body}) {body.map(step)},
+  ReturnStatement({argument}) {if(argument)step(argument)},
 
   Literal({start,value,raw}) {log(start,raw)},
-  AssignmentExpression({operator,left,right}) {log(operator);walk(left);walk(right)},
-  LogicalExpression({operator,left,right}) {log(operator);walk(left);walk(right)},
-  BinaryExpression({operator,left,right}) {log(operator);walk(left);walk(right)},
-  UnaryExpression({operator,prefix,argument}) {log(prefix?'prefix':'suffix',operator); walk(argument)},
-  UpdateExpression({operator,prefix,argument}) {log(prefix?'prefix':'suffix',operator); walk(argument)},
-  ObjectExpression({properties}) {properties.map(walk)},
-  Property({key,value}) {walk(key);walk(value)},
-  ArrayExpression({elements}) {elements.map(walk)},
-  ArrayPattern({elements}) {elements.map(walk)},
-  ArrowFunctionExpression({params,body}) {params.map(walk);walk(body)},
-  TemplateLiteral({expressions,quasis}) {quasis.map(walk);expressions.map(walk)},
+  AssignmentExpression({operator,left,right}) {log(operator);step(left);step(right)},
+  LogicalExpression({operator,left,right}) {log(operator);step(left);step(right)},
+  BinaryExpression({operator,left,right}) {log(operator);step(left);step(right)},
+  UnaryExpression({operator,prefix,argument}) {log(prefix?'prefix':'suffix',operator); step(argument)},
+  UpdateExpression({operator,prefix,argument}) {log(prefix?'prefix':'suffix',operator); step(argument)},
+  ObjectExpression({properties}) {properties.map(step)},
+  Property({key,value}) {step(key);step(value)},
+  ArrayExpression({elements}) {elements.map(step)},
+  ArrayPattern({elements}) {elements.map(step)},
+  ArrowFunctionExpression({params,body}) {params.map(step);step(body)},
+  TemplateLiteral({expressions,quasis}) {quasis.map(step);expressions.map(step)},
   TemplateElement({start,end}) {log(end-start,'bytes')},
 
-  ForStatement({init,test,update,body}) {walk(init);walk(test);walk(update);walk(body)},
-  ForInStatement({left,right,body}) {walk(left); walk(right); walk(body)},
-  ForOfStatement({left,right,body}) {walk(left); walk(right); walk(body)},
-  ChainExpression({expression}) {walk(expression)},
-  ConditionalExpression({test,consequent,alternative}) {walk(test);walk(consequent);walk(alternative)},
+  ForStatement({init,test,update,body}) {step(init);step(test);step(update);step(body)},
+  ForInStatement({left,right,body}) {step(left); step(right); step(body)},
+  ForOfStatement({left,right,body}) {step(left); step(right); step(body)},
+  ChainExpression({expression}) {step(expression)},
+  ConditionalExpression({test,consequent,alternative}) {step(test);step(consequent);step(alternative)},
   ContinueStatement(){},
   BreakStatement(){},
 
-  AssignmentPattern({left,right}) {walk(left);walk(right)},
-  WhileStatement({test,body}) {walk(test);walk(body)},
-  TryStatement({block,handler,finalizer}) {walk(block);walk(handler);walk(finalizer)},
-  CatchClause({param,body}) {walk(param);walk(body)},
+  AssignmentPattern({left,right}) {step(left);step(right)},
+  WhileStatement({test,body}) {step(test);step(body)},
+  TryStatement({block,handler,finalizer}) {step(block);step(handler);step(finalizer)},
+  CatchClause({param,body}) {step(param);step(body)},
 
   EmptyStatement() {},
-  AwaitExpression({argument}) {walk(argument)},
-  ThrowStatement({argument}) {walk(argument)},
-  SwitchStatement({discriminant,cases}) {walk(discriminant); cases.map(walk)},
-  SwitchCase({test,consequent}) {walk(test); consequent.map(walk)},
-  RestElement({argument}) {walk(argument)},
-  ImportExpression({source}) {walk(source)},
-  FunctionDeclaration({id,params,body}) {walk(id),params.map(walk),walk(body)},
+  AwaitExpression({argument}) {step(argument)},
+  ThrowStatement({argument}) {step(argument)},
+  SwitchStatement({discriminant,cases}) {step(discriminant); cases.map(step)},
+  SwitchCase({test,consequent}) {step(test); consequent.map(step)},
+  RestElement({argument}) {step(argument)},
+  ImportExpression({source}) {step(source)},
+  FunctionDeclaration({id,params,body}) {step(id),params.map(step),step(body)},
 
-  ThisExpression({context}) {walk(context)},
+  ThisExpression({context}) {step(context)},
 
-  DoWhileStatement({test,body}) {walk(test);walk(body)},
-  SequenceExpression({expressions}) {expressions.map(walk)},
+  DoWhileStatement({test,body}) {step(test);step(body)},
+  SequenceExpression({expressions}) {expressions.map(step)},
 
-  SpreadElement({argument}) {walk(argument)},
+  SpreadElement({argument}) {step(argument)},
 }
 
 let each = (branch,stack) => {}
-function wander(mods,doit) {
+function walk(mods,doit) {
   each = doit
   for (const mod of mods) {
     stack = [mod.file]
-    walk(mod.tree)
+    step(mod.tree)
   }
   each = (branch,stack) => {}
 }
-function walk(branch) {
+function step(branch) {
   if(branch) {
     const type = branch?.type;
     stack.unshift(branch); 
@@ -84,4 +84,4 @@ function fail(branch) {
   console.log('FAIL',branch)
 }
 
-module.exports = {wander}
\ No newline at end of file
+module.exports = {walk}
\ No newline at end of file