code: function _guessExecutionStatusRelativeTo(target) {
    // check if the two paths are in different functions, we can't track execution of these
    var targetFuncParent = target.scope.getFunctionParent();
    var selfFuncParent = this.scope.getFunctionParent();
    if (targetFuncParent !== selfFuncParent) {
      return "function";
    }
  
    var targetPaths = target.getAncestry();
    //if (targetPaths.indexOf(this) >= 0) return "after";
  
    var selfPaths = this.getAncestry();
  
    // get ancestor where the branches intersect
    var commonPath;
    var targetIndex;
    var selfIndex;
    for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
      var selfPath = selfPaths[selfIndex];
      targetIndex = targetPaths.indexOf(selfPath);
      if (targetIndex >= 0) {
        commonPath = selfPath;
        break;
      }
    }
    if (!commonPath) {
      return "before";
    }
  
    // get the relationship paths that associate these nodes to their common ancestor
    var targetRelationship = targetPaths[targetIndex - 1];
    var selfRelationship = selfPaths[selfIndex - 1];
    if (!targetRelationship || !selfRelationship) {
      return "before";
    }
  
    // container list so let's see which one is after the other
    if (targetRelationship.listKey && targetRelationship.container === selfRelationship.container) {
      return targetRelationship.key > selfRelationship.key ? "before" : "after";
    }
  
    // otherwise we're associated by a parent node, check which key comes before the other
    var targetKeyPosition = t.VISITOR_KEYS[targetRelationship.type].indexOf(targetRelationship.key);
    var selfKeyPosition = t.VISITOR_KEYS[selfRelationship.type].indexOf(selfRelationship.key);
    return targetKeyPosition > selfKeyPosition ? "before" : "after";
  }
docs: Given a `target` check the execution status of it relative to the current path.
  
  "Execution status" simply refers to where or not we **think** this will execuete
  before or after the input `target` element.