sebmck/6to5

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

Open

// @flow

/*:: declare var invariant; */

import type { TokenType } from "../../tokenizer/types";

Function parseMaybeAssign has 56 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    parseMaybeAssign(...args): N.Expression {
      // Note: When the JSX plugin is on, type assertions (`<T> x`) aren't valid syntax.

      let state: ?State;
      let jsx;

Function tsParseNonArrayType has 54 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    tsParseNonArrayType(): N.TsType {
      switch (this.state.type) {
        case tt.name:
        case tt._void:
        case tt._null: {

Function tsParseDeclaration has 48 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    tsParseDeclaration(
      node: any,
      value: string,
      next: boolean,
    ): ?N.Declaration {

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

Open

    parseSubscript(
      base: N.Expression,
      startPos: number,
      startLoc: Position,
      noCalls: ?boolean,

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

Open

    tsParseTypeOrTypePredicateAnnotation(
      returnToken: TokenType,
    ): N.TsTypeAnnotation {
      return this.tsInType(() => {
        const t: N.TsTypeAnnotation = this.startNode();

Function tsTryParseDeclare has 35 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    tsTryParseDeclare(nany: any): ?N.Declaration {
      if (this.isLineTerminator()) {
        return;
      }
      let starttype = this.state.type;

Function tsSkipParameterStart has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    tsSkipParameterStart(): boolean {
      if (this.match(tt.name) || this.match(tt._this)) {
        this.next();
        return true;
      }

Function result has 30 lines of code (exceeds 25 allowed). Consider refactoring.

Open

        const result = this.tsTryParseAndCatch(() => {
          if (!noCalls && this.atPossibleAsyncArrow(base)) {
            // Almost certainly this is a generic async function `async <T>() => ...
            // But it might be a call with a type argument `async<T>();`
            const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(

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

Open

    tsTryParseGenericAsyncArrowFunction(
      startPos: number,
      startLoc: Position,
    ): ?N.ArrowFunctionExpression {
      if (!this.isRelational("<")) {

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

Open

    parseAssignableListItem(
      allowModifiers: ?boolean,
      decorators: N.Decorator[],
    ): N.Pattern | N.TSParameterProperty {
      // Store original location/position to include modifiers in range

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

Open

    parseImport(node: N.Node): N.AnyImport {
      if (this.match(tt.name) || this.match(tt.star) || this.match(tt.braceL)) {
        const ahead = this.lookahead();

        if (this.match(tt.name) && ahead.type === tt.eq) {

Function parseExprOp has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    parseExprOp(
      left: N.Expression,
      leftStartPos: number,
      leftStartLoc: Position,
      minPrec: number,

Function parseClassMemberWithIsStatic has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

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

Avoid too many return statements within this function.

Open

            return this.tsParseAmbientExternalModuleDeclaration(nany);

Avoid too many return statements within this function.

Open

            return this.tsParseModuleOrNamespaceDeclaration(node);

Avoid too many return statements within this function.

Open

            return this.tsParseDeclaration(nany, value, /* next */ true);

Avoid too many return statements within this function.

Open

            return this.tsParseModuleOrNamespaceDeclaration(node);

Avoid too many return statements within this function.

Open

        return arrow.node;

Avoid too many return statements within this function.

Open

        return typeCast.node;

Avoid too many return statements within this function.

Open

            return this.tsParseTypeAliasDeclaration(node);

Avoid too many return statements within this function.

Open

        return jsx.node;

Avoid too many return statements within this function.

Open

      return this.tsParsePropertyOrMethodSignature(node, readonly);

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

Open

      if (this.match(tt.braceL)) {
        let braceStackCounter = 1;
        this.next();

        while (braceStackCounter > 0) {

• Read up
  Read up

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

Open

      if (this.match(tt.bracketL)) {
        let braceStackCounter = 1;
        this.next();

        while (braceStackCounter > 0) {

• Read up
  Read up

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

Open

    typeCastToParameter(node: N.TsTypeCastExpression): N.Node {
      node.expression.typeAnnotation = node.typeAnnotation;

      this.resetEndLocation(
        node.expression,

• Read up
  Read up

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

Open

      if (this.eat(tt.question)) {
        if (param.type !== "Identifier") {
          this.raise(param.start, TSErrors.PatternIsOptional);
        }

• Read up
  Read up

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

Open

      } else {
        this.scope.enter(SCOPE_TS_MODULE);
        this.prodParam.enter(PARAM);
        node.body = this.tsParseModuleBlock();
        this.prodParam.exit();

• Read up
  Read up

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

Open

      if (this.match(tt.braceL)) {
        this.scope.enter(SCOPE_TS_MODULE);
        this.prodParam.enter(PARAM);
        node.body = this.tsParseModuleBlock();
        this.prodParam.exit();

• Read up
  Read up

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

Open

        if (context[context.length - 1] === ct.j_oTag) {
          context.length -= 2;
        } else if (context[context.length - 1] === ct.j_expr) {
          context.length -= 1;
        }

• Read up
  Read up

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

Open

      if (
        node.type === "AssignmentPattern" &&
        node.typeAnnotation &&
        node.right.start < node.typeAnnotation.start
      ) {

• Read up
  Read up

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

Open

    tsInType<T>(cb: () => T): T {
      const oldInType = this.state.inType;
      this.state.inType = true;
      try {
        return cb();

• Read up
  Read up

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

Open

          this.match(tt.colon) ||
          this.match(tt.comma) ||
          this.match(tt.question) ||
          this.match(tt.eq)

• Read up
  Read up

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

Open

      if ((methodOrProp: any).readonly && this.match(tt.parenL)) {
        this.raise(methodOrProp.start, TSErrors.ClassMethodHasReadonly);
      }

• Read up
  Read up

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

Open

      if ((methodOrProp: any).declare && this.match(tt.parenL)) {
        this.raise(methodOrProp.start, TSErrors.ClassMethodHasDeclare);
      }

• Read up
  Read up

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

Open

        case "type":
          if (this.tsCheckLineTerminatorAndMatch(tt.name, next)) {
            if (next) this.next();
            return this.tsParseTypeAliasDeclaration(node);
          }

• Read up
  Read up

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

Open

        case "namespace":
          if (this.tsCheckLineTerminatorAndMatch(tt.name, next)) {
            if (next) this.next();
            return this.tsParseModuleOrNamespaceDeclaration(node);
          }

• Read up
  Read up

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

Open

        case "interface":
          if (this.tsCheckLineTerminatorAndMatch(tt.name, next)) {
            if (next) this.next();
            return this.tsParseInterfaceDeclaration(node);
          }

• Read up
  Read up

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

Open

      if (this.eat(tt.question)) {
        node.optional = true;
        // Include questionmark in location of node
        // Don't use this.finishNode() as otherwise we might process comments twice and
        // include already consumed parens

• Read up
  Read up

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

Open

      if (!result.node) {
        // $FlowIgnore
        refNeedsArrowPos.start = result.error.pos || this.state.start;
        return expr;
      }

• Read up
  Read up

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

Open

        if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
          this.raise(pp.start, TSErrors.UnsupportedParameterPropertyKind);
        }

• Read up
  Read up

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

Open

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

• Read up
  Read up

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

Open

          if (
            pattern.type !== "Identifier" &&
            pattern.type !== "RestElement" &&
            pattern.type !== "ObjectPattern" &&
            pattern.type !== "ArrayPattern"

• Read up
  Read up

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

Open

      if (this.match(tt.name) || this.match(tt.star) || this.match(tt.braceL)) {
        const ahead = this.lookahead();

        if (this.match(tt.name) && ahead.type === tt.eq) {
          return this.tsParseImportEqualsDeclaration(node);

• Read up
  Read up

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

Open

      if (
        importNode.importKind === "type" &&
        importNode.specifiers.length > 1 &&
        importNode.specifiers[0].type === "ImportDefaultSpecifier"
      ) {

• Read up
  Read up