visitor walks, not wander

diff --git a/index.js b/index.js
index b1a1a24fbf450d892e5dfe7d16fa50cec085c7d1..ff1804ce45ed8841a5dad7b7d3c4f0c663d207f1 100644 (file)
--- a/index.js
+++ b/index.js
@@ -37,7 +37,7 @@ app.get('/index', async (req,res,next) => {
   console.log(new Date().toLocaleTimeString(), 'index')
   const reductions = counter()
   const doit = branch => {reductions.count(branch.type)}
-  visitor.wander(mods,doit)
+  visitor.walk(mods,doit)
   const result = `
     <p>${reductions.size()} non-terminals
     <br>${reductions.total()} reductions
@@ -59,7 +59,7 @@ app.get('/terminal', (req,res) => {
   const {type,field} = req.query
   const lits = counter()
   const doit = branch => {if(branch.type==type) lits.count(branch[field])}
-  visitor.wander(mods,doit)
+  visitor.walk(mods,doit)
   const result = style('terminal',type)+`
     <p>${lits.size()} uniques
     <br>${lits.total()} total
@@ -79,7 +79,7 @@ app.get('/usage', (req,res) => {
       ${stack.at(-1)}</a>
       <td>${sxpr(stack[width ?? 2], depth ?? 3)}`)
   }
-  visitor.wander(mods,doit)
+  visitor.walk(mods,doit)
   const vis = row => row.split(/\n/)[3].trim().replaceAll(/<.*?>/g,'').replaceAll(/\.\.+/g,'..')
   list.sort((a,b) => vis(a)>vis(b) ? 1 : -1)
   const q = (id,delta) => Object.entries(req.query)
@@ -110,7 +110,7 @@ app.get('/nesting', (req,res) => {
         <p><pre>${escape(JSON.stringify(hit,omit,2))}</pre>`)
     }
   }
-  visitor.wander(mods,doit)
+  visitor.walk(mods,doit)
   res.send(style('nesting',key)+`${result.join("<hr>")}`)
 })
 

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