Babel Plugin Transform ES2015 Destructuring

// Plugin registration (internal usage)
export default function ({ types: t }) { ... }

{
  "plugins": ["transform-es2015-destructuring"]
}

babel --plugins transform-es2015-destructuring script.js

require("babel-core").transform("code", {
  plugins: ["transform-es2015-destructuring"]
});

/**
 * Creates a Babel plugin for transforming ES2015 destructuring syntax
 * @param {Object} babel - Babel instance with types API
 * @param {Object} babel.types - Babel types API for AST manipulation
 * @returns {Object} Plugin object with visitor methods
 */
function transformES2015Destructuring({ types: t });

/**
 * Transforms destructuring in export named declarations
 * @param {Object} path - Babel path object for the ExportNamedDeclaration node
 */
ExportNamedDeclaration(path);

/**
 * Transforms destructuring in for-in and for-of statements
 * @param {Object} path - Babel path object for the ForXStatement node
 * @param {Object} file - Babel file object for the current file being processed
 */
ForXStatement(path, file);

/**
 * Transforms destructuring in catch clause parameters
 * @param {Object} pathInfo - Destructured path information containing node and scope
 * @param {Object} pathInfo.node - The CatchClause AST node
 * @param {Object} pathInfo.scope - Babel scope object for the catch clause
 * @param {Object} file - Babel file object for the current file being processed
 */
CatchClause({ node, scope }, file);

/**
 * Transforms destructuring in assignment expressions
 * @param {Object} path - Babel path object for the AssignmentExpression node
 * @param {Object} file - Babel file object for the current file being processed
 */
AssignmentExpression(path, file);

/**
 * Transforms destructuring in variable declarations
 * @param {Object} path - Babel path object for the VariableDeclaration node
 * @param {Object} file - Babel file object for the current file being processed
 */
VariableDeclaration(path, file);

/**
 * Core class for transforming destructuring patterns into ES5-compatible code
 */
class DestructuringTransformer {
  /**
   * Creates a new DestructuringTransformer instance
   * @param {Object} opts - Configuration options
   * @param {number} opts.blockHoist - Block hoisting level for generated statements
   * @param {string} opts.operator - Assignment operator for transformations
   * @param {Array} opts.nodes - Array to collect generated AST nodes (defaults to empty array)
   * @param {Object} opts.scope - Babel scope object for variable management
   * @param {Object} opts.file - Babel file object for helper access
   * @param {string} opts.kind - Variable declaration kind ('var', 'let', 'const')
   * 
   * @description The constructor also initializes an internal arrays property for tracking array references
   */
  constructor(opts);

  /**
   * Builds a variable assignment or expression statement
   * @param {Object} id - AST node for the assignment target
   * @param {Object} init - AST node for the assignment value
   * @returns {Object} AST node for the variable assignment
   */
  buildVariableAssignment(id, init);

  /**
   * Builds a variable declaration with 'var' kind
   * @param {Object} id - AST node for the variable identifier
   * @param {Object} init - AST node for the variable initializer
   * @returns {Object} AST node for the variable declaration
   * @note Always uses "var" kind regardless of the constructor's kind parameter
   */
  buildVariableDeclaration(id, init);

  /**
   * Dispatches pattern processing to appropriate handler method
   * @param {Object} id - AST node for the destructuring pattern
   * @param {Object} init - AST node for the destructuring source
   */
  push(id, init);

  /**
   * Converts expression to array form for iteration
   * @param {Object} node - AST node to convert to array
   * @param {number} count - Optional count for array conversion optimization
   * @returns {Object} AST node representing array conversion
   */
  toArray(node, count);

  /**
   * Handles assignment patterns with default values
   * @param {Object} pattern - AssignmentPattern AST node
   * @param {Object} valueRef - AST node for the value reference
   */
  pushAssignmentPattern(pattern, valueRef);

  /**
   * Handles object rest properties in destructuring
   * @param {Object} pattern - ObjectPattern AST node
   * @param {Object} objRef - AST node for the object reference
   * @param {Object} spreadProp - RestProperty AST node
   * @param {number} spreadPropIndex - Index of the rest property
   */
  pushObjectRest(pattern, objRef, spreadProp, spreadPropIndex);

  /**
   * Processes individual object properties in destructuring
   * @param {Object} prop - Property AST node from ObjectPattern
   * @param {Object} propRef - AST node for the property reference
   */
  pushObjectProperty(prop, propRef);

  /**
   * Handles complete object destructuring patterns
   * @param {Object} pattern - ObjectPattern AST node
   * @param {Object} objRef - AST node for the object reference
   */
  pushObjectPattern(pattern, objRef);

  /**
   * Determines if array pattern can be optimally unpacked
   * @param {Object} pattern - ArrayPattern AST node
   * @param {Object} arr - ArrayExpression AST node
   * @returns {boolean} True if unpacking optimization is safe
   * @note Source code contains a bug at line 209: missing return false statement
   */
  canUnpackArrayPattern(pattern, arr);

  /**
   * Optimally processes array patterns that can be unpacked
   * @param {Object} pattern - ArrayPattern AST node
   * @param {Object} arr - ArrayExpression AST node
   */
  pushUnpackedArrayPattern(pattern, arr);

  /**
   * Handles array destructuring patterns
   * @param {Object} pattern - ArrayPattern AST node
   * @param {Object} arrayRef - AST node for the array reference
   */
  pushArrayPattern(pattern, arrayRef);

  /**
   * Initializes the destructuring transformation process
   * @param {Object} pattern - Destructuring pattern AST node
   * @param {Object} ref - Reference AST node for the destructuring source
   * @returns {Array} Array of generated AST nodes for the transformation
   */
  init(pattern, ref);
}

/**
 * Tests if a VariableDeclaration contains any destructuring patterns
 * @param {Object} node - VariableDeclaration AST node to test
 * @returns {boolean} True if the declaration contains destructuring patterns
 */
function variableDeclarationHasPattern(node);

/**
 * Tests if an ArrayPattern contains any RestElements
 * @param {Object} pattern - ArrayPattern AST node to test
 * @returns {boolean} True if the pattern contains rest elements
 */
function hasRest(pattern);

/**
 * Internal visitor for detecting variable references during array unpacking optimization
 * Used to determine if array destructuring can be safely optimized to direct element access
 */
const arrayUnpackVisitor = {
  /**
   * Checks for referenced identifiers that would prevent array unpacking optimization
   * @param {Object} path - Babel path object for the ReferencedIdentifier node
   * @param {Object} state - State object containing bindings and deopt flag
   * @param {Object} state.bindings - Object mapping variable names to binding information
   * @param {boolean} state.deopt - Flag indicating if optimization should be disabled
   */
  ReferencedIdentifier(path, state);
};

var { x, y } = coords;

var x = coords.x,
    y = coords.y;

const [first, second] = arr;

var _arr = arr;
var first = _arr[0];
var second = _arr[1];

const { a = 1, b = 2 } = obj;

var _obj = obj;
var a = _obj.a === undefined ? 1 : _obj.a;
var b = _obj.b === undefined ? 2 : _obj.b;

const { a, ...rest } = obj;

var _obj = obj;
var a = _obj.a;
var rest = _objectWithoutProperties(_obj, ["a"]);

const { user: { name, age } } = data;

var _data = data;
var _user = _data.user;
var name = _user.name;
var age = _user.age;