class

Syntax::Parser

Inherits Syntax::Lexer < Reference < Object

Constants

AtomicWithMethodCheck = [:IDENT, :CONST, :+, :-, :*, :/, ://, :%, :|, :&, :^, :~, :!, :**, :<<, :<, :<=, :==, :!=, :=~, :!~, :>>, :>, :>=, :<=>, :===, :[], :[]=, :[]?, :"[", :&+, :&-, :&*, :&**]

ConstOrDoubleColon = [:CONST, :"::"]

DefOrMacroCheck1 = [:IDENT, :CONST, :"`", :<<, :<, :<=, :==, :===, :!=, :=~, :!~, :>>, :>, :>=, :+, :-, :*, :/, ://, :!, :~, :%, :&, :|, :^, :**, :[], :[]?, :[]=, :<=>, :&+, :&-, :&*, :&**]

DefOrMacroCheck2 = [:<<, :<, :<=, :==, :===, :!=, :=~, :!~, :>>, :>, :>=, :+, :-, :*, :/, ://, :!, :~, :%, :&, :|, :^, :**, :[], :[]?, :[]=, :<=>, :&+, :&-, :&*, :&**]

IdentOrConst = [:IDENT, :CONST]

SemicolonOrNewLine = [:";", :NEWLINE]

Constructors

new(str, string_pool : StringPool | Nil = nil, var_scopes : Array(Set(String)) = [Set(String).new])

Class methods

parse(str, string_pool : StringPool | Nil = nil, var_scopes = [Set(String).new]) : ASTNode

Instance methods

add_when_exp(when_exps, exp)

Adds an expression to all when expressions and error on duplicates

call_block_arg_follows?

can_be_assigned?(node)

check(token_types : Array)

check(token_type)

check_const

check_ident(value)

check_ident

check_macro_expression_end

check_macro_skip_whitespace

check_not_inside_def(message, &)

check_not_pipe_before_proc_literal_body

check_token(value)

check_type_declaration

check_valid_def_name

check_valid_def_op_name

check_valid_exhaustive_expression(exp)

check_void_expression_keyword

check_void_value(exp, location)

compute_block_arg_yields(block_arg)

consume_def_equals_sign_skip_space

consume_def_or_macro_name

consume_delimiter(pieces, delimiter_state, has_interpolation)

consume_heredoc(delimiter_state, node)

consume_heredocs

consume_regex_options

def_nest

def_nest=(def_nest : Int32)

delimiter_or_type_suffix?

end_token?

fun_nest

fun_nest=(fun_nest : Int32)

inside_def?

inside_fun?

invalid_internal_name?(keyword)

make_named_tuple_type(named_args)

make_nilable_expression(type)

make_nilable_type(type)

make_pointer_type(type)

make_static_array_type(type, size)

make_tuple_type(types)

multi_assign_middle?(exp)

multi_assign_target?(exp)

multiassign_left_hand(exp)

named_tuple_start?

needs_heredoc_indent_removed?(delimiter_state)

new_hash_literal(entries, line, column, end_location, allow_of = true)

new_node_check_type_declaration(klass)

new_node_check_type_declaration(klass, &)

new_range(exp, location, exclusive)

next_comes_colon_space?

next_comes_plus_or_minus?

next_token

node_and_next_token(node)

open(symbol, location = @token.location, &)

parse(mode : ParseMode)

parse

parse_add_or_sub

parse_alias

parse_and

parse_annotation

parse_annotation_def

parse_arg(args, extra_assigns, parentheses, found_default_value, found_splat, found_double_splat, allow_restrictions)

parse_arg_name(location, extra_assigns, allow_external_name)

parse_array_literal

parse_as(atomic, klass = Cast)

parse_as?(atomic)

parse_asm

parse_asm_clobbers

parse_asm_operand

parse_asm_operands

parse_asm_options

parse_atomic

parse_atomic_method_suffix(atomic, location)

parse_atomic_method_suffix_special(call, location)

parse_atomic_type

parse_atomic_type_with_suffix

parse_atomic_with_method

parse_atomic_without_location

parse_bare_proc_type

Parse a bare proc type like A, B, C -> D. Generally it is entry point of type parsing and it is used on the context expected type (e.g. type restrictions, rhs of alias and more)

parse_begin

parse_block(block, stop_on_do = false)

parse_block2

parse_block_arg(extra_assigns)

parse_break

parse_c_struct_or_union(union : Bool)

parse_c_struct_or_union_body

parse_c_struct_or_union_fields(exps)

parse_call_arg(found_double_splat = false)

parse_call_args(stop_on_do_after_space = false, allow_curly = false, control = false)

parse_call_args_named_args(location, args, first_name, allow_newline)

parse_call_args_space_consumed(check_plus_and_minus = true, allow_curly = false, control = false, end_token = :")", allow_beginless_range = false)

parse_call_block_arg(args, check_paren, named_args = nil)

parse_call_block_arg_after_dot(obj)

parse_case

parse_class_def(is_abstract = false, is_struct = false, doc = nil)

parse_cmp

parse_control_expression(klass)

parse_curly_block(block)

parse_custom_literal(type)

parse_def(is_abstract = false, is_macro_def = false, doc = nil)

parse_def_free_vars

parse_def_helper(is_abstract = false)

parse_delimiter(want_skip_space = true)

parse_empty_array_literal

parse_enum_body

parse_enum_def

parse_equality

parse_exception_handler(exp, implicit = false, begin_location = nil)

parse_expression

parse_expression_inside_macro

parse_expression_suffix(atomic, location)

parse_expression_suffix(location, &)

parse_expressions

parse_expressions_internal

parse_extend

parse_fun_def(top_level, require_body = false)

parse_fun_literal

parse_fun_literal_arg

parse_fun_pointer

parse_generic(global, location, expression)

parse_generic(expression = false)

Parse generic type path like A::B(C, D)?. This method is used to parse not only a type, but also an expression represents type. And it also consumes prefix :: to specify global path.

parse_generic_or_custom_literal

parse_generic_or_global_call

parse_hash_literal(first_key, location, allow_of)

parse_hash_or_tuple_literal(allow_of = true)

parse_if(check_end = true)

parse_if_after_condition(cond, location, check_end)

parse_include

parse_include_or_extend(klass)

parse_instance_sizeof

parse_is_a(atomic)

parse_lib

parse_lib_body

parse_lib_body_exp

parse_lib_body_exp_without_location

parse_logical_and

parse_logical_or

parse_macro

parse_macro_body(start_location, macro_state = Token::MacroState.default)

parse_macro_control(start_location, macro_state = Token::MacroState.default)

parse_macro_expression

parse_macro_if(start_location, macro_state, check_end = true, is_unless = false)

parse_macro_var_exps

parse_module_def

parse_mul_or_div

parse_multi_assign

parse_named_args(location, first_name = nil, allow_newline = false)

parse_named_tuple(location, first_key)

parse_named_tuple(location)

parse_named_type_args(end_token)

parse_negation_suffix(atomic)

parse_next

parse_nil?(atomic)

parse_offsetof

parse_op_assign(allow_ops = true, allow_suffix = true)

parse_op_assign_no_control(allow_ops = true, allow_suffix = true)

parse_or

parse_out

parse_parenthesized_expression

parse_path(global, location)

parse_path

Parse type path. It also consumes prefix :: to specify global path.

parse_percent_macro_control

parse_percent_macro_expression

parse_pointerof

parse_pow

parse_prefix

parse_proc_type_output(input_types, location)

parse_question_colon

parse_range

parse_require

parse_rescue

parse_rescue_types

parse_responds_to(atomic)

parse_responds_to_name

parse_return

parse_select

parse_shift

parse_single_arg

parse_sizeof(klass)

parse_sizeof

parse_string_array

parse_string_or_symbol_array(klass, elements_type)

parse_string_without_interpolation(context, want_skip_space = true)

parse_symbol_array

parse_to_def(a_def)

parse_tuple(first_exp, location)

parse_type_arg

parse_type_args(name)

parse_type_declaration(var)

parse_type_def

parse_type_splat

parse_type_suffix(type)

parse_type_vars

parse_typeof

parse_union_type

parse_union_types(end_token, *, allow_splats = false)

parse_unless

parse_unless_after_condition(cond, location)

parse_until

parse_var_or_call(global = false, force_call = false)

parse_visibility_modifier(modifier)

parse_when_expression(cond, single, exhaustive)

parse_while

parse_while_or_until(klass)

parse_yield(scope = nil, location = @token.location)

parse_yield_with_scope

prepare_parse_def

preserve_stop_on_do(new_value : Bool = false, &)

push_var(var : Var | Arg)

push_var(var : TypeDeclaration)

push_var(node)

push_var_name(name)

push_vars(vars)

push_visibility

remove_heredoc_from_line(line, indent, line_number)

remove_heredoc_indent(pieces : Array, indent)

set_visibility(node)

string_literal_start?

temp_arg_name

type_nest

type_nest=(type_nest : Int32)

type_path_start?

type_start?

type_start?(*, consume_newlines)

Looks ahead next tokens to check whether they indicate type.

unexpected_token(msg : String | Nil = nil, token : Token = @token)

unexpected_token_in_atomic

valid_select_when?(node)

var?(name)

var_in_scope?(name)

visibility

visibility=(visibility : Visibility | Nil)

wants_doc=(wants_doc)

wants_doc?

when_exp_constant?(exp)

Only error on constant values, because calls might have side-effects: a first call might return one value and not match the case value, but the second same call returns something different and matches it.

when_expression_end

with_isolated_var_scope(create_scope = true, &)

If create_scope is true, creates an isolated variable scope and returns the yield result, resetting the scope afterwards. Otherwise simply returns the yield result without touching the scopes.

with_lexical_var_scope

Creates a new variable scope with the same variables as the current scope, and then returns the yield result, resetting the scope afterwards.

Macros

parse_operator(name, next_operator, node, operators, right_associative = false)

Nested types