public moveNext()

in src/language/json/JSON.ts [406:559]
123 lines of code
36 McCabe index (conditional complexity)

    public moveNext(): boolean {
        if (!this.hasStarted()) {
            this.moveNextBasicToken();
        } else if (this.current) {
            this._currentTokenStartIndex += this.current.length();
        }

        this._current = undefined;
        if (this.currentBasicToken()) {
            switch (this.currentBasicTokenType()) {
                case basic.TokenType.LeftCurlyBracket:
                    assert.deepStrictEqual(this.currentBasicTokenType(), basic.TokenType.LeftCurlyBracket);
                    this._current = LeftCurlyBracket(this._currentTokenStartIndex);
                    this.moveNextBasicToken();
                    break;

                case basic.TokenType.RightCurlyBracket:
                    this._current = RightCurlyBracket(this._currentTokenStartIndex);
                    this.moveNextBasicToken();
                    break;

                case basic.TokenType.LeftSquareBracket:
                    this._current = LeftSquareBracket(this._currentTokenStartIndex);
                    this.moveNextBasicToken();
                    break;

                case basic.TokenType.RightSquareBracket:
                    this._current = RightSquareBracket(this._currentTokenStartIndex);
                    this.moveNextBasicToken();
                    break;

                case basic.TokenType.Comma:
                    this._current = Comma(this._currentTokenStartIndex);
                    this.moveNextBasicToken();
                    break;

                case basic.TokenType.Colon:
                    this._current = Colon(this._currentTokenStartIndex);
                    this.moveNextBasicToken();
                    break;

                case basic.TokenType.Dash:
                case basic.TokenType.Digits:
                    this._current = Number(this._currentTokenStartIndex, readNumber(this.asBasicTokenIterator()));
                    break;

                case basic.TokenType.ForwardSlash:
                    this.moveNextBasicToken();
                    if (!this.currentBasicToken()) {
                        this._current = Literal(this._currentTokenStartIndex, [basic.ForwardSlash]);
                    } else {
                        switch (this.currentBasicTokenType()) {
                            case basic.TokenType.ForwardSlash:
                                const lineCommentBasicTokens: basic.Token[] = [basic.ForwardSlash, basic.ForwardSlash];
                                while (this.moveNextBasicToken()
                                    && this.currentBasicTokenType() !== basic.TokenType.NewLine
                                    && this.currentBasicTokenType() !== basic.TokenType.CarriageReturnNewLine
                                ) {
                                    // tslint:disable-next-line: no-non-null-assertion // guaranteed by this.moveNextBasicToken() return value in while
                                    lineCommentBasicTokens.push(this.currentBasicToken()!);
                                }
                                this._current = Comment(this._currentTokenStartIndex, lineCommentBasicTokens);
                                this._commentsCount++;
                                break;

                            case basic.TokenType.Asterisk:
                                const blockCommentBasicTokens: basic.Token[] = [basic.ForwardSlash, basic.Asterisk];
                                this.moveNextBasicToken();

                                while (this.currentBasicToken()) {
                                    // tslint:disable-next-line: no-non-null-assertion // Validated by while
                                    blockCommentBasicTokens.push(this.currentBasicToken()!);

                                    if (this.currentBasicTokenType() === basic.TokenType.Asterisk) {
                                        this.moveNextBasicToken();

                                        if (this.currentBasicTokenType() === basic.TokenType.ForwardSlash) {
                                            // tslint:disable-next-line: no-non-null-assertion // Guaranteed by if
                                            blockCommentBasicTokens.push(this.currentBasicToken()!);
                                            this.moveNextBasicToken();
                                            break;
                                        }
                                    } else {
                                        this.moveNextBasicToken();
                                    }
                                }

                                this._current = Comment(this._currentTokenStartIndex, blockCommentBasicTokens);
                                this._commentsCount++;
                                break;

                            default:
                                this._current = Literal(this._currentTokenStartIndex, [basic.ForwardSlash]);
                                break;
                        }
                    }
                    break;

                case basic.TokenType.Space:
                case basic.TokenType.Tab:
                case basic.TokenType.CarriageReturn:
                case basic.TokenType.NewLine:
                case basic.TokenType.CarriageReturnNewLine:
                    this._current = Whitespace(this._currentTokenStartIndex, readWhitespace(this.asBasicTokenIterator()));
                    break;

                case basic.TokenType.SingleQuote:
                case basic.TokenType.DoubleQuote:
                    this._current = QuotedString(this._currentTokenStartIndex, readQuotedString(this.asBasicTokenIterator()));
                    break;

                case basic.TokenType.Letters:
                    // tslint:disable-next-line: no-non-null-assertion // Validated by if
                    switch (this.currentBasicToken()!.toString()) {
                        case "true":
                        case "false":
                            // tslint:disable-next-line: no-non-null-assertion // Validated by if
                            this._current = Boolean(this._currentTokenStartIndex, this.currentBasicToken()!);
                            this.moveNextBasicToken();
                            break;

                        case "null":
                            this._current = Null(this._currentTokenStartIndex);
                            this.moveNextBasicToken();
                            break;

                        default:
                            // tslint:disable-next-line: no-non-null-assertion // Validated by if
                            const literalTokens: basic.Token[] = [this.currentBasicToken()!];
                            this.moveNextBasicToken();

                            while (this.currentBasicToken() &&
                                (this.currentBasicTokenType() === basic.TokenType.Letters ||
                                    this.currentBasicTokenType() === basic.TokenType.Underscore)) {
                                // tslint:disable-next-line: no-non-null-assertion // Validated by if
                                literalTokens.push(this.currentBasicToken()!);
                                this.moveNextBasicToken();
                            }

                            this._current = Literal(this._currentTokenStartIndex, literalTokens);
                            break;
                    }
                    break;

                default:
                    // tslint:disable-next-line: no-non-null-assertion // Validated by if
                    this._current = Unrecognized(this._currentTokenStartIndex, this.currentBasicToken()!);
                    this.moveNextBasicToken();
                    break;
            }
        }

        return !!this.current;
    }