babel/babel

File index.js has 507 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import { declare } from "@babel/helper-plugin-utils";
import { types as t } from "@babel/core";

export default declare((api, options) => {
  api.assertVersion(7);

Function VariableDeclaration has 62 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      VariableDeclaration(path) {
        const { node, scope, parent } = path;
        if (t.isForXStatement(parent)) return;
        if (!parent || !path.container) return; // i don't know why this is necessary - TODO
        if (!variableDeclarationHasPattern(node)) return;

Function pushObjectPattern has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    pushObjectPattern(pattern, objRef) {
      // https://github.com/babel/babel/issues/681

      if (!pattern.properties.length) {
        this.nodes.push(

Function ForXStatement has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      ForXStatement(path) {
        const { node, scope } = path;
        const left = node.left;

        if (t.isPattern(left)) {

Function pushObjectRest has 38 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    pushObjectRest(pattern, objRef, spreadProp, spreadPropIndex) {
      // get all the keys that appear in this object before the current spread

      const keys = [];
      let allLiteral = true;

Function AssignmentExpression has 37 lines of code (exceeds 25 allowed). Consider refactoring.

Open

      AssignmentExpression(path) {
        const { node, scope } = path;
        if (!t.isPattern(node.left)) return;

        const nodes = [];

Function pushArrayPattern has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    pushArrayPattern(pattern, arrayRef) {
      if (!pattern.elements) return;

      // optimise basic array destructuring of an array expression
      //

Function pushAssignmentPattern has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    pushAssignmentPattern({ left, right }, valueRef) {
      // we need to assign the current value of the assignment to avoid evaluating
      // it more than once
      const tempId = this.scope.generateUidIdentifierBasedOnNode(valueRef);

Avoid too many return statements within this function.

Open

        if (t.isMemberExpression(elem)) return false;

Avoid too many return statements within this function.

Open

      return !state.deopt;

Avoid too many return statements within this function.

Open

        if (t.isSpreadElement(elem)) return false;

Avoid too many return statements within this function.

Open

        if (t.isCallExpression(elem)) return false;

Avoid too many return statements within this function.

Open

        if (t.isMemberExpression(elem)) return false;

Identical blocks of code found in 2 locations. Consider refactoring.

Open

        for (const name of Object.keys(path.getOuterBindingIdentifiers(path))) {
          specifiers.push(
            t.exportSpecifier(t.identifier(name), t.identifier(name)),
          );
        }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

          if (node.body.body.length === 0 && path.isCompletionRecord()) {
            node.body.body.unshift(
              t.expressionStatement(scope.buildUndefinedNode()),
            );
          }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        const destructuring = new DestructuringTransformer({
          kind: left.kind,
          scope: scope,
          nodes: nodes,
          arrayOnlySpread,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

        const destructuring = new DestructuringTransformer({
          operator: node.operator,
          scope: scope,
          nodes: nodes,
          arrayOnlySpread,

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      if (t.isPattern(pattern)) {
        this.push(pattern, objRef);
      } else {
        this.nodes.push(this.buildVariableAssignment(pattern, objRef));
      }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

      } else if (t.isAssignmentPattern(id)) {
        this.pushAssignmentPattern(id, init);
      } else {
        this.nodes.push(this.buildVariableAssignment(id, init));
      }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  function hasObjectRest(pattern) {
    for (const elem of (pattern.properties: Array)) {
      if (t.isRestElement(elem)) {
        return true;
      }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  function hasRest(pattern) {
    for (const elem of (pattern.elements: Array)) {
      if (t.isRestElement(elem)) {
        return true;
      }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

  function getExtendsHelper(file) {
    return useBuiltIns
      ? t.memberExpression(t.identifier("Object"), t.identifier("assign"))
      : file.addHelper("extends");
  }

• Read up
  Read up