[Validation] Parallelize validation rules.

This provides a performance improvement and simplification to the validator by providing two new generic visitor utilities. One for tracking a TypeInfo instance alongside a visitor instance, and another for stepping through multiple visitors in parallel. The two can be composed together.

Rather than 23 passes of AST visitation with one rule each, this now performs one pass of AST visitation with 23 rules. Since visitation is costly but rules are inexpensive, this nets out to a much faster overall validation, especially noticable for very large queries.

Author: leebyron

src/language/visitor.js

@@ -208,7 +208,7 @@ export function visit(root, visitor, keyMap) {
       if (!isNode(node)) {
         throw new Error('Invalid AST Node: ' + JSON.stringify(node));
       }
-      var visitFn = getVisitFn(visitor, isLeaving, node.kind);
+      var visitFn = getVisitFn(visitor, node.kind, isLeaving);
       if (visitFn) {
         result = visitFn.call(visitor, node, key, parent, path, ancestors);
 
@@ -263,7 +263,83 @@ function isNode(maybeNode) {
   return maybeNode && typeof maybeNode.kind === 'string';
 }
 
-export function getVisitFn(visitor, isLeaving, kind) {
+
+/**
+ * Creates a new visitor instance which delegates to many visitors to run in
+ * parallel. Each visitor will be visited for each node before moving on.
+ *
+ * Visitors must not directly modify the AST nodes and only returning false to
+ * skip sub-branches is supported.
+ */
+export function visitInParallel(visitors) {
+  const skipping = new Array(visitors.length);
+
+  return {
+    enter(node) {
+      for (let i = 0; i < visitors.length; i++) {
+        if (!skipping[i]) {
+          const fn = getVisitFn(visitors[i], node.kind, /* isLeaving */ false);
+          if (fn) {
+            const result = fn.apply(visitors[i], arguments);
+            if (result === false) {
+              skipping[i] = node;
+            }
+          }
+        }
+      }
+    },
+    leave(node) {
+      for (let i = 0; i < visitors.length; i++) {
+        if (!skipping[i]) {
+          const fn = getVisitFn(visitors[i], node.kind, /* isLeaving */ true);
+          if (fn) {
+            fn.apply(visitors[i], arguments);
+          }
+        } else {
+          skipping[i] = null;
+        }
+      }
+    }
+  };
+}
+
+
+/**
+ * Creates a new visitor instance which maintains a provided TypeInfo instance
+ * along with visiting visitor.
+ *
+ * Visitors must not directly modify the AST nodes and only returning false to
+ * skip sub-branches is supported.
+ */
+export function visitWithTypeInfo(typeInfo, visitor) {
+  return {
+    enter(node) {
+      typeInfo.enter(node);
+      const fn = getVisitFn(visitor, node.kind, /* isLeaving */ false);
+      if (fn) {
+        const result = fn.apply(visitor, arguments);
+        if (result === false) {
+          typeInfo.leave(node);
+          return false;
+        }
+      }
+    },
+    leave(node) {
+      const fn = getVisitFn(visitor, node.kind, /* isLeaving */ true);
+      if (fn) {
+        fn.apply(visitor, arguments);
+      }
+      typeInfo.leave(node);
+    }
+  };
+}
+
+
+/**
+ * Given a visitor instance, if it is leaving or not, and a node kind, return
+ * the function the visitor runtime should call.
+ */
+function getVisitFn(visitor, kind, isLeaving) {
   var kindVisitor = visitor[kind];
   if (kindVisitor) {
     if (!isLeaving && typeof kindVisitor === 'function') {
@@ -275,18 +351,18 @@ export function getVisitFn(visitor, isLeaving, kind) {
       // { Kind: { enter() {}, leave() {} } }
       return kindSpecificVisitor;
     }
-    return;
-  }
-  var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
-  if (specificVisitor) {
-    if (typeof specificVisitor === 'function') {
-      // { enter() {}, leave() {} }
-      return specificVisitor;
-    }
-    var specificKindVisitor = specificVisitor[kind];
-    if (typeof specificKindVisitor === 'function') {
-      // { enter: { Kind() {} }, leave: { Kind() {} } }
-      return specificKindVisitor;
+  } else {
+    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
+    if (specificVisitor) {
+      if (typeof specificVisitor === 'function') {
+        // { enter() {}, leave() {} }
+        return specificVisitor;
+      }
+      var specificKindVisitor = specificVisitor[kind];
+      if (typeof specificKindVisitor === 'function') {
+        // { enter: { Kind() {} }, leave: { Kind() {} } }
+        return specificKindVisitor;
+      }
     }
   }
 }

src/validation/validate.js

@@ -10,7 +10,7 @@
 
 import invariant from '../jsutils/invariant';
 import { GraphQLError } from '../error';
-import { visit, getVisitFn } from '../language/visitor';
+import { visit, visitInParallel, visitWithTypeInfo } from '../language/visitor';
 import * as Kind from '../language/kinds';
 import type {
   Document,
@@ -74,47 +74,10 @@ export function visitUsingRules(
   documentAST: Document,
   rules: Array<any>
 ): Array<GraphQLError> {
-  var context = new ValidationContext(schema, documentAST, typeInfo);
-
-  function visitInstance(ast, instance) {
-    visit(ast, {
-      enter(node) {
-        // Collect type information about the current position in the AST.
-        typeInfo.enter(node);
-
-        // Get the visitor function from the validation instance, and if it
-        // exists, call it with the visitor arguments.
-        var enter = getVisitFn(instance, false, node.kind);
-        var result = enter ? enter.apply(instance, arguments) : undefined;
-
-        // If the result is "false", we're not visiting any descendent nodes,
-        // but need to update typeInfo.
-        if (result === false) {
-          typeInfo.leave(node);
-        }
-
-        return result;
-      },
-      leave(node) {
-        // Get the visitor function from the validation instance, and if it
-        // exists, call it with the visitor arguments.
-        var leave = getVisitFn(instance, true, node.kind);
-        var result = leave ? leave.apply(instance, arguments) : undefined;
-
-        // Update typeInfo.
-        typeInfo.leave(node);
-
-        return result;
-      }
-    });
-  }
-
+  const context = new ValidationContext(schema, documentAST, typeInfo);
+  const visitors = rules.map(rule => rule(context));
   // Visit the whole document with each instance of all provided rules.
-  var instances = rules.map(rule => rule(context));
-  instances.forEach(instance => {
-    visitInstance(documentAST, instance);
-  });
-
+  visit(documentAST, visitWithTypeInfo(typeInfo, visitInParallel(visitors)));
   return context.getErrors();
 }
 
@@ -233,19 +196,12 @@ export class ValidationContext {
     if (!usages) {
       usages = [];
       const typeInfo = new TypeInfo(this._schema);
-      visit(node, {
-        enter(subnode) {
-          typeInfo.enter(subnode);
-          if (subnode.kind === Kind.VARIABLE_DEFINITION) {
-            return false;
-          } else if (subnode.kind === Kind.VARIABLE) {
-            usages.push({ node: subnode, type: typeInfo.getInputType() });
-          }
-        },
-        leave(subnode) {
-          typeInfo.leave(subnode);
+      visit(node, visitWithTypeInfo(typeInfo, {
+        VariableDefinition: () => false,
+        Variable(variable) {
+          usages.push({ node: variable, type: typeInfo.getInputType() });
         }
-      });
+      }));
       this._variableUsages.set(node, usages);
     }
     return usages;