code: function isStorableFunction(funcNode, rhsNode) {
              let node = funcNode;
              let parent = funcNode.parent;
  
              while (parent && isInside(parent, rhsNode)) {
                  switch (parent.type) {
                      case "SequenceExpression":
                          if (parent.expressions[parent.expressions.length - 1] !== node) {
                              return false;
                          }
                          break;
  
                      case "CallExpression":
                      case "NewExpression":
                          return parent.callee !== node;
  
                      case "AssignmentExpression":
                      case "TaggedTemplateExpression":
                      case "YieldExpression":
                          return true;
  
                      default:
                          if (STATEMENT_TYPE.test(parent.type)) {
  
                              /*
                               * If it encountered statements, this is a complex pattern.
                               * Since analyzeing complex patterns is hard, this returns `true` to avoid false positive.
                               */
                              return true;
                          }
                  }
  
                  node = parent;
                  parent = parent.parent;
              }
  
              return false;
          }
docs: Checks whether a given function node is stored to somewhere or not.
  If the function node is stored, the function can be used later.
  
  @param {ASTNode} funcNode - A function node to check.
  @param {ASTNode} rhsNode - The RHS node of the previous assignment.
  @returns {boolean} `true` if under the following conditions:
  - the funcNode is assigned to a variable.
  - the funcNode is bound as an argument of a function call.
  - the function is bound to a property and the object satisfies above conditions.
  @private