Function pushTask has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.

Open

function pushTask(taskName, taskDir, suite, suiteName) {
  const taskDirStats = fs.statSync(taskDir);
  let actualLoc = findFile(taskDir + "/input");
  let execLoc = findFile(taskDir + "/exec");

• Read up
  Read up

Function parseStatementContent has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.

Open

  parseStatementContent(context: ?string, topLevel: ?boolean): N.Statement {
    let starttype = this.state.type;
    const node = this.startNode();
    let kind;

• Read up
  Read up

Function parseExprAtom has a Cognitive Complexity of 44 (exceeds 5 allowed). Consider refactoring.

Open

  parseExprAtom(refExpressionErrors?: ?ExpressionErrors): N.Expression {
    // If a division operator appears in an expression position, the
    // tokenizer got confused, and we force it to read a regexp instead.
    if (this.state.type === tt.slash) this.readRegexp();

• Read up
  Read up

Function getTokenFromCode has 162 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  getTokenFromCode(code: number): void {
    switch (code) {
      // The interpretation of a dot depends on whether it is followed
      // by a digit or another two dots.

Function _generateImport has 162 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  _generateImport(opts, importName) {
    const isDefault = importName === "default";
    const isNamed = !!importName && !isDefault;
    const isNamespace = importName === null;

Function gatherSequenceExpressions has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.

Open

export default function gatherSequenceExpressions(
  nodes: Array<Object>,
  scope: Scope,
  declars: Array<Object>,
): ?Object {

• Read up
  Read up

Function _resolve has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.

Open

export function _resolve(dangerous?, resolved?): ?NodePath {
  // detect infinite recursion
  // todo: possibly have a max length on this just to be safe
  if (resolved && resolved.indexOf(this) >= 0) return;

• Read up
  Read up

Function explode has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.

Open

export function explode(visitor) {
  if (visitor._exploded) return visitor;
  visitor._exploded = true;

  // normalise pipes

• Read up
  Read up

Function flowParsePrimaryType has 160 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    flowParsePrimaryType(): N.FlowTypeAnnotation {
      const startPos = this.state.start;
      const startLoc = this.state.startLoc;
      const node = this.startNode();
      let tmp;

File printer.js has 430 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import isInteger from "lodash/isInteger";
import repeat from "lodash/repeat";
import Buffer from "./buffer";
import * as n from "./node";
import * as t from "@babel/types";

Function _visitTypeAnnotation has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.

Open

  _visitTypeAnnotation(node) {
    if (!node) {
      return;
    }
    if (Array.isArray(node)) {

• Read up
  Read up

Function readInt has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.

Open

  readInt(
    radix: number,
    len?: number,
    forceLen?: boolean,
    allowNumSeparator: boolean = true,

• Read up
  Read up

Function gatherNodeParts has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.

Open

function gatherNodeParts(node: Object, parts: Array) {
  switch (node?.type) {
    default:
      if (t.isModuleDeclaration(node)) {
        if (node.source) {

• Read up
  Read up

Tokenizer has 45 functions (exceeds 20 allowed). Consider refactoring.

Open

export default class Tokenizer extends ParserErrors {
  // Forward-declarations
  // parser/util.js
  /*::
  +unexpected: (pos?: ?number, messageOrType?: string | TokenType) => empty;

Function parseClassMemberWithIsStatic has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.

Open

  parseClassMemberWithIsStatic(
    classBody: N.ClassBody,
    member: N.ClassMember,
    state: { hadConstructor: boolean },
    isStatic: boolean,

• Read up
  Read up

Function checkLVal has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.

Open

  checkLVal(
    expr: Expression,
    bindingType: BindingTypes = BIND_NONE,
    checkClashes: ?{ [key: string]: boolean },
    contextDescription: string,

• Read up
  Read up

Function isNodesEquivalent has a Cognitive Complexity of 39 (exceeds 5 allowed). Consider refactoring.

Open

export default function isNodesEquivalent(a: any, b: any): boolean {
  if (
    typeof a !== "object" ||
    typeof b !== "object" ||
    a == null ||

• Read up
  Read up

File built-in-definitions.js has 413 lines of code (exceeds 250 allowed). Consider refactoring.

Open

// @flow

type ObjectMap<V> = { [name: string]: V };

const ArrayNatureIterators = [

Function default has a Cognitive Complexity of 38 (exceeds 5 allowed). Consider refactoring.

Open

export default async function ({
  cliOptions,
  babelOptions,
}: CmdOptions): Promise<void> {
  function buildResult(fileResults: Array<Object>): CompilationOutput {

• Read up
  Read up

Consider simplifying this complex logical expression.

Open

  if (
    nodeType === "Scopable" ||
    "BlockStatement" === nodeType ||
    "CatchClause" === nodeType ||
    "DoWhileStatement" === nodeType ||