code: function VariableDeclaration(node, parent, scope, file) {
      if (t.isForXStatement(parent)) return;
      if (!variableDeclarationHasPattern(node)) return;
  
      var nodes = [];
      var declar;
  
      for (var i = 0; i < node.declarations.length; i++) {
        declar = node.declarations[i];
  
        var patternId = declar.init;
        var pattern = declar.id;
  
        var destructuring = new DestructuringTransformer({
          nodes: nodes,
          scope: scope,
          kind: node.kind,
          file: file
        });
  
        if (t.isPattern(pattern)) {
          destructuring.init(pattern, patternId);
  
          if (+i !== node.declarations.length - 1) {
            // we aren't the last declarator so let's just make the
            // last transformed node inherit from us
            t.inherits(nodes[nodes.length - 1], declar);
          }
        } else {
          nodes.push(t.inherits(destructuring.buildVariableAssignment(declar.id, declar.init), declar));
        }
      }
  
      if (!t.isProgram(parent) && !t.isBlockStatement(parent)) {
        // https://github.com/babel/babel/issues/113
        // for (let [x] = [0]; false;) {}
  
        declar = null;
  
        for (i = 0; i < nodes.length; i++) {
          node = nodes[i];
          declar = declar || t.variableDeclaration(node.kind, []);
  
          if (!t.isVariableDeclaration(node) && declar.kind !== node.kind) {
            throw file.errorWithNode(node, messages.get("invalidParentForThisNode"));
          }
  
          declar.declarations = declar.declarations.concat(node.declarations);
        }
  
        return declar;
      }
  
      return nodes;
    }
docs: [Please add a description.]