Packages
caffeine_lang
4.6.4
6.3.1
6.3.0
6.2.2
6.2.1
6.2.0
6.1.2
6.1.1
6.1.0
6.0.0
5.6.0
5.5.0
5.4.4
5.4.3
5.4.2
5.4.1
5.4.0
5.3.0
5.2.0
5.1.1
5.1.0
5.0.12
5.0.11
5.0.10
5.0.8
5.0.7
5.0.6
5.0.5
5.0.4
5.0.1
5.0.0
4.10.0
4.9.0
4.8.3
4.8.2
4.8.1
4.8.0
4.7.9
4.7.8
4.7.7
4.7.6
4.7.5
4.6.7
4.6.6
4.6.5
4.6.4
4.6.3
4.6.2
4.6.0
4.5.1
4.5.0
4.4.4
4.4.3
4.4.1
4.4.0
4.3.7
4.3.6
3.0.6
3.0.5
3.0.4
3.0.3
3.0.2
3.0.1
3.0.0
2.0.5
2.0.4
2.0.3
2.0.2
2.0.1
2.0.0
1.0.2
1.0.1
0.1.0
0.0.24
0.0.23
0.0.22
0.0.21
0.0.20
0.0.19
0.0.18
0.0.17
0.0.16
0.0.15
0.0.14
0.0.13
0.0.12
0.0.11
0.0.10
0.0.9
0.0.8
0.0.7
0.0.6
0.0.5
0.0.4
0.0.2
0.0.1
A compiler for generating reliability artifacts from service expectation definitions.
Current section
Files
Jump to
Current section
Files
src/caffeine_lang@frontend@parser.erl
-module(caffeine_lang@frontend@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/caffeine_lang/frontend/parser.gleam").
-export([parse_blueprints_file/1, parse_expects_file/1]).
-export_type([parser_state/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
-type parser_state() :: {parser_state,
list(caffeine_lang@frontend@token:positioned_token()),
integer(),
integer(),
integer(),
integer()}.
-file("src/caffeine_lang/frontend/parser.gleam", 95).
?DOC(" Filter out whitespace tokens (keep comments in stream).\n").
-spec filter_whitespace(list(caffeine_lang@frontend@token:positioned_token())) -> list(caffeine_lang@frontend@token:positioned_token()).
filter_whitespace(Tokens) ->
gleam@list:filter(Tokens, fun(Ptok) -> case Ptok of
{positioned_token, whitespace_newline, _, _} ->
false;
{positioned_token, {whitespace_indent, _}, _, _} ->
false;
_ ->
true
end end).
-file("src/caffeine_lang/frontend/parser.gleam", 124).
?DOC(" Initialize parser state from a list of positioned tokens.\n").
-spec init_state(list(caffeine_lang@frontend@token:positioned_token())) -> parser_state().
init_state(Tokens) ->
case Tokens of
[{positioned_token, _, Line, Column} | _] ->
{parser_state, Tokens, Line, Column, Line, Column};
[] ->
{parser_state, Tokens, 1, 1, 1, 1}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 133).
?DOC(" Peek at the current token without consuming it.\n").
-spec peek(parser_state()) -> caffeine_lang@frontend@token:token().
peek(State) ->
case erlang:element(2, State) of
[{positioned_token, Tok, _, _} | _] ->
Tok;
[] ->
e_o_f
end.
-file("src/caffeine_lang/frontend/parser.gleam", 141).
?DOC(" Consume current token and advance state.\n").
-spec advance(parser_state()) -> parser_state().
advance(State) ->
case erlang:element(2, State) of
[_ | Rest] ->
case Rest of
[{positioned_token, _, Line, Column} | _] ->
{parser_state,
Rest,
Line,
Column,
erlang:element(3, State),
erlang:element(4, State)};
[] ->
{parser_state,
Rest,
erlang:element(3, State),
erlang:element(4, State),
erlang:element(3, State),
erlang:element(4, State)}
end;
[] ->
State
end.
-file("src/caffeine_lang/frontend/parser.gleam", 110).
-spec consume_comments_loop(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:comment()), parser_state()}.
consume_comments_loop(State, Acc) ->
case peek(State) of
{comment_line, Text} ->
consume_comments_loop(advance(State), [{line_comment, Text} | Acc]);
{comment_section, Text@1} ->
consume_comments_loop(
advance(State),
[{section_comment, Text@1} | Acc]
);
_ ->
{lists:reverse(Acc), State}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 106).
?DOC(" Consume consecutive comment tokens from the stream, returning them as Comment list.\n").
-spec consume_comments(parser_state()) -> {list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
consume_comments(State) ->
consume_comments_loop(State, []).
-file("src/caffeine_lang/frontend/parser.gleam", 166).
?DOC(" Expect a specific token, consuming it if matched.\n").
-spec expect(parser_state(), caffeine_lang@frontend@token:token(), binary()) -> {ok,
parser_state()} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
expect(State, Expected, Expected_name) ->
case peek(State) of
Tok when Tok =:= Expected ->
{ok, advance(State)};
Tok@1 ->
{error,
{unexpected_token,
Expected_name,
caffeine_lang@frontend@token:to_string(Tok@1),
erlang:element(5, State),
erlang:element(6, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 223).
?DOC(
" Check if current position is a type alias definition.\n"
" Looks for pattern: Identifier ( KeywordType )\n"
).
-spec is_type_alias(parser_state()) -> boolean().
is_type_alias(State) ->
case erlang:element(2, State) of
[{positioned_token, {identifier, _}, _, _},
{positioned_token, symbol_left_paren, _, _},
{positioned_token, keyword_type, _, _} |
_] ->
true;
_ ->
false
end.
-file("src/caffeine_lang/frontend/parser.gleam", 323).
-spec parse_extendable_kind(parser_state()) -> {ok,
{caffeine_lang@frontend@ast:extendable_kind(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_extendable_kind(State) ->
case peek(State) of
keyword_requires ->
{ok, {extendable_requires, advance(State)}};
keyword_provides ->
{ok, {extendable_provides, advance(State)}};
Tok ->
{error,
{unexpected_token,
<<"Type, Requires, or Provides"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 389).
?DOC(" Resolves an artifact name string to a ParsedArtifactRef.\n").
-spec resolve_artifact_ref(binary(), parser_state()) -> {ok,
caffeine_lang@frontend@ast:parsed_artifact_ref()} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
resolve_artifact_ref(Name, State) ->
case Name of
<<"SLO"/utf8>> ->
{ok, parsed_s_l_o};
<<"DependencyRelations"/utf8>> ->
{ok, parsed_dependency_relations};
_ ->
{error,
{unexpected_token,
<<"\"SLO\" or \"DependencyRelations\""/utf8>>,
<<<<"\""/utf8, Name/binary>>/binary, "\""/utf8>>,
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 362).
-spec parse_artifacts_loop(
parser_state(),
list(caffeine_lang@frontend@ast:parsed_artifact_ref())
) -> {ok,
{list(caffeine_lang@frontend@ast:parsed_artifact_ref()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_artifacts_loop(State, Acc) ->
case peek(State) of
symbol_plus ->
State@1 = advance(State),
case peek(State@1) of
{literal_string, Name} ->
gleam@result:'try'(
resolve_artifact_ref(Name, State@1),
fun(Ref) ->
State@2 = advance(State@1),
parse_artifacts_loop(State@2, [Ref | Acc])
end
);
Tok ->
{error,
{unexpected_token,
<<"artifact name"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State@1),
erlang:element(4, State@1)}}
end;
_ ->
{ok, {lists:reverse(Acc), State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 343).
-spec parse_artifacts(parser_state()) -> {ok,
{list(caffeine_lang@frontend@ast:parsed_artifact_ref()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_artifacts(State) ->
case peek(State) of
{literal_string, Name} ->
gleam@result:'try'(
resolve_artifact_ref(Name, State),
fun(Ref) ->
State@1 = advance(State),
parse_artifacts_loop(State@1, [Ref])
end
);
Tok ->
{error,
{unexpected_token,
<<"artifact name"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 457).
?DOC(" Skip tokens until the next block boundary (Blueprints, Expectations, or EOF).\n").
-spec skip_to_block_boundary(parser_state()) -> parser_state().
skip_to_block_boundary(State) ->
case peek(State) of
keyword_blueprints ->
State;
keyword_expectations ->
State;
e_o_f ->
State;
_ ->
skip_to_block_boundary(advance(State))
end.
-file("src/caffeine_lang/frontend/parser.gleam", 465).
?DOC(" Skip tokens until the next item boundary (*, block keyword, or EOF).\n").
-spec skip_to_item_boundary(parser_state()) -> parser_state().
skip_to_item_boundary(State) ->
case peek(State) of
symbol_star ->
State;
keyword_blueprints ->
State;
keyword_expectations ->
State;
e_o_f ->
State;
_ ->
skip_to_item_boundary(advance(State))
end.
-file("src/caffeine_lang/frontend/parser.gleam", 558).
?DOC(" Parse just the header of a blueprints block (Blueprints for \"artifact\").\n").
-spec parse_blueprints_block_header(parser_state()) -> {ok,
{list(caffeine_lang@frontend@ast:parsed_artifact_ref()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_blueprints_block_header(State) ->
gleam@result:'try'(
expect(State, keyword_blueprints, <<"Blueprints"/utf8>>),
fun(State@1) ->
gleam@result:'try'(
expect(State@1, keyword_for, <<"for"/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_artifacts(State@2),
fun(_use0) ->
{Artifacts, State@3} = _use0,
{ok, {Artifacts, State@3}}
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 750).
-spec parse_string_literal(parser_state()) -> {ok, {binary(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_string_literal(State) ->
case peek(State) of
{literal_string, S} ->
{ok, {S, advance(State)}};
Tok ->
{error,
{unexpected_token,
<<"string"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 690).
?DOC(" Parse just the header of an expects block (Expectations for \"blueprint\").\n").
-spec parse_expects_block_header(parser_state()) -> {ok,
{binary(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_expects_block_header(State) ->
gleam@result:'try'(
expect(State, keyword_expectations, <<"Expectations"/utf8>>),
fun(State@1) ->
gleam@result:'try'(
expect(State@1, keyword_for, <<"for"/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_string_literal(State@2),
fun(_use0) ->
{Blueprint, State@3} = _use0,
{ok, {Blueprint, State@3}}
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 799).
-spec parse_extends_list_loop(parser_state(), list(binary())) -> {ok,
{list(binary()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_extends_list_loop(State, Acc) ->
case peek(State) of
symbol_comma ->
State@1 = advance(State),
case peek(State@1) of
{identifier, Name} ->
State@2 = advance(State@1),
parse_extends_list_loop(State@2, [Name | Acc]);
Tok ->
{error,
{unexpected_token,
<<"identifier"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State@1),
erlang:element(4, State@1)}}
end;
_ ->
{ok, {lists:reverse(Acc), State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 780).
-spec parse_extends_list(parser_state()) -> {ok,
{list(binary()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_extends_list(State) ->
case peek(State) of
symbol_right_bracket ->
{ok, {[], State}};
{identifier, Name} ->
State@1 = advance(State),
parse_extends_list_loop(State@1, [Name]);
Tok ->
{error,
{unexpected_token,
<<"identifier"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 765).
-spec parse_optional_extends(parser_state()) -> {ok,
{list(binary()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_optional_extends(State) ->
case peek(State) of
keyword_extends ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_bracket, <<"["/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_extends_list(State@2),
fun(_use0) ->
{Extends, State@3} = _use0,
gleam@result:'try'(
expect(
State@3,
symbol_right_bracket,
<<"]"/utf8>>
),
fun(State@4) -> {ok, {Extends, State@4}} end
)
end
)
end
);
_ ->
{ok, {[], State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 921).
-spec parse_field(
parser_state(),
list(caffeine_lang@frontend@ast:comment()),
fun((parser_state()) -> {ok,
{caffeine_lang@frontend@ast:value(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()})
) -> {ok, {caffeine_lang@frontend@ast:field(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_field(State, Leading_comments, Parse_value) ->
case peek(State) of
{identifier, Name} ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_colon, <<":"/utf8>>),
fun(State@2) ->
gleam@result:'try'(
Parse_value(State@2),
fun(_use0) ->
{Value, State@3} = _use0,
{ok,
{{field, Name, Value, Leading_comments},
State@3}}
end
)
end
);
{literal_string, Name@1} ->
{error,
{quoted_field_name,
Name@1,
erlang:element(3, State),
erlang:element(4, State)}};
Tok ->
{error,
{unexpected_token,
<<"field name"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 893).
-spec parse_fields_loop(
parser_state(),
list(caffeine_lang@frontend@ast:field()),
list(caffeine_lang@frontend@ast:comment()),
fun((parser_state()) -> {ok,
{caffeine_lang@frontend@ast:value(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()})
) -> {ok,
{list(caffeine_lang@frontend@ast:field()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_fields_loop(State, Acc, Pending, Parse_value) ->
case peek(State) of
symbol_comma ->
State@1 = advance(State),
{Next_pending, State@2} = consume_comments(State@1),
case peek(State@2) of
symbol_right_brace ->
{ok, {lists:reverse(Acc), Next_pending, State@2}};
_ ->
gleam@result:'try'(
parse_field(State@2, Next_pending, Parse_value),
fun(_use0) ->
{Field, State@3} = _use0,
{Next_pending@1, State@4} = consume_comments(
State@3
),
parse_fields_loop(
State@4,
[Field | Acc],
Next_pending@1,
Parse_value
)
end
)
end;
_ ->
{ok, {lists:reverse(Acc), Pending, State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 868).
-spec parse_fields(
parser_state(),
list(caffeine_lang@frontend@ast:comment()),
fun((parser_state()) -> {ok,
{caffeine_lang@frontend@ast:value(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()})
) -> {ok,
{list(caffeine_lang@frontend@ast:field()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_fields(State, Pending, Parse_value) ->
case peek(State) of
symbol_right_brace ->
{ok, {[], Pending, State}};
{identifier, _} ->
gleam@result:'try'(
parse_field(State, Pending, Parse_value),
fun(_use0) ->
{Field, State@1} = _use0,
{Next_pending, State@2} = consume_comments(State@1),
parse_fields_loop(
State@2,
[Field],
Next_pending,
Parse_value
)
end
);
{literal_string, Name} ->
{error,
{quoted_field_name,
Name,
erlang:element(3, State),
erlang:element(4, State)}};
Tok ->
{error,
{unexpected_token,
<<"field name or }"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 853).
?DOC(" Generic struct parser parameterized by field value parser.\n").
-spec parse_struct(
parser_state(),
fun((parser_state()) -> {ok,
{caffeine_lang@frontend@ast:value(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()})
) -> {ok, {caffeine_lang@frontend@ast:struct(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_struct(State, Parse_value) ->
gleam@result:'try'(
expect(State, symbol_left_brace, <<"{"/utf8>>),
fun(State@1) ->
{Pending, State@2} = consume_comments(State@1),
gleam@result:'try'(
parse_fields(State@2, Pending, Parse_value),
fun(_use0) ->
{Fields, Trailing_comments, State@3} = _use0,
gleam@result:'try'(
expect(State@3, symbol_right_brace, <<"}"/utf8>>),
fun(State@4) ->
{ok, {{struct, Fields, Trailing_comments}, State@4}}
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1094).
?DOC(
" Parses types valid as Dict keys: String primitive or type alias ref.\n"
" Only String is allowed as a primitive key (JSON keys must be strings).\n"
).
-spec parse_dict_key_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_dict_key_type(State) ->
case peek(State) of
keyword_string ->
State@1 = advance(State),
{ok, {{parsed_primitive, string}, State@1}};
{identifier, Name} ->
case gleam_stdlib:string_starts_with(Name, <<"_"/utf8>>) of
true ->
State@2 = advance(State),
{ok, {{parsed_type_alias_ref, Name}, State@2}};
false ->
{error,
{unknown_type,
Name,
erlang:element(3, State),
erlang:element(4, State)}}
end;
Tok ->
{error,
{unknown_type,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1228).
-spec expect_x(parser_state()) -> {ok, parser_state()} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
expect_x(State) ->
case peek(State) of
keyword_x ->
{ok, advance(State)};
Tok ->
{error,
{invalid_refinement,
<<"expected 'x', got "/utf8,
(caffeine_lang@frontend@token:to_string(Tok))/binary>>,
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1363).
?DOC(" Convert a Literal to its string representation for use in refinements/defaults.\n").
-spec literal_to_string(caffeine_lang@frontend@ast:literal()) -> binary().
literal_to_string(Literal) ->
case Literal of
{literal_string, S} ->
S;
{literal_integer, N} ->
erlang:integer_to_binary(N);
{literal_float, F} ->
gleam_stdlib:float_to_string(F);
{literal_percentage, F@1} ->
<<(gleam_stdlib:float_to_string(F@1))/binary, "%"/utf8>>;
literal_true ->
<<"true"/utf8>>;
literal_false ->
<<"false"/utf8>>;
{literal_list, _} ->
<<"[]"/utf8>>;
{literal_struct, _, _} ->
<<"{}"/utf8>>
end.
-file("src/caffeine_lang/frontend/parser.gleam", 833).
?DOC(" Parses a struct with typed fields (for Requires blocks).\n").
-spec parse_type_struct(parser_state()) -> {ok,
{caffeine_lang@frontend@ast:struct(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_type_struct(State) ->
parse_struct(
State,
fun(S) ->
gleam@result:'try'(
parse_type(S),
fun(_use0) ->
{Type_, S@1} = _use0,
{ok, {{type_value, Type_}, S@1}}
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 950).
-spec parse_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_type(State) ->
case peek(State) of
keyword_string ->
parse_type_with_refinement(State, string);
keyword_integer ->
parse_type_with_refinement(State, {numeric_type, integer});
keyword_float ->
parse_type_with_refinement(State, {numeric_type, float});
keyword_boolean ->
parse_type_with_refinement(State, boolean);
keyword_u_r_l ->
parse_type_with_refinement(State, {semantic_type, u_r_l});
keyword_percentage ->
parse_type_with_refinement(State, {numeric_type, percentage});
keyword_list ->
parse_list_type(State);
keyword_dict ->
parse_dict_type(State);
keyword_optional ->
parse_optional_type(State);
keyword_defaulted ->
parse_defaulted_type(State);
symbol_left_brace ->
parse_record_type(State);
{identifier, Name} ->
case gleam_stdlib:string_starts_with(Name, <<"_"/utf8>>) of
true ->
State@1 = advance(State),
{ok, {{parsed_type_alias_ref, Name}, State@1}};
false ->
{error,
{unknown_type,
Name,
erlang:element(3, State),
erlang:element(4, State)}}
end;
Tok ->
{error,
{unknown_type,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1078).
-spec parse_dict_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_dict_type(State) ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_paren, <<"("/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_dict_key_type(State@2),
fun(_use0) ->
{Key, State@3} = _use0,
gleam@result:'try'(
expect(State@3, symbol_comma, <<","/utf8>>),
fun(State@4) ->
gleam@result:'try'(
parse_collection_inner_type(State@4),
fun(_use0@1) ->
{Value, State@5} = _use0@1,
gleam@result:'try'(
expect(
State@5,
symbol_right_paren,
<<")"/utf8>>
),
fun(State@6) ->
{ok,
{{parsed_collection,
{dict, Key, Value}},
State@6}}
end
)
end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1018).
?DOC(
" Parses types valid inside collections: primitives, nested collections, or type alias refs.\n"
" Does not allow modifiers (Optional/Defaulted) or refinements directly.\n"
).
-spec parse_collection_inner_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_collection_inner_type(State) ->
case peek(State) of
keyword_string ->
State@1 = advance(State),
{ok, {{parsed_primitive, string}, State@1}};
keyword_integer ->
State@2 = advance(State),
{ok, {{parsed_primitive, {numeric_type, integer}}, State@2}};
keyword_float ->
State@3 = advance(State),
{ok, {{parsed_primitive, {numeric_type, float}}, State@3}};
keyword_boolean ->
State@4 = advance(State),
{ok, {{parsed_primitive, boolean}, State@4}};
keyword_u_r_l ->
State@5 = advance(State),
{ok, {{parsed_primitive, {semantic_type, u_r_l}}, State@5}};
keyword_percentage ->
State@6 = advance(State),
{ok, {{parsed_primitive, {numeric_type, percentage}}, State@6}};
keyword_list ->
parse_list_type(State);
keyword_dict ->
parse_dict_type(State);
symbol_left_brace ->
parse_record_type(State);
{identifier, Name} ->
case gleam_stdlib:string_starts_with(Name, <<"_"/utf8>>) of
true ->
State@7 = advance(State),
{ok, {{parsed_type_alias_ref, Name}, State@7}};
false ->
{error,
{unknown_type,
Name,
erlang:element(3, State),
erlang:element(4, State)}}
end;
Tok ->
{error,
{unknown_type,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1002).
?DOC(
" Parses a record type: `{ field: Type, ... }`.\n"
" Reuses parse_type_struct to parse the struct, then converts fields to a dict.\n"
).
-spec parse_record_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_record_type(State) ->
gleam@result:'try'(
parse_type_struct(State),
fun(_use0) ->
{S, State@1} = _use0,
Fields = begin
_pipe = erlang:element(2, S),
_pipe@1 = gleam@list:map(
_pipe,
fun(Field) ->
T@1 = case erlang:element(3, Field) of
{type_value, T} -> T;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"caffeine_lang/frontend/parser"/utf8>>,
function => <<"parse_record_type"/utf8>>,
line => 1009,
value => _assert_fail,
start => 32132,
'end' => 32173,
pattern_start => 32143,
pattern_end => 32159})
end,
{erlang:element(2, Field), T@1}
end
),
maps:from_list(_pipe@1)
end,
{ok, {{parsed_record, Fields}, State@1}}
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 235).
-spec parse_type_alias(
parser_state(),
binary(),
list(caffeine_lang@frontend@ast:comment())
) -> {ok, {caffeine_lang@frontend@ast:type_alias(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_type_alias(State, Name, Leading_comments) ->
case Name of
<<"_"/utf8>> ->
{error,
{invalid_type_alias_name,
Name,
<<"type alias name must have at least one character after the underscore"/utf8>>,
erlang:element(3, State),
erlang:element(4, State)}};
_ ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_paren, <<"("/utf8>>),
fun(State@2) -> case peek(State@2) of
keyword_type ->
State@3 = advance(State@2),
gleam@result:'try'(
expect(
State@3,
symbol_right_paren,
<<")"/utf8>>
),
fun(State@4) ->
gleam@result:'try'(
expect(
State@4,
symbol_colon,
<<":"/utf8>>
),
fun(State@5) ->
gleam@result:'try'(
parse_type(State@5),
fun(_use0) ->
{Type_, State@6} = _use0,
{ok,
{{type_alias,
Name,
Type_,
Leading_comments},
State@6}}
end
)
end
)
end
);
Tok ->
{error,
{unexpected_token,
<<"Type"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State@2),
erlang:element(4, State@2)}}
end end
)
end.
-file("src/caffeine_lang/frontend/parser.gleam", 196).
-spec parse_type_aliases_loop(
parser_state(),
list(caffeine_lang@frontend@ast:type_alias()),
list(caffeine_lang@frontend@ast:comment())
) -> {ok,
{list(caffeine_lang@frontend@ast:type_alias()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_type_aliases_loop(State, Acc, Pending) ->
case peek(State) of
{identifier, Name} ->
case is_type_alias(State) of
true ->
gleam@result:'try'(
parse_type_alias(State, Name, Pending),
fun(_use0) ->
{Type_alias, State@1} = _use0,
{Next_pending, State@2} = consume_comments(State@1),
parse_type_aliases_loop(
State@2,
[Type_alias | Acc],
Next_pending
)
end
);
false ->
{ok, {lists:reverse(Acc), Pending, State}}
end;
_ ->
{ok, {lists:reverse(Acc), Pending, State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 189).
?DOC(
" Parse zero or more type aliases at file start.\n"
" Type alias syntax: _name (Type): <refinement_type>\n"
).
-spec parse_type_aliases(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {ok,
{list(caffeine_lang@frontend@ast:type_alias()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_type_aliases(State, Pending) ->
parse_type_aliases_loop(State, [], Pending).
-file("src/caffeine_lang/frontend/parser.gleam", 1068).
-spec parse_list_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_list_type(State) ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_paren, <<"("/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_collection_inner_type(State@2),
fun(_use0) ->
{Element, State@3} = _use0,
gleam@result:'try'(
expect(State@3, symbol_right_paren, <<")"/utf8>>),
fun(State@4) ->
{ok,
{{parsed_collection, {list, Element}}, State@4}}
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1120).
-spec parse_optional_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_optional_type(State) ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_paren, <<"("/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_type(State@2),
fun(_use0) ->
{Inner, State@3} = _use0,
gleam@result:'try'(
expect(State@3, symbol_right_paren, <<")"/utf8>>),
fun(State@4) ->
{ok,
{{parsed_modifier, {optional, Inner}}, State@4}}
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1318).
-spec parse_literal_list_contents(parser_state()) -> {ok,
{list(caffeine_lang@frontend@ast:literal()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_literal_list_contents(State) ->
case peek(State) of
symbol_right_bracket ->
{ok, {[], State}};
symbol_right_brace ->
{ok, {[], State}};
_ ->
gleam@result:'try'(
parse_literal(State),
fun(_use0) ->
{First, State@1} = _use0,
parse_literal_list_loop(State@1, [First])
end
)
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1330).
-spec parse_literal_list_loop(
parser_state(),
list(caffeine_lang@frontend@ast:literal())
) -> {ok, {list(caffeine_lang@frontend@ast:literal()), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_literal_list_loop(State, Acc) ->
case peek(State) of
symbol_comma ->
State@1 = advance(State),
gleam@result:'try'(
parse_literal(State@1),
fun(_use0) ->
{Literal, State@2} = _use0,
parse_literal_list_loop(State@2, [Literal | Acc])
end
);
_ ->
{ok, {lists:reverse(Acc), State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1286).
-spec parse_literal(parser_state()) -> {ok,
{caffeine_lang@frontend@ast:literal(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_literal(State) ->
case peek(State) of
{literal_string, S} ->
{ok, {{literal_string, S}, advance(State)}};
{literal_integer, N} ->
{ok, {{literal_integer, N}, advance(State)}};
{literal_float, F} ->
{ok, {{literal_float, F}, advance(State)}};
{literal_percentage, F@1} ->
{ok, {{literal_percentage, F@1}, advance(State)}};
literal_true ->
{ok, {literal_true, advance(State)}};
literal_false ->
{ok, {literal_false, advance(State)}};
symbol_left_bracket ->
parse_literal_list(State);
symbol_left_brace ->
parse_literal_struct_value(State);
Tok ->
{error,
{unexpected_token,
<<"literal value"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1309).
-spec parse_literal_list(parser_state()) -> {ok,
{caffeine_lang@frontend@ast:literal(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_literal_list(State) ->
gleam@result:'try'(
expect(State, symbol_left_bracket, <<"["/utf8>>),
fun(State@1) ->
gleam@result:'try'(
parse_literal_list_contents(State@1),
fun(_use0) ->
{Elements, State@2} = _use0,
gleam@result:'try'(
expect(State@2, symbol_right_bracket, <<"]"/utf8>>),
fun(State@3) ->
{ok, {{literal_list, Elements}, State@3}}
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 843).
?DOC(" Parses a struct with literal fields (for Provides blocks).\n").
-spec parse_literal_struct(parser_state()) -> {ok,
{caffeine_lang@frontend@ast:struct(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_literal_struct(State) ->
parse_struct(
State,
fun(S) ->
gleam@result:'try'(
parse_literal(S),
fun(_use0) ->
{Literal, S@1} = _use0,
{ok, {{literal_value, Literal}, S@1}}
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 305).
-spec parse_extendable(
parser_state(),
binary(),
list(caffeine_lang@frontend@ast:comment())
) -> {ok, {caffeine_lang@frontend@ast:extendable(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_extendable(State, Name, Leading_comments) ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_paren, <<"("/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_extendable_kind(State@2),
fun(_use0) ->
{Kind, State@3} = _use0,
gleam@result:'try'(
expect(State@3, symbol_right_paren, <<")"/utf8>>),
fun(State@4) ->
gleam@result:'try'(
expect(State@4, symbol_colon, <<":"/utf8>>),
fun(State@5) -> gleam@result:'try'(case Kind of
extendable_requires ->
parse_type_struct(State@5);
extendable_provides ->
parse_literal_struct(State@5)
end, fun(_use0@1) ->
{Body, State@6} = _use0@1,
{ok,
{{extendable,
Name,
Kind,
Body,
Leading_comments},
State@6}}
end) end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 286).
-spec parse_extendables_loop(
parser_state(),
list(caffeine_lang@frontend@ast:extendable()),
list(caffeine_lang@frontend@ast:comment())
) -> {ok,
{list(caffeine_lang@frontend@ast:extendable()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_extendables_loop(State, Acc, Pending) ->
case peek(State) of
{identifier, Name} ->
gleam@result:'try'(
parse_extendable(State, Name, Pending),
fun(_use0) ->
{Extendable, State@1} = _use0,
{Next_pending, State@2} = consume_comments(State@1),
parse_extendables_loop(
State@2,
[Extendable | Acc],
Next_pending
)
end
);
_ ->
{ok, {lists:reverse(Acc), Pending, State}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 279).
?DOC(" Parse zero or more extendables at file start.\n").
-spec parse_extendables(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {ok,
{list(caffeine_lang@frontend@ast:extendable()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_extendables(State, Pending) ->
parse_extendables_loop(State, [], Pending).
-file("src/caffeine_lang/frontend/parser.gleam", 406).
-spec parse_blueprint_item(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {ok, {caffeine_lang@frontend@ast:blueprint_item(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_blueprint_item(State, Leading_comments) ->
gleam@result:'try'(
expect(State, symbol_star, <<"*"/utf8>>),
fun(State@1) ->
gleam@result:'try'(
parse_string_literal(State@1),
fun(_use0) ->
{Name, State@2} = _use0,
gleam@result:'try'(
parse_optional_extends(State@2),
fun(_use0@1) ->
{Extends, State@3} = _use0@1,
gleam@result:'try'(
expect(State@3, symbol_colon, <<":"/utf8>>),
fun(State@4) ->
gleam@result:'try'(
expect(
State@4,
keyword_requires,
<<"Requires"/utf8>>
),
fun(State@5) ->
gleam@result:'try'(
parse_type_struct(State@5),
fun(_use0@2) ->
{Requires, State@6} = _use0@2,
gleam@result:'try'(
expect(
State@6,
keyword_provides,
<<"Provides"/utf8>>
),
fun(State@7) ->
gleam@result:'try'(
parse_literal_struct(
State@7
),
fun(_use0@3) ->
{Provides,
State@8} = _use0@3,
{ok,
{{blueprint_item,
Name,
Extends,
Requires,
Provides,
Leading_comments},
State@8}}
end
)
end
)
end
)
end
)
end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 428).
-spec parse_expect_item(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {ok, {caffeine_lang@frontend@ast:expect_item(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_expect_item(State, Leading_comments) ->
gleam@result:'try'(
expect(State, symbol_star, <<"*"/utf8>>),
fun(State@1) ->
gleam@result:'try'(
parse_string_literal(State@1),
fun(_use0) ->
{Name, State@2} = _use0,
gleam@result:'try'(
parse_optional_extends(State@2),
fun(_use0@1) ->
{Extends, State@3} = _use0@1,
gleam@result:'try'(
expect(State@3, symbol_colon, <<":"/utf8>>),
fun(State@4) -> case peek(State@4) of
keyword_requires ->
{error,
{unexpected_token,
<<"Provides"/utf8>>,
<<"Requires"/utf8>>,
erlang:element(3, State@4),
erlang:element(4, State@4)}};
_ ->
gleam@result:'try'(
expect(
State@4,
keyword_provides,
<<"Provides"/utf8>>
),
fun(State@5) ->
gleam@result:'try'(
parse_literal_struct(
State@5
),
fun(_use0@2) ->
{Provides, State@6} = _use0@2,
{ok,
{{expect_item,
Name,
Extends,
Provides,
Leading_comments},
State@6}}
end
)
end
)
end end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 575).
-spec parse_blueprint_items_recovering_loop(
parser_state(),
list(caffeine_lang@frontend@ast:blueprint_item()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:blueprint_item()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_blueprint_items_recovering_loop(State, Item_acc, Error_acc, Pending) ->
case peek(State) of
symbol_star ->
case parse_blueprint_item(State, Pending) of
{ok, {Item, State@1}} ->
{Next_pending, State@2} = consume_comments(State@1),
parse_blueprint_items_recovering_loop(
State@2,
[Item | Item_acc],
Error_acc,
Next_pending
);
{error, Err} ->
State@3 = skip_to_item_boundary(advance(State)),
{Next_pending@1, State@4} = consume_comments(State@3),
parse_blueprint_items_recovering_loop(
State@4,
Item_acc,
[Err | Error_acc],
Next_pending@1
)
end;
_ ->
{lists:reverse(Item_acc), lists:reverse(Error_acc), Pending, State}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 568).
?DOC(" Parse blueprint items with recovery between items.\n").
-spec parse_blueprint_items_recovering(parser_state()) -> {list(caffeine_lang@frontend@ast:blueprint_item()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_blueprint_items_recovering(State) ->
{Pending, State@1} = consume_comments(State),
parse_blueprint_items_recovering_loop(State@1, [], [], Pending).
-file("src/caffeine_lang/frontend/parser.gleam", 532).
?DOC(" Parse a single blueprints block, recovering from item-level errors.\n").
-spec parse_blueprints_block_recovering(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {{ok,
{caffeine_lang@frontend@ast:blueprints_block(),
list(caffeine_lang@frontend@ast:comment())}} |
{error, caffeine_lang@frontend@parser_error:parser_error()},
list(caffeine_lang@frontend@parser_error:parser_error()),
parser_state()}.
parse_blueprints_block_recovering(State, Leading_comments) ->
case parse_blueprints_block_header(State) of
{error, Err} ->
{{error, Err}, [], State};
{ok, {Artifacts, State@1}} ->
{Items, Item_errors, Trailing, State@2} = parse_blueprint_items_recovering(
State@1
),
{{ok,
{{blueprints_block, Artifacts, Items, Leading_comments},
Trailing}},
Item_errors,
State@2}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 483).
-spec parse_blueprints_blocks_recovering_loop(
parser_state(),
list(caffeine_lang@frontend@ast:blueprints_block()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:blueprints_block()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_blueprints_blocks_recovering_loop(State, Block_acc, Error_acc, Pending) ->
case peek(State) of
keyword_blueprints ->
{Block_result, Item_errors, State@1} = parse_blueprints_block_recovering(
State,
Pending
),
{More_comments, State@2} = consume_comments(State@1),
case Block_result of
{ok, {Block, Trailing}} ->
Next_pending = lists:append(Trailing, More_comments),
parse_blueprints_blocks_recovering_loop(
State@2,
[Block | Block_acc],
lists:append(Error_acc, Item_errors),
Next_pending
);
{error, Err} ->
State@3 = skip_to_block_boundary(advance(State@2)),
{Next_pending@1, State@4} = consume_comments(State@3),
parse_blueprints_blocks_recovering_loop(
State@4,
Block_acc,
lists:append(Error_acc, [Err | Item_errors]),
Next_pending@1
)
end;
e_o_f ->
{lists:reverse(Block_acc), Error_acc, Pending, State};
Tok ->
Err@1 = {unexpected_token,
<<"Blueprints"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)},
{lists:reverse(Block_acc),
lists:append(Error_acc, [Err@1]),
Pending,
State}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 476).
?DOC(" Parse blueprints blocks with error recovery between blocks and items.\n").
-spec parse_blueprints_blocks_recovering(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:blueprints_block()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_blueprints_blocks_recovering(State, Pending) ->
parse_blueprints_blocks_recovering_loop(State, [], [], Pending).
-file("src/caffeine_lang/frontend/parser.gleam", 38).
?DOC(
" Parses a blueprints file from source text.\n"
" Returns all recoverable parse errors rather than stopping at the first one.\n"
).
-spec parse_blueprints_file(binary()) -> {ok,
caffeine_lang@frontend@ast:blueprints_file(caffeine_lang@frontend@ast:parsed())} |
{error, list(caffeine_lang@frontend@parser_error:parser_error())}.
parse_blueprints_file(Source) ->
gleam@result:'try'(
begin
_pipe = caffeine_lang@frontend@tokenizer:tokenize(Source),
gleam@result:map_error(_pipe, fun(E) -> [{tokenizer_error, E}] end)
end,
fun(Tokens) ->
Filtered = filter_whitespace(Tokens),
State = init_state(Filtered),
{Pending, State@1} = consume_comments(State),
gleam@result:'try'(
begin
_pipe@1 = parse_type_aliases(State@1, Pending),
gleam@result:map_error(_pipe@1, fun(E@1) -> [E@1] end)
end,
fun(_use0) ->
{Type_aliases, Pending@1, State@2} = _use0,
gleam@result:'try'(
begin
_pipe@2 = parse_extendables(State@2, Pending@1),
gleam@result:map_error(
_pipe@2,
fun(E@2) -> [E@2] end
)
end,
fun(_use0@1) ->
{Extendables, Pending@2, State@3} = _use0@1,
{Blocks, Errors, Pending@3, _} = parse_blueprints_blocks_recovering(
State@3,
Pending@2
),
case Errors of
[] ->
{ok,
{blueprints_file,
Type_aliases,
Extendables,
Blocks,
Pending@3}};
Errs ->
{error, Errs}
end
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 711).
-spec parse_expect_items_recovering_loop(
parser_state(),
list(caffeine_lang@frontend@ast:expect_item()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:expect_item()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_expect_items_recovering_loop(State, Item_acc, Error_acc, Pending) ->
case peek(State) of
symbol_star ->
case parse_expect_item(State, Pending) of
{ok, {Item, State@1}} ->
{Next_pending, State@2} = consume_comments(State@1),
parse_expect_items_recovering_loop(
State@2,
[Item | Item_acc],
Error_acc,
Next_pending
);
{error, Err} ->
State@3 = skip_to_item_boundary(advance(State)),
{Next_pending@1, State@4} = consume_comments(State@3),
parse_expect_items_recovering_loop(
State@4,
Item_acc,
[Err | Error_acc],
Next_pending@1
)
end;
_ ->
{lists:reverse(Item_acc), lists:reverse(Error_acc), Pending, State}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 704).
?DOC(" Parse expect items with recovery between items.\n").
-spec parse_expect_items_recovering(parser_state()) -> {list(caffeine_lang@frontend@ast:expect_item()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_expect_items_recovering(State) ->
{Pending, State@1} = consume_comments(State),
parse_expect_items_recovering_loop(State@1, [], [], Pending).
-file("src/caffeine_lang/frontend/parser.gleam", 667).
?DOC(" Parse a single expects block, recovering from item-level errors.\n").
-spec parse_expects_block_recovering(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {{ok,
{caffeine_lang@frontend@ast:expects_block(),
list(caffeine_lang@frontend@ast:comment())}} |
{error, caffeine_lang@frontend@parser_error:parser_error()},
list(caffeine_lang@frontend@parser_error:parser_error()),
parser_state()}.
parse_expects_block_recovering(State, Leading_comments) ->
case parse_expects_block_header(State) of
{error, Err} ->
{{error, Err}, [], State};
{ok, {Blueprint, State@1}} ->
{Items, Item_errors, Trailing, State@2} = parse_expect_items_recovering(
State@1
),
{{ok,
{{expects_block, Blueprint, Items, Leading_comments},
Trailing}},
Item_errors,
State@2}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 618).
-spec parse_expects_blocks_recovering_loop(
parser_state(),
list(caffeine_lang@frontend@ast:expects_block()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:expects_block()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_expects_blocks_recovering_loop(State, Block_acc, Error_acc, Pending) ->
case peek(State) of
keyword_expectations ->
{Block_result, Item_errors, State@1} = parse_expects_block_recovering(
State,
Pending
),
{More_comments, State@2} = consume_comments(State@1),
case Block_result of
{ok, {Block, Trailing}} ->
Next_pending = lists:append(Trailing, More_comments),
parse_expects_blocks_recovering_loop(
State@2,
[Block | Block_acc],
lists:append(Error_acc, Item_errors),
Next_pending
);
{error, Err} ->
State@3 = skip_to_block_boundary(advance(State@2)),
{Next_pending@1, State@4} = consume_comments(State@3),
parse_expects_blocks_recovering_loop(
State@4,
Block_acc,
lists:append(Error_acc, [Err | Item_errors]),
Next_pending@1
)
end;
e_o_f ->
{lists:reverse(Block_acc), Error_acc, Pending, State};
Tok ->
Err@1 = {unexpected_token,
<<"Expectations"/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)},
{lists:reverse(Block_acc),
lists:append(Error_acc, [Err@1]),
Pending,
State}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 611).
?DOC(" Parse expects blocks with error recovery between blocks and items.\n").
-spec parse_expects_blocks_recovering(
parser_state(),
list(caffeine_lang@frontend@ast:comment())
) -> {list(caffeine_lang@frontend@ast:expects_block()),
list(caffeine_lang@frontend@parser_error:parser_error()),
list(caffeine_lang@frontend@ast:comment()),
parser_state()}.
parse_expects_blocks_recovering(State, Pending) ->
parse_expects_blocks_recovering_loop(State, [], [], Pending).
-file("src/caffeine_lang/frontend/parser.gleam", 72).
?DOC(
" Parses an expects file from source text.\n"
" Returns all recoverable parse errors rather than stopping at the first one.\n"
).
-spec parse_expects_file(binary()) -> {ok,
caffeine_lang@frontend@ast:expects_file(caffeine_lang@frontend@ast:parsed())} |
{error, list(caffeine_lang@frontend@parser_error:parser_error())}.
parse_expects_file(Source) ->
gleam@result:'try'(
begin
_pipe = caffeine_lang@frontend@tokenizer:tokenize(Source),
gleam@result:map_error(_pipe, fun(E) -> [{tokenizer_error, E}] end)
end,
fun(Tokens) ->
Filtered = filter_whitespace(Tokens),
State = init_state(Filtered),
{Pending, State@1} = consume_comments(State),
gleam@result:'try'(
begin
_pipe@1 = parse_extendables(State@1, Pending),
gleam@result:map_error(_pipe@1, fun(E@1) -> [E@1] end)
end,
fun(_use0) ->
{Extendables, Pending@1, State@2} = _use0,
{Blocks, Errors, Pending@2, _} = parse_expects_blocks_recovering(
State@2,
Pending@1
),
case Errors of
[] ->
{ok, {expects_file, Extendables, Blocks, Pending@2}};
Errs ->
{error, Errs}
end
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1171).
-spec parse_defaulted_refinement_body(
parser_state(),
caffeine_lang@types:parsed_type()
) -> {ok,
{caffeine_lang@types:refinement_types(caffeine_lang@types:parsed_type()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_defaulted_refinement_body(State, Defaulted) ->
case peek(State) of
symbol_left_brace ->
State@1 = advance(State),
gleam@result:'try'(
parse_literal_list_contents(State@1),
fun(_use0) ->
{Values, State@2} = _use0,
gleam@result:'try'(
expect(State@2, symbol_right_brace, <<"}"/utf8>>),
fun(State@3) ->
String_values = gleam@list:map(
Values,
fun literal_to_string/1
),
{ok,
{{one_of,
Defaulted,
gleam@set:from_list(String_values)},
State@3}}
end
)
end
);
symbol_left_paren ->
State@4 = advance(State),
gleam@result:'try'(
parse_literal(State@4),
fun(_use0@1) ->
{Min, State@5} = _use0@1,
gleam@result:'try'(
expect(State@5, symbol_dot_dot, <<".."/utf8>>),
fun(State@6) ->
gleam@result:'try'(
parse_literal(State@6),
fun(_use0@2) ->
{Max, State@7} = _use0@2,
gleam@result:'try'(
expect(
State@7,
symbol_right_paren,
<<")"/utf8>>
),
fun(State@8) ->
{ok,
{{inclusive_range,
Defaulted,
literal_to_string(Min),
literal_to_string(Max)},
State@8}}
end
)
end
)
end
)
end
);
Tok ->
{error,
{unexpected_token,
<<"{ or ("/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1154).
?DOC(" Parse refinement on a Defaulted type: { x | x in { ... } } or { x | x in ( ... ) }\n").
-spec parse_defaulted_refinement(
parser_state(),
caffeine_lang@types:parsed_type()
) -> {ok,
{caffeine_lang@types:refinement_types(caffeine_lang@types:parsed_type()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_defaulted_refinement(State, Defaulted) ->
gleam@result:'try'(
expect(State, symbol_left_brace, <<"{"/utf8>>),
fun(State@1) ->
gleam@result:'try'(
expect_x(State@1),
fun(State@2) ->
gleam@result:'try'(
expect(State@2, symbol_pipe, <<"|"/utf8>>),
fun(State@3) ->
gleam@result:'try'(
expect_x(State@3),
fun(State@4) ->
gleam@result:'try'(
expect(
State@4,
keyword_in,
<<"in"/utf8>>
),
fun(State@5) ->
gleam@result:'try'(
parse_defaulted_refinement_body(
State@5,
Defaulted
),
fun(_use0) ->
{Refinement, State@6} = _use0,
gleam@result:'try'(
expect(
State@6,
symbol_right_brace,
<<"}"/utf8>>
),
fun(State@7) ->
{ok,
{Refinement,
State@7}}
end
)
end
)
end
)
end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1130).
-spec parse_defaulted_type(parser_state()) -> {ok,
{caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_defaulted_type(State) ->
State@1 = advance(State),
gleam@result:'try'(
expect(State@1, symbol_left_paren, <<"("/utf8>>),
fun(State@2) ->
gleam@result:'try'(
parse_type(State@2),
fun(_use0) ->
{Inner, State@3} = _use0,
gleam@result:'try'(
expect(State@3, symbol_comma, <<","/utf8>>),
fun(State@4) ->
gleam@result:'try'(
parse_literal(State@4),
fun(_use0@1) ->
{Default, State@5} = _use0@1,
gleam@result:'try'(
expect(
State@5,
symbol_right_paren,
<<")"/utf8>>
),
fun(State@6) ->
Defaulted = {parsed_modifier,
{defaulted,
Inner,
literal_to_string(Default)}},
case peek(State@6) of
symbol_left_brace ->
gleam@result:'try'(
parse_defaulted_refinement(
State@6,
Defaulted
),
fun(_use0@2) ->
{Refinement,
State@7} = _use0@2,
{ok,
{{parsed_refinement,
Refinement},
State@7}}
end
);
_ ->
{ok, {Defaulted, State@6}}
end
end
)
end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 1240).
-spec parse_refinement_body(
parser_state(),
caffeine_lang@types:primitive_types()
) -> {ok,
{caffeine_lang@types:refinement_types(caffeine_lang@types:parsed_type()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_refinement_body(State, Primitive) ->
case peek(State) of
symbol_left_brace ->
State@1 = advance(State),
gleam@result:'try'(
parse_literal_list_contents(State@1),
fun(_use0) ->
{Values, State@2} = _use0,
gleam@result:'try'(
expect(State@2, symbol_right_brace, <<"}"/utf8>>),
fun(State@3) ->
String_values = gleam@list:map(
Values,
fun literal_to_string/1
),
{ok,
{{one_of,
{parsed_primitive, Primitive},
gleam@set:from_list(String_values)},
State@3}}
end
)
end
);
symbol_left_paren ->
State@4 = advance(State),
gleam@result:'try'(
parse_literal(State@4),
fun(_use0@1) ->
{Min, State@5} = _use0@1,
gleam@result:'try'(
expect(State@5, symbol_dot_dot, <<".."/utf8>>),
fun(State@6) ->
gleam@result:'try'(
parse_literal(State@6),
fun(_use0@2) ->
{Max, State@7} = _use0@2,
gleam@result:'try'(
expect(
State@7,
symbol_right_paren,
<<")"/utf8>>
),
fun(State@8) ->
{ok,
{{inclusive_range,
{parsed_primitive,
Primitive},
literal_to_string(Min),
literal_to_string(Max)},
State@8}}
end
)
end
)
end
)
end
);
Tok ->
{error,
{unexpected_token,
<<"{ or ("/utf8>>,
caffeine_lang@frontend@token:to_string(Tok),
erlang:element(3, State),
erlang:element(4, State)}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1214).
-spec parse_refinement(parser_state(), caffeine_lang@types:primitive_types()) -> {ok,
{caffeine_lang@types:refinement_types(caffeine_lang@types:parsed_type()),
parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_refinement(State, Primitive) ->
gleam@result:'try'(
expect(State, symbol_left_brace, <<"{"/utf8>>),
fun(State@1) ->
gleam@result:'try'(
expect_x(State@1),
fun(State@2) ->
gleam@result:'try'(
expect(State@2, symbol_pipe, <<"|"/utf8>>),
fun(State@3) ->
gleam@result:'try'(
expect_x(State@3),
fun(State@4) ->
gleam@result:'try'(
expect(
State@4,
keyword_in,
<<"in"/utf8>>
),
fun(State@5) ->
gleam@result:'try'(
parse_refinement_body(
State@5,
Primitive
),
fun(_use0) ->
{Refinement, State@6} = _use0,
gleam@result:'try'(
expect(
State@6,
symbol_right_brace,
<<"}"/utf8>>
),
fun(State@7) ->
{ok,
{Refinement,
State@7}}
end
)
end
)
end
)
end
)
end
)
end
)
end
).
-file("src/caffeine_lang/frontend/parser.gleam", 986).
-spec parse_type_with_refinement(
parser_state(),
caffeine_lang@types:primitive_types()
) -> {ok, {caffeine_lang@types:parsed_type(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_type_with_refinement(State, Primitive) ->
State@1 = advance(State),
case peek(State@1) of
symbol_left_brace ->
gleam@result:'try'(
parse_refinement(State@1, Primitive),
fun(_use0) ->
{Refinement, State@2} = _use0,
{ok, {{parsed_refinement, Refinement}, State@2}}
end
);
_ ->
{ok, {{parsed_primitive, Primitive}, State@1}}
end.
-file("src/caffeine_lang/frontend/parser.gleam", 1344).
-spec parse_literal_struct_value(parser_state()) -> {ok,
{caffeine_lang@frontend@ast:literal(), parser_state()}} |
{error, caffeine_lang@frontend@parser_error:parser_error()}.
parse_literal_struct_value(State) ->
Parse_value = fun(S) ->
gleam@result:'try'(
parse_literal(S),
fun(_use0) ->
{Literal, S@1} = _use0,
{ok, {{literal_value, Literal}, S@1}}
end
)
end,
gleam@result:'try'(
expect(State, symbol_left_brace, <<"{"/utf8>>),
fun(State@1) ->
{Pending, State@2} = consume_comments(State@1),
gleam@result:'try'(
parse_fields(State@2, Pending, Parse_value),
fun(_use0@1) ->
{Fields, Trailing_comments, State@3} = _use0@1,
gleam@result:'try'(
expect(State@3, symbol_right_brace, <<"}"/utf8>>),
fun(State@4) ->
{ok,
{{literal_struct, Fields, Trailing_comments},
State@4}}
end
)
end
)
end
).