Infinite loop when parsing case

[adamziel]

When I try to parse this code fragment, the documentation blocks page hangs – as if the parser entered an infinite loop:

 case "${TEST_PROFILE-}" in
    *"/.bashrc" | *"/.bash_profile" | *"/.zshrc" | *"/.zprofile")
      return
    ;;
esac

[Bobb56]

Here is how I changed the code to make it work on my side:

fn parse_case_statement(&mut self) -> Node {
    self.next_token(); // Skip "case"

    // Parse the expression to match against - this should be a simple word or quoted string
    let expression = match &self.current_token.kind {
        TokenKind::Word(word) => {
            let expr = Node::StringLiteral(word.clone());
            self.next_token();
            expr
        }
        TokenKind::Quote => {
            // Handle quoted strings
            self.parse_quoted_string(TokenKind::Quote)
        }
        TokenKind::CmdSubst => {
            // Handle command substitution
            self.parse_command_substitution()
        }
        _ => {
            // Fallback to parsing as a condition
            self.parse_condition_until_token_kind(TokenKind::In)
        }
    };

    // Expect "in" keyword
    if self.current_token.kind == TokenKind::In {
        self.next_token(); // Skip "in"
    }

    let mut patterns = Vec::new();

    // Parse case patterns until we hit "esac"
    while self.current_token.kind != TokenKind::Esac
        && self.current_token.kind != TokenKind::EOF
    {
        // Skip any newlines or whitespace
        while self.current_token.kind == TokenKind::Newline {
            self.next_token();
        }

        if self.current_token.kind == TokenKind::Esac {
            break;
        }

        // Parse pattern(s) - can be multiple patterns separated by |
        let mut pattern_list = Vec::new();

        // Loop over the patterns
        while self.current_token.kind != TokenKind::RParen {
            // Skip the pipe if there is one
            if self.current_token.kind == TokenKind::Pipe {
                self.next_token(); // Skip |
            }
            
            let mut pattern = String::new();
            while self.current_token.kind != TokenKind::Pipe && self.current_token.kind != TokenKind::RParen {
                pattern += &self.current_token.value;
                self.next_token();
            }
            pattern_list.push(pattern);
        }

        // Expect )
        if self.current_token.kind == TokenKind::RParen {
            self.next_token(); // Skip )
        }

        // Skip any newlines
        while self.current_token.kind == TokenKind::Newline {
            self.next_token();
        }

        // Parse the body until we hit ;; or esac
        // Use a simpler approach - parse until we hit ;; or esac
        let mut body_statements = Vec::new();
        let mut body_operators = Vec::new();

        while self.current_token.kind != TokenKind::DoubleSemicolon
            && self.current_token.kind != TokenKind::Esac
            && self.current_token.kind != TokenKind::EOF
        {
            if let Some(statement) = self.parse_statement() {
                body_statements.push(statement);

                // Handle operators between statements
                if self.current_token.kind == TokenKind::Semicolon {
                    body_operators.push(";".to_string());
                    self.next_token();
                } else if self.current_token.kind == TokenKind::Newline {
                    body_operators.push("\n".to_string());
                    self.next_token();
                }
            }
        }

        let body = if body_statements.len() == 1 && body_operators.is_empty() {
            body_statements.into_iter().next().unwrap()
        } else {
            Node::List {
                statements: body_statements,
                operators: body_operators,
            }
        };

        // Skip ;; if present
        if self.current_token.kind == TokenKind::DoubleSemicolon {
            self.next_token();
        }

        // Skip any newlines after ;;
        while self.current_token.kind == TokenKind::Newline {
            self.next_token();
        }

        if !pattern_list.is_empty() {
            patterns.push(CasePattern {
                patterns: pattern_list,
                body: Box::new(body),
            });
        }
    }

    // Skip "esac"
    if self.current_token.kind == TokenKind::Esac {
        self.next_token();
    }

    Node::CaseStatement {
        expression: Box::new(expression),
        patterns,
    }
}

I don't know if it works in any cases but it works better than before.