Method parseComprehensionSpecs

internal/parser/parser.go:678–729

* parses for x in expr for y in expr if expr for z in expr ... */

(forToken *token, end tokenKind)

/* parses for x in expr for y in expr if expr for z in expr ... */
func (p *parser) parseComprehensionSpecs(forToken *token, end tokenKind) (*ast.ForSpec, *token, errors.StaticError) {
	var parseComprehensionSpecsHelper func(forToken *token, outer *ast.ForSpec) (*ast.ForSpec, *token, errors.StaticError)
	parseComprehensionSpecsHelper = func(forToken *token, outer *ast.ForSpec) (*ast.ForSpec, *token, errors.StaticError) {
		var ifSpecs []ast.IfSpec

		varID, popErr := p.popExpect(tokenIdentifier)
		if popErr != nil {
			return nil, nil, popErr
		}
		id := ast.Identifier(varID.data)
		inToken, err := p.popExpect(tokenIn)
		if err != nil {
			return nil, nil, err
		}
		arr, err := p.parse(iast.MaxPrecedence)
		if err != nil {
			return nil, nil, err
		}
		forSpec := &ast.ForSpec{
			ForFodder: forToken.fodder,
			VarFodder: varID.fodder,
			VarName:   id,
			InFodder:  inToken.fodder,
			Expr:      arr,
			Outer:     outer,
		}

		maybeIf := p.pop()
		for ; maybeIf.kind == tokenIf; maybeIf = p.pop() {
			cond, err := p.parse(iast.MaxPrecedence)
			if err != nil {
				return nil, nil, err
			}
			ifSpecs = append(ifSpecs, ast.IfSpec{
				IfFodder: maybeIf.fodder,
				Expr:     cond,
			})
		}
		forSpec.Conditions = ifSpecs
		if maybeIf.kind == end {
			return forSpec, maybeIf, nil
		}

		if maybeIf.kind != tokenFor {
			return nil, nil, errors.MakeStaticError(
				fmt.Sprintf("Expected for, if or %v after for clause, got: %v", end, maybeIf), maybeIf.loc)
		}

		return parseComprehensionSpecsHelper(maybeIf, forSpec)
	}
	return parseComprehensionSpecsHelper(forToken, nil)
}

// Assumes that the leading '[' has already been consumed and passed as tok.
// Should read up to and consume the trailing ']'