Make node names optional

src/babel/__snapshots__/plugin.test.js.snap

···
     return;
   }
 
-  node.tag = 'a';
+  if ('a') node.tag = 'a';
   return node;
 };
 
···
     return;
   }
 
-  node.tag = 'b';
+  if ('b') node.tag = 'b';
   return node;
 };"
 `;
···
     return;
   }
 
-  node.tag = 'node';
+  if ('node') node.tag = 'node';
   return node;
 };"
 `;
···
     return;
   }
 
-  node.tag = 'inner';
+  if ('inner') node.tag = 'inner';
   return node;
 };
 
···
     return;
   }
 
-  node.tag = 'node';
+  if ('node') node.tag = 'node';
+  return node;
+};"
+`;
+
+exports[`works with nameless matchers 1`] = `
+"import { match, __pattern as _pattern } from \\"reghex\\";
+
+var _objectObject_expression = _pattern(1),
+    _objectObject_expression2 = _pattern(2),
+    _objectObject_expression3 = _pattern(3),
+    _objectObject_expression4 = _pattern(4),
+    _objectObject_expression5 = _pattern(5);
+
+const node = function (state) {
+  var y1 = state.y,
+      x1 = state.x;
+  var node = [];
+  var x;
+
+  alt_2: {
+    block_2: {
+      var y2 = state.y,
+          x2 = state.x;
+
+      if ((x = _objectObject_expression(state)) != null) {
+        node.push(x);
+      } else {
+        state.y = y2;
+        state.x = x2;
+        break block_2;
+      }
+
+      group_2: for (;;) {
+        var y2 = state.y,
+            x2 = state.x;
+
+        if ((x = _objectObject_expression(state)) != null) {
+          node.push(x);
+        } else {
+          state.y = y2;
+          state.x = x2;
+          break group_2;
+        }
+      }
+
+      break alt_2;
+    }
+
+    if ((x = _objectObject_expression2(state)) != null) {
+      node.push(x);
+    } else {
+      state.y = y1;
+      state.x = x1;
+      return;
+    }
+
+    group_2: for (;;) {
+      var y2 = state.y,
+          x2 = state.x;
+
+      if ((x = _objectObject_expression2(state)) != null) {
+        node.push(x);
+      } else {
+        state.y = y2;
+        state.x = x2;
+        break group_2;
+      }
+    }
+
+    group_2: for (;;) {
+      var y2 = state.y,
+          x2 = state.x;
+      var ln2 = node.length;
+
+      if ((x = _objectObject_expression3(state)) != null) {
+        node.push(x);
+      } else {
+        state.y = y2;
+        state.x = x2;
+        node.length = ln2;
+        break group_2;
+      }
+
+      var y4 = state.y,
+          x4 = state.x;
+
+      if ((x = _objectObject_expression4(state)) != null) {
+        node.push(x);
+      } else {
+        state.y = y4;
+        state.x = x4;
+      }
+
+      if ((x = _objectObject_expression5(state)) != null) {
+        node.push(x);
+      } else {
+        state.y = y2;
+        state.x = x2;
+        node.length = ln2;
+        break group_2;
+      }
+    }
+  }
+
+  if (null) node.tag = null;
   return node;
 };"
 `;
···
     }
   }
 
-  node.tag = 'node';
+  if ('node') node.tag = 'node';
   return node;
 };"
 `;
···
     return;
   }
 
-  node.tag = 'inner';
+  if ('inner') node.tag = 'inner';
   return node;
 };
 
···
     return;
   }
 
-  node.tag = 'node';
+  if ('node') node.tag = 'node';
   return node;
 };"
 `;
···
     }
   }
 
-  node.tag = 'node';
+  if ('node') node.tag = 'node';
   return node;
 };"
 `;
···
       x1 = state.x;
   var node = [];
   var x;
-  node.tag = 'inner';
+  if ('inner') node.tag = 'inner';
   return _inner_transform(node);
 };
 
···
       x1 = state.x;
   var node = [];
   var x;
-  node.tag = 'node';
+  if ('node') node.tag = 'node';
   return transform(node);
 };"
 `;

src/babel/plugin.test.js

···
   ).toMatchSnapshot();
 });
 
+it('works with nameless matchers', () => {
+  const code = `
+    import { match } from 'reghex/macro';
+
+    const node = match()\`
+      \${1}+ | \${2}+ (\${3} ( \${4}? \${5} ) )*
+    \`;
+  `;
+
+  expect(
+    transform(code, { babelrc: false, presets: [], plugins: [reghexPlugin] })
+      .code
+  ).toMatchSnapshot();
+});
+
 it('works while only minifying', () => {
   const code = `
     import { match } from 'reghex/macro';

src/babel/transform.js

···
     getMatchName(path) {
       t.assertTaggedTemplateExpression(path.node);
       const nameArgumentPath = path.get('tag.arguments.0');
-      const { confident, value } = nameArgumentPath.evaluate();
-      if (!confident && t.isIdentifier(nameArgumentPath.node)) {
-        return nameArgumentPath.node.name;
-      } else if (confident && typeof value === 'string') {
-        return value;
-      } else {
-        return path.scope.generateUidIdentifierBasedOnNode(path.node);
+      if (nameArgumentPath) {
+        const { confident, value } = nameArgumentPath.evaluate();
+        if (!confident && t.isIdentifier(nameArgumentPath.node)) {
+          return nameArgumentPath.node.name;
+        } else if (confident && typeof value === 'string') {
+          return value;
+        }
       }
+
+      return path.scope.generateUidIdentifierBasedOnNode(path.node);
     },
 
     /** Given a match, hoists its expressions in front of the match's statement */
···
     },
 
     minifyMatch(path) {
-      if (!path.node.tag.arguments.length) {
-        throw path
-          .get('tag')
-          .buildCodeFrameError(
-            'match() must at least be called with a node name'
-          );
-      }
-
       const quasis = path.node.quasi.quasis.map((x) =>
         t.stringLiteral(x.value.cooked.replace(/\s*/g, ''))
       );
···
     },
 
     transformMatch(path) {
-      if (!path.node.tag.arguments.length) {
-        throw path
-          .get('tag')
-          .buildCodeFrameError(
-            'match() must at least be called with a node name'
-          );
+      let name = path.node.tag.arguments[0];
+      if (!name) {
+        name = t.nullLiteral();
       }
 
-      const name = path.node.tag.arguments[0];
       const quasis = path.node.quasi.quasis.map((x) => x.value.cooked);
 
       const expressions = this._prepareExpressions(path);

src/codegen.js

···
         capture: true,
       })}
 
-      ${_node}.tag = ${name};
+      if (${name}) ${_node}.tag = ${name};
       return ${transform ? js`(${transform})(${_node})` : _node};
     })
   `;

src/core.test.js

···
   }
 };
 
+describe('can create nameless matchers', () => {
+  it('matches without tagging', () => {
+    const state = { quasis: ['1'], expressions: [], x: 0, y: 0 };
+    const node = match(null)`${/1/}`;
+    expect(node(state)).toEqual(['1']);
+  });
+});
+
 describe('required matcher', () => {
   const node = match('node')`${/1/}`;
   it.each`