Package evaluation to test Lerche on Julia 1.14.0-DEV.2309 (6e1a27e459*) started at 2026-06-06T04:29:42.439 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 17.37s ################################################################################ # Installation # Installing Lerche... Resolving package versions... Installed OrderedCollections ─ v1.8.2 Installed DataStructures ───── v0.19.5 Installed Preferences ──────── v1.5.2 Installed Lerche ───────────── v0.5.8 Installed PrecompileTools ──── v1.3.4 Updating `~/.julia/environments/v1.14/Project.toml` [d42ef402] + Lerche v0.5.8 Updating `~/.julia/environments/v1.14/Manifest.toml` [864edb3b] + DataStructures v0.19.5 [d42ef402] + Lerche v0.5.8 ⌅ [bac558e1] + OrderedCollections v1.8.2 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [ade2ca70] + Dates v1.11.0 [56ddb016] + Logging v1.11.0 [de0858da] + Printf v1.11.0 [fa267f1f] + TOML v1.0.3 [4ec0a83e] + Unicode v1.11.0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Installation completed after 1.94s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 6.8 s ✓ TestEnv 1 dependency successfully precompiled in 7 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... 153.6 s ✓ OrderedCollections 2.9 s ✓ Preferences 171.8 s ✓ DataStructures 3.0 s ✓ PrecompileTools ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 =# Core.@doc "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." load_grammar(gl::GrammarLoader, grammar_text; grammar_name = "", import_paths = []) = begin │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:959 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:960 =# │ try │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:961 =# │ tree = transform(CanonizeTree(), parse(gl.parser, grammar_text * "\n")) │ catch e │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:963 =# │ if e isa UnexpectedCharacters │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:964 =# │ context = get_context(e, grammar_text) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:965 =# │ throw(GrammarError("Unexpected input at line $(e.line) column $(e).column in $(grammar_name): \n\n$(context)")) │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:967 =# e isa UnexpectedToken │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:968 =# │ context = get_context(e, grammar_text) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:969 =# │ error = match_examples(e, partial(parse, gl.parser), ERRORS, use_accepts = true) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:970 =# │ if error != nothing │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:971 =# │ throw(GrammarError("$(error) at line $(e.line) column $(e.column)\n\n$(context)")) │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:973 =# occursin("STRING", e.expected) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:974 =# │ throw(GrammarError("Expecting a value at line $(e.line) column $(e.column)\n\n$(context)")) │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:977 =# │ rethrow(e) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:980 =# │ tree = transform(PrepareGrammar(), tree) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:983 =# │ defs = classify(tree.children, key = (c->begin │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:983 =# │ c.data │ end), value = (c->begin │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:983 =# │ c.children │ end)) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:984 =# │ term_defs = pop!(defs, "term", []) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:985 =# │ rule_defs = pop!(defs, "rule", []) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:986 =# │ statements = pop!(defs, "statement", []) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =# @assert length(defs) == 0 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:989 =# │ term_defs = [if length(td) == 3 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:989 =# │ td │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:989 =# │ [td[1], 1, td[2]] │ end for td = term_defs] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:990 =# │ term_defs = [(name.value, (t, if !(typeof(p) <: Int) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:990 =# │ Base.parse(Int64, p.value) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:990 =# │ p │ end)) for (name, p, t) = term_defs] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:991 =# │ rule_defs = Any[options_from_rule(x[1], x[2:var"end"]...) for x = rule_defs] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:996 =# │ (ignore, imports) = ([], Dict()) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:997 =# │ for a_stmt = statements │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =# @assert length(a_stmt) == 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:999 =# │ stmt = a_stmt[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1000 =# │ if stmt.data == "ignore" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1001 =# │ t = stmt.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1002 =# │ push!(ignore, t) │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1003 =# stmt.data == "import" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1004 =# │ if length(stmt.children) > 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1005 =# │ (path_node, arg1) = stmt.children │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1007 =# │ path_node = stmt.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1008 =# │ arg1 = nothing │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1010 =# │ if arg1 isa Tree │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1011 =# │ dotted_path = tuple(path_node.children) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1012 =# │ names = arg1.children │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1013 =# │ aliases = Dict(zip(names, names)) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1015 =# │ dotted_path = tuple(path_node.children[1:var"end" - 1]) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1016 =# │ name = path_node.children[var"end"] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1017 =# │ aliases = Dict(name => if arg1 !== nothing │ arg1 │ else │ name │ end) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1020 =# │ if path_node.data == "import_lib" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1021 =# │ base_path = nothing │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1023 =# │ if grammar_name == "" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1024 =# │ base_file = abspath(PROGRAM_FILE) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1026 =# │ base_file = grammar_name │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1028 =# │ if base_file !== nothing │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1029 =# │ base_path = first(splitdir(base_file)) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1031 =# │ base_path = pwd() │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1035 =# │ try │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1036 =# │ (import_base_path, import_aliases) = imports[dotted_path] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =# @assert base_path == import_base_path "Inconsistent base path: $(base_path) != $(import_base_path)" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1038 =# │ merge!(import_aliases, aliases) │ catch e │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1040 =# │ if e isa KeyError │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1041 =# │ imports[dotted_path] = (base_path, aliases) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1043 =# │ rethrow(e) │ end │ end │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1046 =# stmt.data == "declare" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1047 =# │ for t = stmt.children │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1048 =# │ push!(term_defs, [t.value, (nothing, nothing)]) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1049 =# │ end │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =# @assert false stmt │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1053 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1056 =# │ for (dotted_path, ba) = imports │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1057 =# │ (base_path, aliases) = ba │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1058 =# │ grammar_path = joinpath([x.value for x = dotted_path...]...) * EXT │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1059 =# │ g = import_grammar(gl, grammar_path, base_path = base_path, import_paths = import_paths) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1060 =# │ (new_td, new_rd) = import_from_grammar_into_namespace(g, join([x.value for x = dotted_path...], "__"), aliases) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1062 =# │ append!(term_defs, new_td) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1063 =# │ append!(rule_defs, new_rd) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1064 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1067 =# │ for (name, _) = term_defs │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1068 =# │ if startswith(name, "__") │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1069 =# │ throw(GrammarError("Names starting with double-underscore are reserved (Error at $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1071 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1077 =# │ ignore_names = [] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1078 =# │ for t = ignore │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1079 =# │ if t.data == "expansions" && length(t.children) == 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1080 =# │ t2 = t.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1081 =# │ if t2.data == "expansion" && length(t2.children) == 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1082 =# │ item = t2.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1083 =# │ if item.data == "value" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1084 =# │ item = item.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1085 =# │ if item isa Token && item.type_ == "TERMINAL" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1086 =# │ push!(ignore_names, item.value) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1087 =# │ continue │ end │ end │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1094 =# │ name = "__IGNORE_$(length(ignore_names))" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1095 =# │ push!(ignore_names, name) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1096 =# │ push!(term_defs, (name, (t, 0))) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1097 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1099 =# │ terminal_names = Set() │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1100 =# │ for (name, _) = term_defs │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1101 =# │ if name in terminal_names │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1102 =# │ throw(GrammarError("Terminal '$(name)' defined more than once")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1105 =# │ push!(terminal_names, name) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1106 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1108 =# │ if Set(ignore_names) > terminal_names │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1109 =# │ throw(GrammarError("Terminals $(setdiff(ignore_names, terminal_names)) were marked to ignore but were not defined!")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1112 =# │ resolve_term_references(term_defs) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1113 =# │ rules = rule_defs │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1114 =# │ rule_names = Dict() │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1116 =# │ if gl.global_keep_all_tokens │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1117 =# │ rules = [(a, b, c, RuleOptions(d, true)) for (a, b, c, d) = rules] │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1119 =# │ for (name, params, _x, option) = rules │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1120 =# │ if gl.global_keep_all_tokens │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1121 =# │ option = RuleOptions(option, true) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1123 =# │ if startswith(name, "__") │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1124 =# │ throw(GrammarError("Names starting with double-underscore are reserved (Error at $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1127 =# │ if name in keys(rule_names) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1128 =# │ throw(GrammarError("Rule '$(name)' defined more than once")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1130 =# │ rule_names[name] = length(params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1131 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1135 =# │ for (name, params, expansions, _o) = rules │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1136 =# │ for (i, p) = enumerate(params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1137 =# │ if p in keys(rule_names) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1138 =# │ throw(GrammarError("Template Parameter conflicts with rule $(p) (in template $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1140 =# │ if p in params[1:i - 1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1141 =# │ throw(GrammarError("Duplicate Template Parameter $(p) (in template $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1143 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1144 =# │ for temp = find_data(expansions, "template_usage") │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1145 =# │ sym = temp.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1146 =# │ args = temp.children[2:var"end"] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1147 =# │ if !(sym in params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1148 =# │ if !(sym in keys(rule_names)) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1149 =# │ throw(GrammarError("Template '$(sym)' used but not defined (in rule $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1151 =# │ if length(args) != rule_names[sym] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1152 =# │ throw(GrammarError("Wrong number of template arguments used for $(sym) (expected $(rule_names[sym]), got $(length(args))) (in rule $(name))")) │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1155 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1157 =# │ for sym = _find_used_symbols(expansions) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1158 =# │ if sym.type_ == "TERMINAL" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1159 =# │ if !(sym in terminal_names) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1160 =# │ throw(GrammarError("Token '$(sym)' used but not defined (in rule $(name))")) │ end │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1163 =# │ if !(sym in keys(rule_names)) && !(sym in params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1164 =# │ throw(GrammarError("Rule '$(sym)' used but not defined (in rule $(name))")) │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1167 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1168 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1169 =# │ return Grammar(rules, term_defs, ignore_names) │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 =#) :: Value │ │ "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." :: Value │ │ [=] │ │ [call] │ │ load_grammar :: Identifier │ │ [parameters] │ │ [kw] │ │ grammar_name :: Identifier │ │ "" :: Value │ │ [kw] │ │ import_paths :: Identifier │ │ [vect] │ │ [::] │ │ gl :: Identifier │ │ GrammarLoader :: Identifier │ │ grammar_text :: Identifier │ │ [block] │ │ [try] │ │ [block] │ │ [=] │ │ tree :: Identifier │ │ [call] │ │ transform :: Identifier │ │ [call] │ │ CanonizeTree :: Identifier │ │ [call] │ │ parse :: Identifier │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ parser :: Identifier │ │ [call] │ │ * :: Identifier │ │ grammar_text :: Identifier │ │ "\n" :: Value │ │ e :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ e :: Identifier │ │ UnexpectedCharacters :: Identifier │ │ [block] │ │ [=] │ │ context :: Identifier │ │ [call] │ │ get_context :: Identifier │ │ e :: Identifier │ │ grammar_text :: Identifier │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Unexpected input at line " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ │ e :: Identifier │ │ ".column in " :: Value │ │ grammar_name :: Identifier │ │ ": \n\n" :: Value │ │ context :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ isa :: Identifier │ │ e :: Identifier │ │ UnexpectedToken :: Identifier │ │ [block] │ │ [=] │ │ context :: Identifier │ │ [call] │ │ get_context :: Identifier │ │ e :: Identifier │ │ grammar_text :: Identifier │ │ [=] │ │ error :: Identifier │ │ [call] │ │ match_examples :: Identifier │ │ e :: Identifier │ │ [call] │ │ partial :: Identifier │ │ parse :: Identifier │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ parser :: Identifier │ │ ERRORS :: Identifier │ │ [kw] │ │ use_accepts :: Identifier │ │ true :: Value │ │ [if] │ │ [call] │ │ != :: Identifier │ │ error :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ error :: Identifier │ │ " at line " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ │ context :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ occursin :: Identifier │ │ "STRING" :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ expected :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Expecting a value at line " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ │ context :: Identifier │ │ [call] │ │ rethrow :: Identifier │ │ e :: Identifier │ │ [=] │ │ tree :: Identifier │ │ [call] │ │ transform :: Identifier │ │ [call] │ │ PrepareGrammar :: Identifier │ │ tree :: Identifier │ │ [=] │ │ defs :: Identifier │ │ [call] │ │ classify :: Identifier │ │ [.] │ │ tree :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [kw] │ │ key :: Identifier │ │ [->] │ │ c :: Identifier │ │ [block] │ │ [.] │ │ c :: Identifier │ │ [inert] │ │ data :: Identifier │ │ [kw] │ │ value :: Identifier │ │ [->] │ │ c :: Identifier │ │ [block] │ │ [.] │ │ c :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [=] │ │ term_defs :: Identifier │ │ [call] │ │ pop! :: Identifier │ │ defs :: Identifier │ │ "term" :: Value │ │ [vect] │ │ [=] │ │ rule_defs :: Identifier │ │ [call] │ │ pop! :: Identifier │ │ defs :: Identifier │ │ "rule" :: Value │ │ [vect] │ │ [=] │ │ statements :: Identifier │ │ [call] │ │ pop! :: Identifier │ │ defs :: Identifier │ │ "statement" :: Value │ │ [vect] │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =#) :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ defs :: Identifier │ │ 0 :: Value │ │ [=] │ │ term_defs :: Identifier │ │ [comprehension] │ │ [generator] │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ td :: Identifier │ │ 3 :: Value │ │ [block] │ │ td :: Identifier │ │ [block] │ │ [vect] │ │ [ref] │ │ td :: Identifier │ │ 1 :: Value │ │ 1 :: Value │ │ [ref] │ │ td :: Identifier │ │ 2 :: Value │ │ [=] │ │ td :: Identifier │ │ term_defs :: Identifier │ │ [=] │ │ term_defs :: Identifier │ │ [comprehension] │ │ [generator] │ │ [tuple] │ │ [.] │ │ name :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ t :: Identifier │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [<:] │ │ [call] │ │ typeof :: Identifier │ │ p :: Identifier │ │ Int :: Identifier │ │ [block] │ │ [call] │ │ [.] │ │ Base :: Identifier │ │ [inert] │ │ parse :: Identifier │ │ Int64 :: Identifier │ │ [.] │ │ p :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [block] │ │ p :: Identifier │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ p :: Identifier │ │ t :: Identifier │ │ term_defs :: Identifier │ │ [=] │ │ rule_defs :: Identifier │ │ [typed_comprehension] │ │ Any :: Identifier │ │ [generator] │ │ [call] │ │ options_from_rule :: Identifier │ │ [ref] │ │ x :: Identifier │ │ 1 :: Value │ │ [...] │ │ [ref] │ │ x :: Identifier │ │ [call] │ │ : :: Identifier │ │ 2 :: Value │ │ end :: Identifier │ │ [=] │ │ x :: Identifier │ │ rule_defs :: Identifier │ │ [=] │ │ [tuple] │ │ ignore :: Identifier │ │ imports :: Identifier │ │ [tuple] │ │ [vect] │ │ [call] │ │ Dict :: Identifier │ │ [for] │ │ [=] │ │ a_stmt :: Identifier │ │ statements :: Identifier │ │ [block] │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =#) :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ a_stmt :: Identifier │ │ 1 :: Value │ │ [=] │ │ stmt :: Identifier │ │ [ref] │ │ a_stmt :: Identifier │ │ 1 :: Value │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "ignore" :: Value │ │ [block] │ │ [=] │ │ t :: Identifier │ │ [ref] │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [call] │ │ push! :: Identifier │ │ ignore :: Identifier │ │ t :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "import" :: Value │ │ [block] │ │ [if] │ │ [call] │ │ > :: Identifier │ │ [call] │ │ length :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [block] │ │ [=] │ │ [tuple] │ │ path_node :: Identifier │ │ arg1 :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [block] │ │ [=] │ │ path_node :: Identifier │ │ [ref] │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [=] │ │ arg1 :: Identifier │ │ nothing :: Identifier │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ arg1 :: Identifier │ │ Tree :: Identifier │ │ [block] │ │ [=] │ │ dotted_path :: Identifier │ │ [call] │ │ tuple :: Identifier │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [=] │ │ names :: Identifier │ │ [.] │ │ arg1 :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [=] │ │ aliases :: Identifier │ │ [call] │ │ Dict :: Identifier │ │ [call] │ │ zip :: Identifier │ │ names :: Identifier │ │ names :: Identifier │ │ [block] │ │ [=] │ │ dotted_path :: Identifier │ │ [call] │ │ tuple :: Identifier │ │ [ref] │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ │ 1 :: Value │ │ [call] │ │ - :: Identifier │ │ end :: Identifier │ │ 1 :: Value │ │ [=] │ │ name :: Identifier │ │ [ref] │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ children :: Identifier │ │ end :: Identifier │ │ [=] │ │ aliases :: Identifier │ │ [call] │ │ Dict :: Identifier │ │ [call] │ │ => :: Identifier │ │ name :: Identifier │ │ [if] │ │ [call] │ │ !== :: Identifier │ │ arg1 :: Identifier │ │ nothing :: Identifier │ │ arg1 :: Identifier │ │ name :: Identifier │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "import_lib" :: Value │ │ [block] │ │ [=] │ │ base_path :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ │ grammar_name :: Identifier │ │ "" :: Value │ │ [block] │ │ [=] │ │ base_file :: Identifier │ │ [call] │ │ abspath :: Identifier │ │ PROGRAM_FILE :: Identifier │ │ [block] │ │ [=] │ │ base_file :: Identifier │ │ grammar_name :: Identifier │ │ [if] │ │ [call] │ │ !== :: Identifier │ │ base_file :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [=] │ │ base_path :: Identifier │ │ [call] │ │ first :: Identifier │ │ [call] │ │ splitdir :: Identifier │ │ base_file :: Identifier │ │ [block] │ │ [=] │ │ base_path :: Identifier │ │ [call] │ │ pwd :: Identifier │ │ [try] │ │ [block] │ │ [=] │ │ [tuple] │ │ import_base_path :: Identifier │ │ import_aliases :: Identifier │ │ [ref] │ │ imports :: Identifier │ │ dotted_path :: Identifier │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =#) :: Value │ │ [call] │ │ == :: Identifier │ │ base_path :: Identifier │ │ import_base_path :: Identifier │ │ [string] │ │ "Inconsistent base path: " :: Value │ │ base_path :: Identifier │ │ " != " :: Value │ │ import_base_path :: Identifier │ │ [call] │ │ merge! :: Identifier │ │ import_aliases :: Identifier │ │ aliases :: Identifier │ │ e :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ e :: Identifier │ │ KeyError :: Identifier │ │ [block] │ │ [=] │ │ [ref] │ │ imports :: Identifier │ │ dotted_path :: Identifier │ │ [tuple] │ │ base_path :: Identifier │ │ aliases :: Identifier │ │ [block] │ │ [call] │ │ rethrow :: Identifier │ │ e :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "declare" :: Value │ │ [block] │ │ [for] │ │ [=] │ │ t :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [block] │ │ [call] │ │ push! :: Identifier │ │ term_defs :: Identifier │ │ [vect] │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ nothing :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =#) :: Value │ │ false :: Value │ │ stmt :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ dotted_path :: Identifier │ │ ba :: Identifier │ │ imports :: Identifier │ │ [block] │ │ [=] │ │ [tuple] │ │ base_path :: Identifier │ │ aliases :: Identifier │ │ ba :: Identifier │ │ [=] │ │ grammar_path :: Identifier │ │ [call] │ │ * :: Identifier │ │ [call] │ │ joinpath :: Identifier │ │ [...] │ │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ │ [...] │ │ dotted_path :: Identifier │ │ EXT :: Identifier │ │ [=] │ │ g :: Identifier │ │ [call] │ │ import_grammar :: Identifier │ │ gl :: Identifier │ │ grammar_path :: Identifier │ │ [kw] │ │ base_path :: Identifier │ │ base_path :: Identifier │ │ [kw] │ │ import_paths :: Identifier │ │ import_paths :: Identifier │ │ [=] │ │ [tuple] │ │ new_td :: Identifier │ │ new_rd :: Identifier │ │ [call] │ │ import_from_grammar_into_namespace :: Identifier │ │ g :: Identifier │ │ [call] │ │ join :: Identifier │ │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ │ [...] │ │ dotted_path :: Identifier │ │ "__" :: Value │ │ aliases :: Identifier │ │ [call] │ │ append! :: Identifier │ │ term_defs :: Identifier │ │ new_td :: Identifier │ │ [call] │ │ append! :: Identifier │ │ rule_defs :: Identifier │ │ new_rd :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ _ :: Identifier │ │ term_defs :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ startswith :: Identifier │ │ name :: Identifier │ │ "__" :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [=] │ │ ignore_names :: Identifier │ │ [vect] │ │ [for] │ │ [=] │ │ t :: Identifier │ │ ignore :: Identifier │ │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "expansions" :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [block] │ │ [=] │ │ t2 :: Identifier │ │ [ref] │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ t2 :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "expansion" :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ [.] │ │ t2 :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [block] │ │ [=] │ │ item :: Identifier │ │ [ref] │ │ [.] │ │ t2 :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "value" :: Value │ │ [block] │ │ [=] │ │ item :: Identifier │ │ [ref] │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [if] │ │ [&&] │ │ [call] │ │ isa :: Identifier │ │ item :: Identifier │ │ Token :: Identifier │ │ [call] │ │ == :: Identifier │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ │ [block] │ │ [call] │ │ push! :: Identifier │ │ ignore_names :: Identifier │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [continue] │ │ [=] │ │ name :: Identifier │ │ [string] │ │ "__IGNORE_" :: Value │ │ [call] │ │ length :: Identifier │ │ ignore_names :: Identifier │ │ [call] │ │ push! :: Identifier │ │ ignore_names :: Identifier │ │ name :: Identifier │ │ [call] │ │ push! :: Identifier │ │ term_defs :: Identifier │ │ [tuple] │ │ name :: Identifier │ │ [tuple] │ │ t :: Identifier │ │ 0 :: Value │ │ [=] │ │ terminal_names :: Identifier │ │ [call] │ │ Set :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ _ :: Identifier │ │ term_defs :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ │ name :: Identifier │ │ terminal_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Terminal '" :: Value │ │ name :: Identifier │ │ "' defined more than once" :: Value │ │ [call] │ │ push! :: Identifier │ │ terminal_names :: Identifier │ │ name :: Identifier │ │ [if] │ │ [call] │ │ > :: Identifier │ │ [call] │ │ Set :: Identifier │ │ ignore_names :: Identifier │ │ terminal_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Terminals " :: Value │ │ [call] │ │ setdiff :: Identifier │ │ ignore_names :: Identifier │ │ terminal_names :: Identifier │ │ " were marked to ignore but were not defined!" :: Value │ │ [call] │ │ resolve_term_references :: Identifier │ │ term_defs :: Identifier │ │ [=] │ │ rules :: Identifier │ │ rule_defs :: Identifier │ │ [=] │ │ rule_names :: Identifier │ │ [call] │ │ Dict :: Identifier │ │ [if] │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ rules :: Identifier │ │ [comprehension] │ │ [generator] │ │ [tuple] │ │ a :: Identifier │ │ b :: Identifier │ │ c :: Identifier │ │ [call] │ │ RuleOptions :: Identifier │ │ d :: Identifier │ │ true :: Value │ │ [=] │ │ [tuple] │ │ a :: Identifier │ │ b :: Identifier │ │ c :: Identifier │ │ d :: Identifier │ │ rules :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ params :: Identifier │ │ _x :: Identifier │ │ option :: Identifier │ │ rules :: Identifier │ │ [block] │ │ [if] │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ option :: Identifier │ │ [call] │ │ RuleOptions :: Identifier │ │ option :: Identifier │ │ true :: Value │ │ [if] │ │ [call] │ │ startswith :: Identifier │ │ name :: Identifier │ │ "__" :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [if] │ │ [call] │ │ in :: Identifier │ │ name :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Rule '" :: Value │ │ name :: Identifier │ │ "' defined more than once" :: Value │ │ [=] │ │ [ref] │ │ rule_names :: Identifier │ │ name :: Identifier │ │ [call] │ │ length :: Identifier │ │ params :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ params :: Identifier │ │ expansions :: Identifier │ │ _o :: Identifier │ │ rules :: Identifier │ │ [block] │ │ [for] │ │ [=] │ │ [tuple] │ │ i :: Identifier │ │ p :: Identifier │ │ [call] │ │ enumerate :: Identifier │ │ params :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ │ p :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Template Parameter conflicts with rule " :: Value │ │ p :: Identifier │ │ " (in template " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [if] │ │ [call] │ │ in :: Identifier │ │ p :: Identifier │ │ [ref] │ │ params :: Identifier │ │ [call] │ │ : :: Identifier │ │ 1 :: Value │ │ [call] │ │ - :: Identifier │ │ i :: Identifier │ │ 1 :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Duplicate Template Parameter " :: Value │ │ p :: Identifier │ │ " (in template " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [for] │ │ [=] │ │ temp :: Identifier │ │ [call] │ │ find_data :: Identifier │ │ expansions :: Identifier │ │ "template_usage" :: Value │ │ [block] │ │ [=] │ │ sym :: Identifier │ │ [ref] │ │ [.] │ │ temp :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [=] │ │ args :: Identifier │ │ [ref] │ │ [.] │ │ temp :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ │ 2 :: Value │ │ end :: Identifier │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ params :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Template '" :: Value │ │ sym :: Identifier │ │ "' used but not defined (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [if] │ │ [call] │ │ != :: Identifier │ │ [call] │ │ length :: Identifier │ │ args :: Identifier │ │ [ref] │ │ rule_names :: Identifier │ │ sym :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Wrong number of template arguments used for " :: Value │ │ sym :: Identifier │ │ " (expected " :: Value │ │ [ref] │ │ rule_names :: Identifier │ │ sym :: Identifier │ │ ", got " :: Value │ │ [call] │ │ length :: Identifier │ │ args :: Identifier │ │ ") (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [for] │ │ [=] │ │ sym :: Identifier │ │ [call] │ │ _find_used_symbols :: Identifier │ │ expansions :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ sym :: Identifier │ │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ terminal_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Token '" :: Value │ │ sym :: Identifier │ │ "' used but not defined (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ params :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Rule '" :: Value │ │ sym :: Identifier │ │ "' used but not defined (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [return] │ │ [call] │ │ Grammar :: Identifier │ │ rules :: Identifier │ │ term_defs :: Identifier │ │ ignore_names :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [=] │ │ [call] │ │ load_grammar :: Identifier │ scope_layer=1 │ [parameters] │ │ [kw] │ │ grammar_name :: Identifier │ scope_layer=1 │ "" :: Value │ macro_source=1141 │ [kw] │ │ import_paths :: Identifier │ scope_layer=1 │ [vect] │ macro_source=1141 │ [::] │ │ gl :: Identifier │ scope_layer=1 │ GrammarLoader :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ [block] │ │ [try] │ │ [block] │ │ [=] │ │ tree :: Identifier │ scope_layer=1 │ [call] │ │ transform :: Identifier │ scope_layer=1 │ [call] │ │ CanonizeTree :: Identifier │ scope_layer=1 │ [call] │ │ parse :: Identifier │ scope_layer=1 │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ parser :: Identifier │ │ [call] │ │ * :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ "\n" :: Value │ macro_source=1141 │ e :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ UnexpectedCharacters :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ context :: Identifier │ scope_layer=1 │ [call] │ │ get_context :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Unexpected input at line " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ macro_source=1141 │ e :: Identifier │ scope_layer=1 │ ".column in " :: Value │ macro_source=1141 │ grammar_name :: Identifier │ scope_layer=1 │ ": \n\n" :: Value │ macro_source=1141 │ context :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ UnexpectedToken :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ context :: Identifier │ scope_layer=1 │ [call] │ │ get_context :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ [=] │ │ error :: Identifier │ scope_layer=1 │ [call] │ │ match_examples :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [call] │ │ partial :: Identifier │ scope_layer=1 │ parse :: Identifier │ scope_layer=1 │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ parser :: Identifier │ │ ERRORS :: Identifier │ scope_layer=1 │ [kw] │ │ use_accepts :: Identifier │ scope_layer=1 │ true :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ != :: Identifier │ scope_layer=1 │ error :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ error :: Identifier │ scope_layer=1 │ " at line " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ macro_source=1141 │ context :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ occursin :: Identifier │ scope_layer=1 │ "STRING" :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ expected :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Expecting a value at line " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ macro_source=1141 │ context :: Identifier │ scope_layer=1 │ [call] │ │ rethrow :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [=] │ │ tree :: Identifier │ scope_layer=1 │ [call] │ │ transform :: Identifier │ scope_layer=1 │ [call] │ │ PrepareGrammar :: Identifier │ scope_layer=1 │ tree :: Identifier │ scope_layer=1 │ [=] │ │ defs :: Identifier │ scope_layer=1 │ [call] │ │ classify :: Identifier │ scope_layer=1 │ [.] │ │ tree :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [kw] │ │ key :: Identifier │ scope_layer=1 │ [->] │ │ c :: Identifier │ scope_layer=1 │ [block] │ │ [.] │ │ c :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ [kw] │ │ value :: Identifier │ scope_layer=1 │ [->] │ │ c :: Identifier │ scope_layer=1 │ [block] │ │ [.] │ │ c :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [=] │ │ term_defs :: Identifier │ scope_layer=1 │ [call] │ │ pop! :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ "term" :: Value │ macro_source=1141 │ [vect] │ macro_source=1141 │ [=] │ │ rule_defs :: Identifier │ scope_layer=1 │ [call] │ │ pop! :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ "rule" :: Value │ macro_source=1141 │ [vect] │ macro_source=1141 │ [=] │ │ statements :: Identifier │ scope_layer=1 │ [call] │ │ pop! :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ "statement" :: Value │ macro_source=1141 │ [vect] │ macro_source=1141 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=1141 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "length(defs) == 0" :: Value │ macro_source=1141 │ [=] │ │ term_defs :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ td :: Identifier │ scope_layer=1 │ 3 :: Value │ macro_source=1141 │ [block] │ │ td :: Identifier │ scope_layer=1 │ [block] │ │ [vect] │ │ [ref] │ │ td :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ 1 :: Value │ macro_source=1141 │ [ref] │ │ td :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=1141 │ [=] │ │ td :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [=] │ │ term_defs :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [tuple] │ │ [.] │ │ name :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ t :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [call] │ │ typeof :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ [.] │ │ Base :: Identifier │ scope_layer=1 │ [inert] │ │ parse :: Identifier │ │ Int64 :: Identifier │ scope_layer=1 │ [.] │ │ p :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [block] │ │ p :: Identifier │ scope_layer=1 │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ t :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [=] │ │ rule_defs :: Identifier │ scope_layer=1 │ [typed_comprehension] │ │ Any :: Identifier │ scope_layer=1 │ [generator] │ │ [call] │ │ options_from_rule :: Identifier │ scope_layer=1 │ [ref] │ │ x :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [...] │ │ [ref] │ │ x :: Identifier │ scope_layer=1 │ [call] │ │ : :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=1141 │ end :: Identifier │ scope_layer=1 │ [=] │ │ x :: Identifier │ scope_layer=1 │ rule_defs :: Identifier │ scope_layer=1 │ [=] │ │ [tuple] │ │ ignore :: Identifier │ scope_layer=1 │ imports :: Identifier │ scope_layer=1 │ [tuple] │ │ [vect] │ macro_source=1141 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ a_stmt :: Identifier │ scope_layer=1 │ statements :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ a_stmt :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "length(a_stmt) == 1" :: Value │ macro_source=1141 │ [=] │ │ stmt :: Identifier │ scope_layer=1 │ [ref] │ │ a_stmt :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "ignore" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ t :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ ignore :: Identifier │ scope_layer=1 │ t :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "import" :: Value │ macro_source=1141 │ [block] │ │ [if] │ │ [call] │ │ > :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ [tuple] │ │ path_node :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [block] │ │ [=] │ │ path_node :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [=] │ │ arg1 :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ Tree :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ dotted_path :: Identifier │ scope_layer=1 │ [call] │ │ tuple :: Identifier │ scope_layer=1 │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [=] │ │ names :: Identifier │ scope_layer=1 │ [.] │ │ arg1 :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [=] │ │ aliases :: Identifier │ scope_layer=1 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [call] │ │ zip :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ dotted_path :: Identifier │ scope_layer=1 │ [call] │ │ tuple :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [call] │ │ - :: Identifier │ scope_layer=1 │ end :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [=] │ │ name :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ end :: Identifier │ scope_layer=1 │ [=] │ │ aliases :: Identifier │ scope_layer=1 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [call] │ │ => :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ !== :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "import_lib" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ base_path :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ grammar_name :: Identifier │ scope_layer=1 │ "" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ base_file :: Identifier │ scope_layer=1 │ [call] │ │ abspath :: Identifier │ scope_layer=1 │ PROGRAM_FILE :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ base_file :: Identifier │ scope_layer=1 │ grammar_name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ !== :: Identifier │ scope_layer=1 │ base_file :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ base_path :: Identifier │ scope_layer=1 │ [call] │ │ first :: Identifier │ scope_layer=1 │ [call] │ │ splitdir :: Identifier │ scope_layer=1 │ base_file :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ base_path :: Identifier │ scope_layer=1 │ [call] │ │ pwd :: Identifier │ scope_layer=1 │ [try] │ │ [block] │ │ [=] │ │ [tuple] │ │ import_base_path :: Identifier │ scope_layer=1 │ import_aliases :: Identifier │ scope_layer=1 │ [ref] │ │ imports :: Identifier │ scope_layer=1 │ dotted_path :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ base_path :: Identifier │ scope_layer=1 │ import_base_path :: Identifier │ scope_layer=1 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ [call] │ │ Base._assert_tostring :: Value │ macro_source=1141 │ [string] │ │ "Inconsistent base path: " :: Value │ macro_source=1141 │ base_path :: Identifier │ scope_layer=1 │ " != " :: Value │ macro_source=1141 │ import_base_path :: Identifier │ scope_layer=1 │ [call] │ │ merge! :: Identifier │ scope_layer=1 │ import_aliases :: Identifier │ scope_layer=1 │ aliases :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ KeyError :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ [ref] │ │ imports :: Identifier │ scope_layer=1 │ dotted_path :: Identifier │ scope_layer=1 │ [tuple] │ │ base_path :: Identifier │ scope_layer=1 │ aliases :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ rethrow :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "declare" :: Value │ macro_source=1141 │ [block] │ │ [for] │ │ [=] │ │ t :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [block] │ │ [call] │ │ push! :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [vect] │ │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ nothing :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ false :: Value │ macro_source=1141 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ [call] │ │ Base._assert_tostring :: Value │ macro_source=1141 │ stmt :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ dotted_path :: Identifier │ scope_layer=1 │ ba :: Identifier │ scope_layer=1 │ imports :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ [tuple] │ │ base_path :: Identifier │ scope_layer=1 │ aliases :: Identifier │ scope_layer=1 │ ba :: Identifier │ scope_layer=1 │ [=] │ │ grammar_path :: Identifier │ scope_layer=1 │ [call] │ │ * :: Identifier │ scope_layer=1 │ [call] │ │ joinpath :: Identifier │ scope_layer=1 │ [...] │ │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ scope_layer=1 │ [...] │ │ dotted_path :: Identifier │ scope_layer=1 │ EXT :: Identifier │ scope_layer=1 │ [=] │ │ g :: Identifier │ scope_layer=1 │ [call] │ │ import_grammar :: Identifier │ scope_layer=1 │ gl :: Identifier │ scope_layer=1 │ grammar_path :: Identifier │ scope_layer=1 │ [kw] │ │ base_path :: Identifier │ scope_layer=1 │ base_path :: Identifier │ scope_layer=1 │ [kw] │ │ import_paths :: Identifier │ scope_layer=1 │ import_paths :: Identifier │ scope_layer=1 │ [=] │ │ [tuple] │ │ new_td :: Identifier │ scope_layer=1 │ new_rd :: Identifier │ scope_layer=1 │ [call] │ │ import_from_grammar_into_namespace :: Identifier │ scope_layer=1 │ g :: Identifier │ scope_layer=1 │ [call] │ │ join :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ scope_layer=1 │ [...] │ │ dotted_path :: Identifier │ scope_layer=1 │ "__" :: Value │ macro_source=1141 │ aliases :: Identifier │ scope_layer=1 │ [call] │ │ append! :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ new_td :: Identifier │ scope_layer=1 │ [call] │ │ append! :: Identifier │ scope_layer=1 │ rule_defs :: Identifier │ scope_layer=1 │ new_rd :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ _ :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ startswith :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ "__" :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [=] │ │ ignore_names :: Identifier │ scope_layer=1 │ [vect] │ macro_source=1141 │ [for] │ │ [=] │ │ t :: Identifier │ scope_layer=1 │ ignore :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "expansions" :: Value │ macro_source=1141 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ t2 :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ t2 :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "expansion" :: Value │ macro_source=1141 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ [.] │ │ t2 :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ item :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ t2 :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "value" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ item :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [if] │ │ [&&] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ item :: Identifier │ scope_layer=1 │ Token :: Identifier │ scope_layer=1 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ push! :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [continue] │ macro_source=1141 │ [=] │ │ name :: Identifier │ scope_layer=1 │ [string] │ │ "__IGNORE_" :: Value │ macro_source=1141 │ [call] │ │ length :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ [tuple] │ │ t :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=1141 │ [=] │ │ terminal_names :: Identifier │ scope_layer=1 │ [call] │ │ Set :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ _ :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Terminal '" :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ "' defined more than once" :: Value │ macro_source=1141 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ > :: Identifier │ scope_layer=1 │ [call] │ │ Set :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Terminals " :: Value │ macro_source=1141 │ [call] │ │ setdiff :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ " were marked to ignore but were not defined!" :: Value │ macro_source=1141 │ [call] │ │ resolve_term_references :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [=] │ │ rules :: Identifier │ scope_layer=1 │ rule_defs :: Identifier │ scope_layer=1 │ [=] │ │ rule_names :: Identifier │ scope_layer=1 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [if] │ │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ rules :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [tuple] │ │ a :: Identifier │ scope_layer=1 │ b :: Identifier │ scope_layer=1 │ c :: Identifier │ scope_layer=1 │ [call] │ │ RuleOptions :: Identifier │ scope_layer=1 │ d :: Identifier │ scope_layer=1 │ true :: Value │ macro_source=1141 │ [=] │ │ [tuple] │ │ a :: Identifier │ scope_layer=1 │ b :: Identifier │ scope_layer=1 │ c :: Identifier │ scope_layer=1 │ d :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ _x :: Identifier │ scope_layer=1 │ option :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ option :: Identifier │ scope_layer=1 │ [call] │ │ RuleOptions :: Identifier │ scope_layer=1 │ option :: Identifier │ scope_layer=1 │ true :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ startswith :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ "__" :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Rule '" :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ "' defined more than once" :: Value │ macro_source=1141 │ [=] │ │ [ref] │ │ rule_names :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ expansions :: Identifier │ scope_layer=1 │ _o :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ [block] │ │ [for] │ │ [=] │ │ [tuple] │ │ i :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ [call] │ │ enumerate :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Template Parameter conflicts with rule " :: Value │ macro_source=1141 │ p :: Identifier │ scope_layer=1 │ " (in template " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ [ref] │ │ params :: Identifier │ scope_layer=1 │ [call] │ │ : :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [call] │ │ - :: Identifier │ scope_layer=1 │ i :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Duplicate Template Parameter " :: Value │ macro_source=1141 │ p :: Identifier │ scope_layer=1 │ " (in template " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [for] │ │ [=] │ │ temp :: Identifier │ scope_layer=1 │ [call] │ │ find_data :: Identifier │ scope_layer=1 │ expansions :: Identifier │ scope_layer=1 │ "template_usage" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ sym :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ temp :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [=] │ │ args :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ temp :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=1141 │ end :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Template '" :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ "' used but not defined (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ != :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ args :: Identifier │ scope_layer=1 │ [ref] │ │ rule_names :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Wrong number of template arguments used for " :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ " (expected " :: Value │ macro_source=1141 │ [ref] │ │ rule_names :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ ", got " :: Value │ macro_source=1141 │ [call] │ │ length :: Identifier │ scope_layer=1 │ args :: Identifier │ scope_layer=1 │ ") (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [for] │ │ [=] │ │ sym :: Identifier │ scope_layer=1 │ [call] │ │ _find_used_symbols :: Identifier │ scope_layer=1 │ expansions :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ sym :: Identifier │ scope_layer=1 │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ macro_source=1141 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Token '" :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ "' used but not defined (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Rule '" :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ "' used but not defined (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [return] │ │ [call] │ │ Grammar :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=1141 │ Lerche :: Value │ macro_source=1141 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=1141 │ Lerche :: Value │ │ [inert] │ jl_source=L65 │ load_grammar :: Identifier │ │ [call] │ macro_source=1141 │ Base.Docs.docstr :: Value │ macro_source=1141 │ [call] │ macro_source=1141 │ Core.svec :: Value │ macro_source=1141 │ "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." :: Value │ macro_source=1141 │ [call] │ macro_source=1141 │ Dict{Symbol, Any} :: Value │ macro_source=1141 │ :path => "/home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl" :: Value │ macro_source=1141 │ :linenumber => 958 :: Value │ macro_source=1141 │ :module => Lerche :: Value │ macro_source=1141 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ GrammarLoader :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl" │ line = 958 └ mod = Lerche ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1058 =# - unexpected `...` splatting can only be done into a `call`, `tuple`, `curly`, or array-like expression Expression:  (... dotted_path) Containing expressions:  (comprehension (generator (. x (inert value)) (= x (... dotted_path))))  Detailed provenance:  (... dotted_path)  └─ (... dotted_path)  ├─ @ /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1058  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 =#) "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." (= (call load_grammar (parameters (kw grammar_name "") (kw import_paths (vect))) (:: gl GrammarLoader) grammar_text) (block (try (block (= tree (call transform (call CanonizeTree) (call parse (. gl (inert parser)) (call * grammar_text "\n"))))) e (block (if (call isa e UnexpectedCharacters) (block (= context (call get_context e grammar_text)) (call throw (call GrammarError (string "Unexpected input at line " (. e (inert line)) " column " e ".column in " grammar_name ": \n\n" context)))) (elseif (block (call isa e UnexpectedToken)) (block (= context (call get_context e grammar_text)) (= error (call match_examples e (call partial parse (. gl (inert parser))) ERRORS (kw use_accepts true))) (if (call != error nothing) (block (call throw (call GrammarError (string error " at line " (. e (inert line)) " column " (. e (inert column)) "\n\n" context)))) (elseif (block (call occursin "STRING" (. e (inert expected)))) (block (call throw (call GrammarError (string "Expecting a value at line " (. e (inert line)) " column " (. e (inert column)) "\n\n" context))))))))) (call rethrow e))) (= tree (call transform (call PrepareGrammar) tree)) (= defs (call classify (. tree (inert children)) (kw key (-> c (block (. c (inert data))))) (kw value (-> c (block (. c (inert children))))))) (= term_defs (call pop! defs "term" (vect))) (= rule_defs (call pop! defs "rule" (vect))) (= statements (call pop! defs "statement" (vect))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =#) (call == (call length defs) 0)) (= term_defs (comprehension (generator (if (call == (call length td) 3) (block td) (block (vect (ref td 1) 1 (ref td 2)))) (= td term_defs)))) (= term_defs (comprehension (generator (tuple (. name (inert value)) (tuple t (if (call ! (<: (call typeof p) Int)) (block (call (. Base (inert parse)) Int64 (. p (inert value)))) (block p)))) (= (tuple name p t) term_defs)))) (= rule_defs (typed_comprehension Any (generator (call options_from_rule (ref x 1) (... (ref x (call : 2 end)))) (= x rule_defs)))) (= (tuple ignore imports) (tuple (vect) (call Dict))) (for (= a_stmt statements) (block (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =#) (call == (call length a_stmt) 1)) (= stmt (ref a_stmt 1)) (if (call == (. stmt (inert data)) "ignore") (block (= t (ref (. stmt (inert children)) 1)) (call push! ignore t)) (elseif (block (call == (. stmt (inert data)) "import")) (block (if (call > (call length (. stmt (inert children))) 1) (block (= (tuple path_node arg1) (. stmt (inert children)))) (block (= path_node (ref (. stmt (inert children)) 1)) (= arg1 nothing))) (if (call isa arg1 Tree) (block (= dotted_path (call tuple (. path_node (inert children)))) (= names (. arg1 (inert children))) (= aliases (call Dict (call zip names names)))) (block (= dotted_path (call tuple (ref (. path_node (inert children)) (call : 1 (call - end 1))))) (= name (ref (. path_node (inert children)) end)) (= aliases (call Dict (call => name (if (call !== arg1 nothing) arg1 name)))))) (if (call == (. path_node (inert data)) "import_lib") (block (= base_path nothing)) (block (if (call == grammar_name "") (block (= base_file (call abspath PROGRAM_FILE))) (block (= base_file grammar_name))) (if (call !== base_file nothing) (block (= base_path (call first (call splitdir base_file)))) (block (= base_path (call pwd)))))) (try (block (= (tuple import_base_path import_aliases) (ref imports dotted_path)) (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =#) (call == base_path import_base_path) (string "Inconsistent base path: " base_path " != " import_base_path)) (call merge! import_aliases aliases)) e (block (if (call isa e KeyError) (block (= (ref imports dotted_path) (tuple base_path aliases))) (block (call rethrow e)))))) (elseif (block (call == (. stmt (inert data)) "declare")) (block (for (= t (. stmt (inert children))) (block (call push! term_defs (vect (. t (inert value)) (tuple nothing nothing)))))) (block (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =#) false stmt))))))) (for (= (tuple dotted_path ba) imports) (block (= (tuple base_path aliases) ba) (= grammar_path (call * (call joinpath (... (comprehension (generator (. x (inert value)) (= x (... dotted_path)))))) EXT)) (= g (call import_grammar gl grammar_path (kw base_path base_path) (kw import_paths import_paths))) (= (tuple new_td new_rd) (call import_from_grammar_into_namespace g (call join (comprehension (generator (. x (inert value)) (= x (... dotted_path)))) "__") aliases)) (call append! term_defs new_td) (call append! rule_defs new_rd))) (for (= (tuple name _) term_defs) (block (if (call startswith name "__") (block (call throw (call GrammarError (string "Names starting with double-underscore are reserved (Error at " name ")"))))))) (= ignore_names (vect)) (for (= t ignore) (block (if (&& (call == (. t (inert data)) "expansions") (call == (call length (. t (inert children))) 1)) (block (= t2 (ref (. t (inert children)) 1)) (if (&& (call == (. t2 (inert data)) "expansion") (call == (call length (. t2 (inert children))) 1)) (block (= item (ref (. t2 (inert children)) 1)) (if (call == (. item (inert data)) "value") (block (= item (ref (. item (inert children)) 1)) (if (&& (call isa item Token) (call == (. item (inert type_)) "TERMINAL")) (block (call push! ignore_names (. item (inert value))) (continue))))))))) (= name (string "__IGNORE_" (call length ignore_names))) (call push! ignore_names name) (call push! term_defs (tuple name (tuple t 0))))) (= terminal_names (call Set)) (for (= (tuple name _) term_defs) (block (if (call in name terminal_names) (block (call throw (call GrammarError (string "Terminal '" name "' defined more than once"))))) (call push! terminal_names name))) (if (call > (call Set ignore_names) terminal_names) (block (call throw (call GrammarError (string "Terminals " (call setdiff ignore_names terminal_names) " were marked to ignore but were not defined!"))))) (call resolve_term_references term_defs) (= rules rule_defs) (= rule_names (call Dict)) (if (. gl (inert global_keep_all_tokens)) (block (= rules (comprehension (generator (tuple a b c (call RuleOptions d true)) (= (tuple a b c d) rules)))))) (for (= (tuple name params _x option) rules) (block (if (. gl (inert global_keep_all_tokens)) (block (= option (call RuleOptions option true)))) (if (call startswith name "__") (block (call throw (call GrammarError (string "Names starting with double-underscore are reserved (Error at " name ")"))))) (if (call in name (call keys rule_names)) (block (call throw (call GrammarError (string "Rule '" name "' defined more than once"))))) (= (ref rule_names name) (call length params)))) (for (= (tuple name params expansions _o) rules) (block (for (= (tuple i p) (call enumerate params)) (block (if (call in p (call keys rule_names)) (block (call throw (call GrammarError (string "Template Parameter conflicts with rule " p " (in template " name ")"))))) (if (call in p (ref params (call : 1 (call - i 1)))) (block (call throw (call GrammarError (string "Duplicate Template Parameter " p " (in template " name ")"))))))) (for (= temp (call find_data expansions "template_usage")) (block (= sym (ref (. temp (inert children)) 1)) (= args (ref (. temp (inert children)) (call : 2 end))) (if (call ! (call in sym params)) (block (if (call ! (call in sym (call keys rule_names))) (block (call throw (call GrammarError (string "Template '" sym "' used but not defined (in rule " name ")"))))) (if (call != (call length args) (ref rule_names sym)) (block (call throw (call GrammarError (string "Wrong number of template arguments used for " sym " (expected " (ref rule_names sym) ", got " (call length args) ") (in rule " name ")"))))))))) (for (= sym (call _find_used_symbols expansions)) (block (if (call == (. sym (inert type_)) "TERMINAL") (block (if (call ! (call in sym terminal_names)) (block (call throw (call GrammarError (string "Token '" sym "' used but not defined (in rule " name ")")))))) (block (if (&& (call ! (call in sym (call keys rule_names))) (call ! (call in sym params))) (block (call throw (call GrammarError (string "Rule '" sym "' used but not defined (in rule " name ")"))))))))))) (return (call Grammar rules term_defs ignore_names)))))  └─ @ /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958  Stacktrace:  [1] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4448  [2] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [3] include(mapexpr::Function, mod::Module, _path::String)  @ Base Base.jl:327  [4] top-level scope  @ ~/.julia/packages/Lerche/bn9Mc/src/Lerche.jl:39  [5] include(mod::Module, _path::String)  @ Base Base.jl:326  [6] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [7] top-level scope  @ stdin:5  [8] eval(m::Module, e::Any)  @ Core boot.jl:521  [9] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [10] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [11] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [12] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 in expression starting at /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/Lerche.jl:1 in expression starting at stdin:5 ✗ Lerche 4 dependencies successfully precompiled in 440 seconds. 12 already precompiled. Precompilation completed after 473.54s ################################################################################ # Testing # Testing Lerche Status `/tmp/jl_6PzTe9/Project.toml` [d42ef402] Lerche v0.5.8 [8dfed614] Test v1.11.0 Status `/tmp/jl_6PzTe9/Manifest.toml` [864edb3b] DataStructures v0.19.5 [d42ef402] Lerche v0.5.8 ⌅ [bac558e1] OrderedCollections v1.8.2 [aea7be01] PrecompileTools v1.3.4 [21216c6a] Preferences v1.5.2 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [f489334b] StyledStrings v1.13.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [4ec0a83e] Unicode v1.11.0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 =# Core.@doc "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." load_grammar(gl::GrammarLoader, grammar_text; grammar_name = "", import_paths = []) = begin │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:959 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:960 =# │ try │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:961 =# │ tree = transform(CanonizeTree(), parse(gl.parser, grammar_text * "\n")) │ catch e │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:963 =# │ if e isa UnexpectedCharacters │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:964 =# │ context = get_context(e, grammar_text) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:965 =# │ throw(GrammarError("Unexpected input at line $(e.line) column $(e).column in $(grammar_name): \n\n$(context)")) │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:967 =# e isa UnexpectedToken │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:968 =# │ context = get_context(e, grammar_text) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:969 =# │ error = match_examples(e, partial(parse, gl.parser), ERRORS, use_accepts = true) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:970 =# │ if error != nothing │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:971 =# │ throw(GrammarError("$(error) at line $(e.line) column $(e.column)\n\n$(context)")) │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:973 =# occursin("STRING", e.expected) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:974 =# │ throw(GrammarError("Expecting a value at line $(e.line) column $(e.column)\n\n$(context)")) │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:977 =# │ rethrow(e) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:980 =# │ tree = transform(PrepareGrammar(), tree) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:983 =# │ defs = classify(tree.children, key = (c->begin │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:983 =# │ c.data │ end), value = (c->begin │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:983 =# │ c.children │ end)) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:984 =# │ term_defs = pop!(defs, "term", []) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:985 =# │ rule_defs = pop!(defs, "rule", []) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:986 =# │ statements = pop!(defs, "statement", []) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =# @assert length(defs) == 0 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:989 =# │ term_defs = [if length(td) == 3 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:989 =# │ td │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:989 =# │ [td[1], 1, td[2]] │ end for td = term_defs] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:990 =# │ term_defs = [(name.value, (t, if !(typeof(p) <: Int) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:990 =# │ Base.parse(Int64, p.value) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:990 =# │ p │ end)) for (name, p, t) = term_defs] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:991 =# │ rule_defs = Any[options_from_rule(x[1], x[2:var"end"]...) for x = rule_defs] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:996 =# │ (ignore, imports) = ([], Dict()) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:997 =# │ for a_stmt = statements │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =# @assert length(a_stmt) == 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:999 =# │ stmt = a_stmt[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1000 =# │ if stmt.data == "ignore" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1001 =# │ t = stmt.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1002 =# │ push!(ignore, t) │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1003 =# stmt.data == "import" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1004 =# │ if length(stmt.children) > 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1005 =# │ (path_node, arg1) = stmt.children │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1007 =# │ path_node = stmt.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1008 =# │ arg1 = nothing │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1010 =# │ if arg1 isa Tree │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1011 =# │ dotted_path = tuple(path_node.children) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1012 =# │ names = arg1.children │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1013 =# │ aliases = Dict(zip(names, names)) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1015 =# │ dotted_path = tuple(path_node.children[1:var"end" - 1]) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1016 =# │ name = path_node.children[var"end"] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1017 =# │ aliases = Dict(name => if arg1 !== nothing │ arg1 │ else │ name │ end) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1020 =# │ if path_node.data == "import_lib" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1021 =# │ base_path = nothing │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1023 =# │ if grammar_name == "" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1024 =# │ base_file = abspath(PROGRAM_FILE) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1026 =# │ base_file = grammar_name │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1028 =# │ if base_file !== nothing │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1029 =# │ base_path = first(splitdir(base_file)) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1031 =# │ base_path = pwd() │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1035 =# │ try │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1036 =# │ (import_base_path, import_aliases) = imports[dotted_path] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =# @assert base_path == import_base_path "Inconsistent base path: $(base_path) != $(import_base_path)" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1038 =# │ merge!(import_aliases, aliases) │ catch e │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1040 =# │ if e isa KeyError │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1041 =# │ imports[dotted_path] = (base_path, aliases) │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1043 =# │ rethrow(e) │ end │ end │ elseif #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1046 =# stmt.data == "declare" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1047 =# │ for t = stmt.children │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1048 =# │ push!(term_defs, [t.value, (nothing, nothing)]) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1049 =# │ end │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =# │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =# @assert false stmt │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1053 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1056 =# │ for (dotted_path, ba) = imports │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1057 =# │ (base_path, aliases) = ba │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1058 =# │ grammar_path = joinpath([x.value for x = dotted_path...]...) * EXT │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1059 =# │ g = import_grammar(gl, grammar_path, base_path = base_path, import_paths = import_paths) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1060 =# │ (new_td, new_rd) = import_from_grammar_into_namespace(g, join([x.value for x = dotted_path...], "__"), aliases) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1062 =# │ append!(term_defs, new_td) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1063 =# │ append!(rule_defs, new_rd) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1064 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1067 =# │ for (name, _) = term_defs │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1068 =# │ if startswith(name, "__") │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1069 =# │ throw(GrammarError("Names starting with double-underscore are reserved (Error at $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1071 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1077 =# │ ignore_names = [] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1078 =# │ for t = ignore │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1079 =# │ if t.data == "expansions" && length(t.children) == 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1080 =# │ t2 = t.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1081 =# │ if t2.data == "expansion" && length(t2.children) == 1 │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1082 =# │ item = t2.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1083 =# │ if item.data == "value" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1084 =# │ item = item.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1085 =# │ if item isa Token && item.type_ == "TERMINAL" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1086 =# │ push!(ignore_names, item.value) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1087 =# │ continue │ end │ end │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1094 =# │ name = "__IGNORE_$(length(ignore_names))" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1095 =# │ push!(ignore_names, name) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1096 =# │ push!(term_defs, (name, (t, 0))) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1097 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1099 =# │ terminal_names = Set() │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1100 =# │ for (name, _) = term_defs │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1101 =# │ if name in terminal_names │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1102 =# │ throw(GrammarError("Terminal '$(name)' defined more than once")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1105 =# │ push!(terminal_names, name) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1106 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1108 =# │ if Set(ignore_names) > terminal_names │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1109 =# │ throw(GrammarError("Terminals $(setdiff(ignore_names, terminal_names)) were marked to ignore but were not defined!")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1112 =# │ resolve_term_references(term_defs) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1113 =# │ rules = rule_defs │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1114 =# │ rule_names = Dict() │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1116 =# │ if gl.global_keep_all_tokens │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1117 =# │ rules = [(a, b, c, RuleOptions(d, true)) for (a, b, c, d) = rules] │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1119 =# │ for (name, params, _x, option) = rules │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1120 =# │ if gl.global_keep_all_tokens │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1121 =# │ option = RuleOptions(option, true) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1123 =# │ if startswith(name, "__") │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1124 =# │ throw(GrammarError("Names starting with double-underscore are reserved (Error at $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1127 =# │ if name in keys(rule_names) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1128 =# │ throw(GrammarError("Rule '$(name)' defined more than once")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1130 =# │ rule_names[name] = length(params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1131 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1135 =# │ for (name, params, expansions, _o) = rules │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1136 =# │ for (i, p) = enumerate(params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1137 =# │ if p in keys(rule_names) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1138 =# │ throw(GrammarError("Template Parameter conflicts with rule $(p) (in template $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1140 =# │ if p in params[1:i - 1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1141 =# │ throw(GrammarError("Duplicate Template Parameter $(p) (in template $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1143 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1144 =# │ for temp = find_data(expansions, "template_usage") │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1145 =# │ sym = temp.children[1] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1146 =# │ args = temp.children[2:var"end"] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1147 =# │ if !(sym in params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1148 =# │ if !(sym in keys(rule_names)) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1149 =# │ throw(GrammarError("Template '$(sym)' used but not defined (in rule $(name))")) │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1151 =# │ if length(args) != rule_names[sym] │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1152 =# │ throw(GrammarError("Wrong number of template arguments used for $(sym) (expected $(rule_names[sym]), got $(length(args))) (in rule $(name))")) │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1155 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1157 =# │ for sym = _find_used_symbols(expansions) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1158 =# │ if sym.type_ == "TERMINAL" │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1159 =# │ if !(sym in terminal_names) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1160 =# │ throw(GrammarError("Token '$(sym)' used but not defined (in rule $(name))")) │ end │ else │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1163 =# │ if !(sym in keys(rule_names)) && !(sym in params) │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1164 =# │ throw(GrammarError("Rule '$(sym)' used but not defined (in rule $(name))")) │ end │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1167 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1168 =# │ end │ #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1169 =# │ return Grammar(rules, term_defs, ignore_names) │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 =#) :: Value │ │ "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." :: Value │ │ [=] │ │ [call] │ │ load_grammar :: Identifier │ │ [parameters] │ │ [kw] │ │ grammar_name :: Identifier │ │ "" :: Value │ │ [kw] │ │ import_paths :: Identifier │ │ [vect] │ │ [::] │ │ gl :: Identifier │ │ GrammarLoader :: Identifier │ │ grammar_text :: Identifier │ │ [block] │ │ [try] │ │ [block] │ │ [=] │ │ tree :: Identifier │ │ [call] │ │ transform :: Identifier │ │ [call] │ │ CanonizeTree :: Identifier │ │ [call] │ │ parse :: Identifier │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ parser :: Identifier │ │ [call] │ │ * :: Identifier │ │ grammar_text :: Identifier │ │ "\n" :: Value │ │ e :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ e :: Identifier │ │ UnexpectedCharacters :: Identifier │ │ [block] │ │ [=] │ │ context :: Identifier │ │ [call] │ │ get_context :: Identifier │ │ e :: Identifier │ │ grammar_text :: Identifier │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Unexpected input at line " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ │ e :: Identifier │ │ ".column in " :: Value │ │ grammar_name :: Identifier │ │ ": \n\n" :: Value │ │ context :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ isa :: Identifier │ │ e :: Identifier │ │ UnexpectedToken :: Identifier │ │ [block] │ │ [=] │ │ context :: Identifier │ │ [call] │ │ get_context :: Identifier │ │ e :: Identifier │ │ grammar_text :: Identifier │ │ [=] │ │ error :: Identifier │ │ [call] │ │ match_examples :: Identifier │ │ e :: Identifier │ │ [call] │ │ partial :: Identifier │ │ parse :: Identifier │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ parser :: Identifier │ │ ERRORS :: Identifier │ │ [kw] │ │ use_accepts :: Identifier │ │ true :: Value │ │ [if] │ │ [call] │ │ != :: Identifier │ │ error :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ error :: Identifier │ │ " at line " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ │ context :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ occursin :: Identifier │ │ "STRING" :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ expected :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Expecting a value at line " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ │ context :: Identifier │ │ [call] │ │ rethrow :: Identifier │ │ e :: Identifier │ │ [=] │ │ tree :: Identifier │ │ [call] │ │ transform :: Identifier │ │ [call] │ │ PrepareGrammar :: Identifier │ │ tree :: Identifier │ │ [=] │ │ defs :: Identifier │ │ [call] │ │ classify :: Identifier │ │ [.] │ │ tree :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [kw] │ │ key :: Identifier │ │ [->] │ │ c :: Identifier │ │ [block] │ │ [.] │ │ c :: Identifier │ │ [inert] │ │ data :: Identifier │ │ [kw] │ │ value :: Identifier │ │ [->] │ │ c :: Identifier │ │ [block] │ │ [.] │ │ c :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [=] │ │ term_defs :: Identifier │ │ [call] │ │ pop! :: Identifier │ │ defs :: Identifier │ │ "term" :: Value │ │ [vect] │ │ [=] │ │ rule_defs :: Identifier │ │ [call] │ │ pop! :: Identifier │ │ defs :: Identifier │ │ "rule" :: Value │ │ [vect] │ │ [=] │ │ statements :: Identifier │ │ [call] │ │ pop! :: Identifier │ │ defs :: Identifier │ │ "statement" :: Value │ │ [vect] │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =#) :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ defs :: Identifier │ │ 0 :: Value │ │ [=] │ │ term_defs :: Identifier │ │ [comprehension] │ │ [generator] │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ td :: Identifier │ │ 3 :: Value │ │ [block] │ │ td :: Identifier │ │ [block] │ │ [vect] │ │ [ref] │ │ td :: Identifier │ │ 1 :: Value │ │ 1 :: Value │ │ [ref] │ │ td :: Identifier │ │ 2 :: Value │ │ [=] │ │ td :: Identifier │ │ term_defs :: Identifier │ │ [=] │ │ term_defs :: Identifier │ │ [comprehension] │ │ [generator] │ │ [tuple] │ │ [.] │ │ name :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ t :: Identifier │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [<:] │ │ [call] │ │ typeof :: Identifier │ │ p :: Identifier │ │ Int :: Identifier │ │ [block] │ │ [call] │ │ [.] │ │ Base :: Identifier │ │ [inert] │ │ parse :: Identifier │ │ Int64 :: Identifier │ │ [.] │ │ p :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [block] │ │ p :: Identifier │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ p :: Identifier │ │ t :: Identifier │ │ term_defs :: Identifier │ │ [=] │ │ rule_defs :: Identifier │ │ [typed_comprehension] │ │ Any :: Identifier │ │ [generator] │ │ [call] │ │ options_from_rule :: Identifier │ │ [ref] │ │ x :: Identifier │ │ 1 :: Value │ │ [...] │ │ [ref] │ │ x :: Identifier │ │ [call] │ │ : :: Identifier │ │ 2 :: Value │ │ end :: Identifier │ │ [=] │ │ x :: Identifier │ │ rule_defs :: Identifier │ │ [=] │ │ [tuple] │ │ ignore :: Identifier │ │ imports :: Identifier │ │ [tuple] │ │ [vect] │ │ [call] │ │ Dict :: Identifier │ │ [for] │ │ [=] │ │ a_stmt :: Identifier │ │ statements :: Identifier │ │ [block] │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =#) :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ a_stmt :: Identifier │ │ 1 :: Value │ │ [=] │ │ stmt :: Identifier │ │ [ref] │ │ a_stmt :: Identifier │ │ 1 :: Value │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "ignore" :: Value │ │ [block] │ │ [=] │ │ t :: Identifier │ │ [ref] │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [call] │ │ push! :: Identifier │ │ ignore :: Identifier │ │ t :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "import" :: Value │ │ [block] │ │ [if] │ │ [call] │ │ > :: Identifier │ │ [call] │ │ length :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [block] │ │ [=] │ │ [tuple] │ │ path_node :: Identifier │ │ arg1 :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [block] │ │ [=] │ │ path_node :: Identifier │ │ [ref] │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [=] │ │ arg1 :: Identifier │ │ nothing :: Identifier │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ arg1 :: Identifier │ │ Tree :: Identifier │ │ [block] │ │ [=] │ │ dotted_path :: Identifier │ │ [call] │ │ tuple :: Identifier │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [=] │ │ names :: Identifier │ │ [.] │ │ arg1 :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [=] │ │ aliases :: Identifier │ │ [call] │ │ Dict :: Identifier │ │ [call] │ │ zip :: Identifier │ │ names :: Identifier │ │ names :: Identifier │ │ [block] │ │ [=] │ │ dotted_path :: Identifier │ │ [call] │ │ tuple :: Identifier │ │ [ref] │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ │ 1 :: Value │ │ [call] │ │ - :: Identifier │ │ end :: Identifier │ │ 1 :: Value │ │ [=] │ │ name :: Identifier │ │ [ref] │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ children :: Identifier │ │ end :: Identifier │ │ [=] │ │ aliases :: Identifier │ │ [call] │ │ Dict :: Identifier │ │ [call] │ │ => :: Identifier │ │ name :: Identifier │ │ [if] │ │ [call] │ │ !== :: Identifier │ │ arg1 :: Identifier │ │ nothing :: Identifier │ │ arg1 :: Identifier │ │ name :: Identifier │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ path_node :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "import_lib" :: Value │ │ [block] │ │ [=] │ │ base_path :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ │ grammar_name :: Identifier │ │ "" :: Value │ │ [block] │ │ [=] │ │ base_file :: Identifier │ │ [call] │ │ abspath :: Identifier │ │ PROGRAM_FILE :: Identifier │ │ [block] │ │ [=] │ │ base_file :: Identifier │ │ grammar_name :: Identifier │ │ [if] │ │ [call] │ │ !== :: Identifier │ │ base_file :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [=] │ │ base_path :: Identifier │ │ [call] │ │ first :: Identifier │ │ [call] │ │ splitdir :: Identifier │ │ base_file :: Identifier │ │ [block] │ │ [=] │ │ base_path :: Identifier │ │ [call] │ │ pwd :: Identifier │ │ [try] │ │ [block] │ │ [=] │ │ [tuple] │ │ import_base_path :: Identifier │ │ import_aliases :: Identifier │ │ [ref] │ │ imports :: Identifier │ │ dotted_path :: Identifier │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =#) :: Value │ │ [call] │ │ == :: Identifier │ │ base_path :: Identifier │ │ import_base_path :: Identifier │ │ [string] │ │ "Inconsistent base path: " :: Value │ │ base_path :: Identifier │ │ " != " :: Value │ │ import_base_path :: Identifier │ │ [call] │ │ merge! :: Identifier │ │ import_aliases :: Identifier │ │ aliases :: Identifier │ │ e :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ e :: Identifier │ │ KeyError :: Identifier │ │ [block] │ │ [=] │ │ [ref] │ │ imports :: Identifier │ │ dotted_path :: Identifier │ │ [tuple] │ │ base_path :: Identifier │ │ aliases :: Identifier │ │ [block] │ │ [call] │ │ rethrow :: Identifier │ │ e :: Identifier │ │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "declare" :: Value │ │ [block] │ │ [for] │ │ [=] │ │ t :: Identifier │ │ [.] │ │ stmt :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [block] │ │ [call] │ │ push! :: Identifier │ │ term_defs :: Identifier │ │ [vect] │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ nothing :: Identifier │ │ nothing :: Identifier │ │ [block] │ │ [macrocall] │ │ @assert :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =#) :: Value │ │ false :: Value │ │ stmt :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ dotted_path :: Identifier │ │ ba :: Identifier │ │ imports :: Identifier │ │ [block] │ │ [=] │ │ [tuple] │ │ base_path :: Identifier │ │ aliases :: Identifier │ │ ba :: Identifier │ │ [=] │ │ grammar_path :: Identifier │ │ [call] │ │ * :: Identifier │ │ [call] │ │ joinpath :: Identifier │ │ [...] │ │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ │ [...] │ │ dotted_path :: Identifier │ │ EXT :: Identifier │ │ [=] │ │ g :: Identifier │ │ [call] │ │ import_grammar :: Identifier │ │ gl :: Identifier │ │ grammar_path :: Identifier │ │ [kw] │ │ base_path :: Identifier │ │ base_path :: Identifier │ │ [kw] │ │ import_paths :: Identifier │ │ import_paths :: Identifier │ │ [=] │ │ [tuple] │ │ new_td :: Identifier │ │ new_rd :: Identifier │ │ [call] │ │ import_from_grammar_into_namespace :: Identifier │ │ g :: Identifier │ │ [call] │ │ join :: Identifier │ │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ │ [...] │ │ dotted_path :: Identifier │ │ "__" :: Value │ │ aliases :: Identifier │ │ [call] │ │ append! :: Identifier │ │ term_defs :: Identifier │ │ new_td :: Identifier │ │ [call] │ │ append! :: Identifier │ │ rule_defs :: Identifier │ │ new_rd :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ _ :: Identifier │ │ term_defs :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ startswith :: Identifier │ │ name :: Identifier │ │ "__" :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [=] │ │ ignore_names :: Identifier │ │ [vect] │ │ [for] │ │ [=] │ │ t :: Identifier │ │ ignore :: Identifier │ │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "expansions" :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [block] │ │ [=] │ │ t2 :: Identifier │ │ [ref] │ │ [.] │ │ t :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ t2 :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "expansion" :: Value │ │ [call] │ │ == :: Identifier │ │ [call] │ │ length :: Identifier │ │ [.] │ │ t2 :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [block] │ │ [=] │ │ item :: Identifier │ │ [ref] │ │ [.] │ │ t2 :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ data :: Identifier │ │ "value" :: Value │ │ [block] │ │ [=] │ │ item :: Identifier │ │ [ref] │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [if] │ │ [&&] │ │ [call] │ │ isa :: Identifier │ │ item :: Identifier │ │ Token :: Identifier │ │ [call] │ │ == :: Identifier │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ │ [block] │ │ [call] │ │ push! :: Identifier │ │ ignore_names :: Identifier │ │ [.] │ │ item :: Identifier │ │ [inert] │ │ value :: Identifier │ │ [continue] │ │ [=] │ │ name :: Identifier │ │ [string] │ │ "__IGNORE_" :: Value │ │ [call] │ │ length :: Identifier │ │ ignore_names :: Identifier │ │ [call] │ │ push! :: Identifier │ │ ignore_names :: Identifier │ │ name :: Identifier │ │ [call] │ │ push! :: Identifier │ │ term_defs :: Identifier │ │ [tuple] │ │ name :: Identifier │ │ [tuple] │ │ t :: Identifier │ │ 0 :: Value │ │ [=] │ │ terminal_names :: Identifier │ │ [call] │ │ Set :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ _ :: Identifier │ │ term_defs :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ │ name :: Identifier │ │ terminal_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Terminal '" :: Value │ │ name :: Identifier │ │ "' defined more than once" :: Value │ │ [call] │ │ push! :: Identifier │ │ terminal_names :: Identifier │ │ name :: Identifier │ │ [if] │ │ [call] │ │ > :: Identifier │ │ [call] │ │ Set :: Identifier │ │ ignore_names :: Identifier │ │ terminal_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Terminals " :: Value │ │ [call] │ │ setdiff :: Identifier │ │ ignore_names :: Identifier │ │ terminal_names :: Identifier │ │ " were marked to ignore but were not defined!" :: Value │ │ [call] │ │ resolve_term_references :: Identifier │ │ term_defs :: Identifier │ │ [=] │ │ rules :: Identifier │ │ rule_defs :: Identifier │ │ [=] │ │ rule_names :: Identifier │ │ [call] │ │ Dict :: Identifier │ │ [if] │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ rules :: Identifier │ │ [comprehension] │ │ [generator] │ │ [tuple] │ │ a :: Identifier │ │ b :: Identifier │ │ c :: Identifier │ │ [call] │ │ RuleOptions :: Identifier │ │ d :: Identifier │ │ true :: Value │ │ [=] │ │ [tuple] │ │ a :: Identifier │ │ b :: Identifier │ │ c :: Identifier │ │ d :: Identifier │ │ rules :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ params :: Identifier │ │ _x :: Identifier │ │ option :: Identifier │ │ rules :: Identifier │ │ [block] │ │ [if] │ │ [.] │ │ gl :: Identifier │ │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ option :: Identifier │ │ [call] │ │ RuleOptions :: Identifier │ │ option :: Identifier │ │ true :: Value │ │ [if] │ │ [call] │ │ startswith :: Identifier │ │ name :: Identifier │ │ "__" :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [if] │ │ [call] │ │ in :: Identifier │ │ name :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Rule '" :: Value │ │ name :: Identifier │ │ "' defined more than once" :: Value │ │ [=] │ │ [ref] │ │ rule_names :: Identifier │ │ name :: Identifier │ │ [call] │ │ length :: Identifier │ │ params :: Identifier │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ params :: Identifier │ │ expansions :: Identifier │ │ _o :: Identifier │ │ rules :: Identifier │ │ [block] │ │ [for] │ │ [=] │ │ [tuple] │ │ i :: Identifier │ │ p :: Identifier │ │ [call] │ │ enumerate :: Identifier │ │ params :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ │ p :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Template Parameter conflicts with rule " :: Value │ │ p :: Identifier │ │ " (in template " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [if] │ │ [call] │ │ in :: Identifier │ │ p :: Identifier │ │ [ref] │ │ params :: Identifier │ │ [call] │ │ : :: Identifier │ │ 1 :: Value │ │ [call] │ │ - :: Identifier │ │ i :: Identifier │ │ 1 :: Value │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Duplicate Template Parameter " :: Value │ │ p :: Identifier │ │ " (in template " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [for] │ │ [=] │ │ temp :: Identifier │ │ [call] │ │ find_data :: Identifier │ │ expansions :: Identifier │ │ "template_usage" :: Value │ │ [block] │ │ [=] │ │ sym :: Identifier │ │ [ref] │ │ [.] │ │ temp :: Identifier │ │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ │ [=] │ │ args :: Identifier │ │ [ref] │ │ [.] │ │ temp :: Identifier │ │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ │ 2 :: Value │ │ end :: Identifier │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ params :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Template '" :: Value │ │ sym :: Identifier │ │ "' used but not defined (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [if] │ │ [call] │ │ != :: Identifier │ │ [call] │ │ length :: Identifier │ │ args :: Identifier │ │ [ref] │ │ rule_names :: Identifier │ │ sym :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Wrong number of template arguments used for " :: Value │ │ sym :: Identifier │ │ " (expected " :: Value │ │ [ref] │ │ rule_names :: Identifier │ │ sym :: Identifier │ │ ", got " :: Value │ │ [call] │ │ length :: Identifier │ │ args :: Identifier │ │ ") (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [for] │ │ [=] │ │ sym :: Identifier │ │ [call] │ │ _find_used_symbols :: Identifier │ │ expansions :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ │ [.] │ │ sym :: Identifier │ │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ terminal_names :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Token '" :: Value │ │ sym :: Identifier │ │ "' used but not defined (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ [call] │ │ keys :: Identifier │ │ rule_names :: Identifier │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ in :: Identifier │ │ sym :: Identifier │ │ params :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ │ [call] │ │ GrammarError :: Identifier │ │ [string] │ │ "Rule '" :: Value │ │ sym :: Identifier │ │ "' used but not defined (in rule " :: Value │ │ name :: Identifier │ │ ")" :: Value │ │ [return] │ │ [call] │ │ Grammar :: Identifier │ │ rules :: Identifier │ │ term_defs :: Identifier │ │ ignore_names :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [=] │ │ [call] │ │ load_grammar :: Identifier │ scope_layer=1 │ [parameters] │ │ [kw] │ │ grammar_name :: Identifier │ scope_layer=1 │ "" :: Value │ macro_source=1141 │ [kw] │ │ import_paths :: Identifier │ scope_layer=1 │ [vect] │ macro_source=1141 │ [::] │ │ gl :: Identifier │ scope_layer=1 │ GrammarLoader :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ [block] │ │ [try] │ │ [block] │ │ [=] │ │ tree :: Identifier │ scope_layer=1 │ [call] │ │ transform :: Identifier │ scope_layer=1 │ [call] │ │ CanonizeTree :: Identifier │ scope_layer=1 │ [call] │ │ parse :: Identifier │ scope_layer=1 │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ parser :: Identifier │ │ [call] │ │ * :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ "\n" :: Value │ macro_source=1141 │ e :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ UnexpectedCharacters :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ context :: Identifier │ scope_layer=1 │ [call] │ │ get_context :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Unexpected input at line " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ macro_source=1141 │ e :: Identifier │ scope_layer=1 │ ".column in " :: Value │ macro_source=1141 │ grammar_name :: Identifier │ scope_layer=1 │ ": \n\n" :: Value │ macro_source=1141 │ context :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ UnexpectedToken :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ context :: Identifier │ scope_layer=1 │ [call] │ │ get_context :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ grammar_text :: Identifier │ scope_layer=1 │ [=] │ │ error :: Identifier │ scope_layer=1 │ [call] │ │ match_examples :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [call] │ │ partial :: Identifier │ scope_layer=1 │ parse :: Identifier │ scope_layer=1 │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ parser :: Identifier │ │ ERRORS :: Identifier │ scope_layer=1 │ [kw] │ │ use_accepts :: Identifier │ scope_layer=1 │ true :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ != :: Identifier │ scope_layer=1 │ error :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ error :: Identifier │ scope_layer=1 │ " at line " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ macro_source=1141 │ context :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ occursin :: Identifier │ scope_layer=1 │ "STRING" :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ expected :: Identifier │ │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Expecting a value at line " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ line :: Identifier │ │ " column " :: Value │ macro_source=1141 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ column :: Identifier │ │ "\n\n" :: Value │ macro_source=1141 │ context :: Identifier │ scope_layer=1 │ [call] │ │ rethrow :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [=] │ │ tree :: Identifier │ scope_layer=1 │ [call] │ │ transform :: Identifier │ scope_layer=1 │ [call] │ │ PrepareGrammar :: Identifier │ scope_layer=1 │ tree :: Identifier │ scope_layer=1 │ [=] │ │ defs :: Identifier │ scope_layer=1 │ [call] │ │ classify :: Identifier │ scope_layer=1 │ [.] │ │ tree :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [kw] │ │ key :: Identifier │ scope_layer=1 │ [->] │ │ c :: Identifier │ scope_layer=1 │ [block] │ │ [.] │ │ c :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ [kw] │ │ value :: Identifier │ scope_layer=1 │ [->] │ │ c :: Identifier │ scope_layer=1 │ [block] │ │ [.] │ │ c :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [=] │ │ term_defs :: Identifier │ scope_layer=1 │ [call] │ │ pop! :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ "term" :: Value │ macro_source=1141 │ [vect] │ macro_source=1141 │ [=] │ │ rule_defs :: Identifier │ scope_layer=1 │ [call] │ │ pop! :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ "rule" :: Value │ macro_source=1141 │ [vect] │ macro_source=1141 │ [=] │ │ statements :: Identifier │ scope_layer=1 │ [call] │ │ pop! :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ "statement" :: Value │ macro_source=1141 │ [vect] │ macro_source=1141 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ defs :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=1141 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "length(defs) == 0" :: Value │ macro_source=1141 │ [=] │ │ term_defs :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ td :: Identifier │ scope_layer=1 │ 3 :: Value │ macro_source=1141 │ [block] │ │ td :: Identifier │ scope_layer=1 │ [block] │ │ [vect] │ │ [ref] │ │ td :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ 1 :: Value │ macro_source=1141 │ [ref] │ │ td :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=1141 │ [=] │ │ td :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [=] │ │ term_defs :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [tuple] │ │ [.] │ │ name :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ t :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [call] │ │ typeof :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ [.] │ │ Base :: Identifier │ scope_layer=1 │ [inert] │ │ parse :: Identifier │ │ Int64 :: Identifier │ scope_layer=1 │ [.] │ │ p :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [block] │ │ p :: Identifier │ scope_layer=1 │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ t :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [=] │ │ rule_defs :: Identifier │ scope_layer=1 │ [typed_comprehension] │ │ Any :: Identifier │ scope_layer=1 │ [generator] │ │ [call] │ │ options_from_rule :: Identifier │ scope_layer=1 │ [ref] │ │ x :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [...] │ │ [ref] │ │ x :: Identifier │ scope_layer=1 │ [call] │ │ : :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=1141 │ end :: Identifier │ scope_layer=1 │ [=] │ │ x :: Identifier │ scope_layer=1 │ rule_defs :: Identifier │ scope_layer=1 │ [=] │ │ [tuple] │ │ ignore :: Identifier │ scope_layer=1 │ imports :: Identifier │ scope_layer=1 │ [tuple] │ │ [vect] │ macro_source=1141 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ a_stmt :: Identifier │ scope_layer=1 │ statements :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ a_stmt :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "length(a_stmt) == 1" :: Value │ macro_source=1141 │ [=] │ │ stmt :: Identifier │ scope_layer=1 │ [ref] │ │ a_stmt :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "ignore" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ t :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ ignore :: Identifier │ scope_layer=1 │ t :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "import" :: Value │ macro_source=1141 │ [block] │ │ [if] │ │ [call] │ │ > :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ [tuple] │ │ path_node :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [block] │ │ [=] │ │ path_node :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [=] │ │ arg1 :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ Tree :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ dotted_path :: Identifier │ scope_layer=1 │ [call] │ │ tuple :: Identifier │ scope_layer=1 │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [=] │ │ names :: Identifier │ scope_layer=1 │ [.] │ │ arg1 :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [=] │ │ aliases :: Identifier │ scope_layer=1 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [call] │ │ zip :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ dotted_path :: Identifier │ scope_layer=1 │ [call] │ │ tuple :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [call] │ │ - :: Identifier │ scope_layer=1 │ end :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [=] │ │ name :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ end :: Identifier │ scope_layer=1 │ [=] │ │ aliases :: Identifier │ scope_layer=1 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [call] │ │ => :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ !== :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ arg1 :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ path_node :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "import_lib" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ base_path :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ grammar_name :: Identifier │ scope_layer=1 │ "" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ base_file :: Identifier │ scope_layer=1 │ [call] │ │ abspath :: Identifier │ scope_layer=1 │ PROGRAM_FILE :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ base_file :: Identifier │ scope_layer=1 │ grammar_name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ !== :: Identifier │ scope_layer=1 │ base_file :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ base_path :: Identifier │ scope_layer=1 │ [call] │ │ first :: Identifier │ scope_layer=1 │ [call] │ │ splitdir :: Identifier │ scope_layer=1 │ base_file :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ base_path :: Identifier │ scope_layer=1 │ [call] │ │ pwd :: Identifier │ scope_layer=1 │ [try] │ │ [block] │ │ [=] │ │ [tuple] │ │ import_base_path :: Identifier │ scope_layer=1 │ import_aliases :: Identifier │ scope_layer=1 │ [ref] │ │ imports :: Identifier │ scope_layer=1 │ dotted_path :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ base_path :: Identifier │ scope_layer=1 │ import_base_path :: Identifier │ scope_layer=1 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ [call] │ │ Base._assert_tostring :: Value │ macro_source=1141 │ [string] │ │ "Inconsistent base path: " :: Value │ macro_source=1141 │ base_path :: Identifier │ scope_layer=1 │ " != " :: Value │ macro_source=1141 │ import_base_path :: Identifier │ scope_layer=1 │ [call] │ │ merge! :: Identifier │ scope_layer=1 │ import_aliases :: Identifier │ scope_layer=1 │ aliases :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ KeyError :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ [ref] │ │ imports :: Identifier │ scope_layer=1 │ dotted_path :: Identifier │ scope_layer=1 │ [tuple] │ │ base_path :: Identifier │ scope_layer=1 │ aliases :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ rethrow :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [elseif] │ │ [block] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "declare" :: Value │ macro_source=1141 │ [block] │ │ [for] │ │ [=] │ │ t :: Identifier │ scope_layer=1 │ [.] │ │ stmt :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [block] │ │ [call] │ │ push! :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [vect] │ │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [tuple] │ │ nothing :: Identifier │ scope_layer=1 │ nothing :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ false :: Value │ macro_source=1141 │ nothing :: Value │ macro_source=1141 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ [call] │ │ Base._assert_tostring :: Value │ macro_source=1141 │ stmt :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ dotted_path :: Identifier │ scope_layer=1 │ ba :: Identifier │ scope_layer=1 │ imports :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ [tuple] │ │ base_path :: Identifier │ scope_layer=1 │ aliases :: Identifier │ scope_layer=1 │ ba :: Identifier │ scope_layer=1 │ [=] │ │ grammar_path :: Identifier │ scope_layer=1 │ [call] │ │ * :: Identifier │ scope_layer=1 │ [call] │ │ joinpath :: Identifier │ scope_layer=1 │ [...] │ │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ scope_layer=1 │ [...] │ │ dotted_path :: Identifier │ scope_layer=1 │ EXT :: Identifier │ scope_layer=1 │ [=] │ │ g :: Identifier │ scope_layer=1 │ [call] │ │ import_grammar :: Identifier │ scope_layer=1 │ gl :: Identifier │ scope_layer=1 │ grammar_path :: Identifier │ scope_layer=1 │ [kw] │ │ base_path :: Identifier │ scope_layer=1 │ base_path :: Identifier │ scope_layer=1 │ [kw] │ │ import_paths :: Identifier │ scope_layer=1 │ import_paths :: Identifier │ scope_layer=1 │ [=] │ │ [tuple] │ │ new_td :: Identifier │ scope_layer=1 │ new_rd :: Identifier │ scope_layer=1 │ [call] │ │ import_from_grammar_into_namespace :: Identifier │ scope_layer=1 │ g :: Identifier │ scope_layer=1 │ [call] │ │ join :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [.] │ │ x :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [=] │ │ x :: Identifier │ scope_layer=1 │ [...] │ │ dotted_path :: Identifier │ scope_layer=1 │ "__" :: Value │ macro_source=1141 │ aliases :: Identifier │ scope_layer=1 │ [call] │ │ append! :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ new_td :: Identifier │ scope_layer=1 │ [call] │ │ append! :: Identifier │ scope_layer=1 │ rule_defs :: Identifier │ scope_layer=1 │ new_rd :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ _ :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ startswith :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ "__" :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [=] │ │ ignore_names :: Identifier │ scope_layer=1 │ [vect] │ macro_source=1141 │ [for] │ │ [=] │ │ t :: Identifier │ scope_layer=1 │ ignore :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "expansions" :: Value │ macro_source=1141 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ t2 :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ t :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [if] │ │ [&&] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ t2 :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "expansion" :: Value │ macro_source=1141 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ [.] │ │ t2 :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ item :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ t2 :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ "value" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ item :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [if] │ │ [&&] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ item :: Identifier │ scope_layer=1 │ Token :: Identifier │ scope_layer=1 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ push! :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ [.] │ │ item :: Identifier │ scope_layer=1 │ [inert] │ │ value :: Identifier │ │ [continue] │ macro_source=1141 │ [=] │ │ name :: Identifier │ scope_layer=1 │ [string] │ │ "__IGNORE_" :: Value │ macro_source=1141 │ [call] │ │ length :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ [tuple] │ │ t :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=1141 │ [=] │ │ terminal_names :: Identifier │ scope_layer=1 │ [call] │ │ Set :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ _ :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Terminal '" :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ "' defined more than once" :: Value │ macro_source=1141 │ [call] │ │ push! :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ > :: Identifier │ scope_layer=1 │ [call] │ │ Set :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Terminals " :: Value │ macro_source=1141 │ [call] │ │ setdiff :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ " were marked to ignore but were not defined!" :: Value │ macro_source=1141 │ [call] │ │ resolve_term_references :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ [=] │ │ rules :: Identifier │ scope_layer=1 │ rule_defs :: Identifier │ scope_layer=1 │ [=] │ │ rule_names :: Identifier │ scope_layer=1 │ [call] │ │ Dict :: Identifier │ scope_layer=1 │ [if] │ │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ rules :: Identifier │ scope_layer=1 │ [comprehension] │ │ [generator] │ │ [tuple] │ │ a :: Identifier │ scope_layer=1 │ b :: Identifier │ scope_layer=1 │ c :: Identifier │ scope_layer=1 │ [call] │ │ RuleOptions :: Identifier │ scope_layer=1 │ d :: Identifier │ scope_layer=1 │ true :: Value │ macro_source=1141 │ [=] │ │ [tuple] │ │ a :: Identifier │ scope_layer=1 │ b :: Identifier │ scope_layer=1 │ c :: Identifier │ scope_layer=1 │ d :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ _x :: Identifier │ scope_layer=1 │ option :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [.] │ │ gl :: Identifier │ scope_layer=1 │ [inert] │ │ global_keep_all_tokens :: Identifier │ │ [block] │ │ [=] │ │ option :: Identifier │ scope_layer=1 │ [call] │ │ RuleOptions :: Identifier │ scope_layer=1 │ option :: Identifier │ scope_layer=1 │ true :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ startswith :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ "__" :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Names starting with double-underscore are reserved (Error at " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Rule '" :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ "' defined more than once" :: Value │ macro_source=1141 │ [=] │ │ [ref] │ │ rule_names :: Identifier │ scope_layer=1 │ name :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ expansions :: Identifier │ scope_layer=1 │ _o :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ [block] │ │ [for] │ │ [=] │ │ [tuple] │ │ i :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ [call] │ │ enumerate :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Template Parameter conflicts with rule " :: Value │ macro_source=1141 │ p :: Identifier │ scope_layer=1 │ " (in template " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ in :: Identifier │ scope_layer=1 │ p :: Identifier │ scope_layer=1 │ [ref] │ │ params :: Identifier │ scope_layer=1 │ [call] │ │ : :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [call] │ │ - :: Identifier │ scope_layer=1 │ i :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=1141 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Duplicate Template Parameter " :: Value │ macro_source=1141 │ p :: Identifier │ scope_layer=1 │ " (in template " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [for] │ │ [=] │ │ temp :: Identifier │ scope_layer=1 │ [call] │ │ find_data :: Identifier │ scope_layer=1 │ expansions :: Identifier │ scope_layer=1 │ "template_usage" :: Value │ macro_source=1141 │ [block] │ │ [=] │ │ sym :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ temp :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ 1 :: Value │ macro_source=1141 │ [=] │ │ args :: Identifier │ scope_layer=1 │ [ref] │ │ [.] │ │ temp :: Identifier │ scope_layer=1 │ [inert] │ │ children :: Identifier │ │ [call] │ │ : :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=1141 │ end :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Template '" :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ "' used but not defined (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [if] │ │ [call] │ │ != :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ args :: Identifier │ scope_layer=1 │ [ref] │ │ rule_names :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Wrong number of template arguments used for " :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ " (expected " :: Value │ macro_source=1141 │ [ref] │ │ rule_names :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ ", got " :: Value │ macro_source=1141 │ [call] │ │ length :: Identifier │ scope_layer=1 │ args :: Identifier │ scope_layer=1 │ ") (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [for] │ │ [=] │ │ sym :: Identifier │ scope_layer=1 │ [call] │ │ _find_used_symbols :: Identifier │ scope_layer=1 │ expansions :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ == :: Identifier │ scope_layer=1 │ [.] │ │ sym :: Identifier │ scope_layer=1 │ [inert] │ │ type_ :: Identifier │ │ "TERMINAL" :: Value │ macro_source=1141 │ [block] │ │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ terminal_names :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Token '" :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ "' used but not defined (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [block] │ │ [if] │ │ [&&] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ [call] │ │ keys :: Identifier │ scope_layer=1 │ rule_names :: Identifier │ scope_layer=1 │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ in :: Identifier │ scope_layer=1 │ sym :: Identifier │ scope_layer=1 │ params :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ throw :: Identifier │ scope_layer=1 │ [call] │ │ GrammarError :: Identifier │ scope_layer=1 │ [string] │ │ "Rule '" :: Value │ macro_source=1141 │ sym :: Identifier │ scope_layer=1 │ "' used but not defined (in rule " :: Value │ macro_source=1141 │ name :: Identifier │ scope_layer=1 │ ")" :: Value │ macro_source=1141 │ [return] │ │ [call] │ │ Grammar :: Identifier │ scope_layer=1 │ rules :: Identifier │ scope_layer=1 │ term_defs :: Identifier │ scope_layer=1 │ ignore_names :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=1141 │ Lerche :: Value │ macro_source=1141 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=1141 │ Lerche :: Value │ │ [inert] │ jl_source=L65 │ load_grammar :: Identifier │ │ [call] │ macro_source=1141 │ Base.Docs.docstr :: Value │ macro_source=1141 │ [call] │ macro_source=1141 │ Core.svec :: Value │ macro_source=1141 │ "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." :: Value │ macro_source=1141 │ [call] │ macro_source=1141 │ Dict{Symbol, Any} :: Value │ macro_source=1141 │ :path => "/home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl" :: Value │ macro_source=1141 │ :linenumber => 958 :: Value │ macro_source=1141 │ :module => Lerche :: Value │ macro_source=1141 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ GrammarLoader :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl" │ line = 958 └ mod = Lerche ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1058 =# - unexpected `...` splatting can only be done into a `call`, `tuple`, `curly`, or array-like expression Expression:  (... dotted_path) Containing expressions:  (comprehension (generator (. x (inert value)) (= x (... dotted_path))))  Detailed provenance:  (... dotted_path)  └─ (... dotted_path)  ├─ @ /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1058  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 =#) "Parse grammar_text, verify, and create Grammar object. Display nice messages on error." (= (call load_grammar (parameters (kw grammar_name "") (kw import_paths (vect))) (:: gl GrammarLoader) grammar_text) (block (try (block (= tree (call transform (call CanonizeTree) (call parse (. gl (inert parser)) (call * grammar_text "\n"))))) e (block (if (call isa e UnexpectedCharacters) (block (= context (call get_context e grammar_text)) (call throw (call GrammarError (string "Unexpected input at line " (. e (inert line)) " column " e ".column in " grammar_name ": \n\n" context)))) (elseif (block (call isa e UnexpectedToken)) (block (= context (call get_context e grammar_text)) (= error (call match_examples e (call partial parse (. gl (inert parser))) ERRORS (kw use_accepts true))) (if (call != error nothing) (block (call throw (call GrammarError (string error " at line " (. e (inert line)) " column " (. e (inert column)) "\n\n" context)))) (elseif (block (call occursin "STRING" (. e (inert expected)))) (block (call throw (call GrammarError (string "Expecting a value at line " (. e (inert line)) " column " (. e (inert column)) "\n\n" context))))))))) (call rethrow e))) (= tree (call transform (call PrepareGrammar) tree)) (= defs (call classify (. tree (inert children)) (kw key (-> c (block (. c (inert data))))) (kw value (-> c (block (. c (inert children))))))) (= term_defs (call pop! defs "term" (vect))) (= rule_defs (call pop! defs "rule" (vect))) (= statements (call pop! defs "statement" (vect))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:987 =#) (call == (call length defs) 0)) (= term_defs (comprehension (generator (if (call == (call length td) 3) (block td) (block (vect (ref td 1) 1 (ref td 2)))) (= td term_defs)))) (= term_defs (comprehension (generator (tuple (. name (inert value)) (tuple t (if (call ! (<: (call typeof p) Int)) (block (call (. Base (inert parse)) Int64 (. p (inert value)))) (block p)))) (= (tuple name p t) term_defs)))) (= rule_defs (typed_comprehension Any (generator (call options_from_rule (ref x 1) (... (ref x (call : 2 end)))) (= x rule_defs)))) (= (tuple ignore imports) (tuple (vect) (call Dict))) (for (= a_stmt statements) (block (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:998 =#) (call == (call length a_stmt) 1)) (= stmt (ref a_stmt 1)) (if (call == (. stmt (inert data)) "ignore") (block (= t (ref (. stmt (inert children)) 1)) (call push! ignore t)) (elseif (block (call == (. stmt (inert data)) "import")) (block (if (call > (call length (. stmt (inert children))) 1) (block (= (tuple path_node arg1) (. stmt (inert children)))) (block (= path_node (ref (. stmt (inert children)) 1)) (= arg1 nothing))) (if (call isa arg1 Tree) (block (= dotted_path (call tuple (. path_node (inert children)))) (= names (. arg1 (inert children))) (= aliases (call Dict (call zip names names)))) (block (= dotted_path (call tuple (ref (. path_node (inert children)) (call : 1 (call - end 1))))) (= name (ref (. path_node (inert children)) end)) (= aliases (call Dict (call => name (if (call !== arg1 nothing) arg1 name)))))) (if (call == (. path_node (inert data)) "import_lib") (block (= base_path nothing)) (block (if (call == grammar_name "") (block (= base_file (call abspath PROGRAM_FILE))) (block (= base_file grammar_name))) (if (call !== base_file nothing) (block (= base_path (call first (call splitdir base_file)))) (block (= base_path (call pwd)))))) (try (block (= (tuple import_base_path import_aliases) (ref imports dotted_path)) (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1037 =#) (call == base_path import_base_path) (string "Inconsistent base path: " base_path " != " import_base_path)) (call merge! import_aliases aliases)) e (block (if (call isa e KeyError) (block (= (ref imports dotted_path) (tuple base_path aliases))) (block (call rethrow e)))))) (elseif (block (call == (. stmt (inert data)) "declare")) (block (for (= t (. stmt (inert children))) (block (call push! term_defs (vect (. t (inert value)) (tuple nothing nothing)))))) (block (macrocall @assert :(#= /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:1051 =#) false stmt))))))) (for (= (tuple dotted_path ba) imports) (block (= (tuple base_path aliases) ba) (= grammar_path (call * (call joinpath (... (comprehension (generator (. x (inert value)) (= x (... dotted_path)))))) EXT)) (= g (call import_grammar gl grammar_path (kw base_path base_path) (kw import_paths import_paths))) (= (tuple new_td new_rd) (call import_from_grammar_into_namespace g (call join (comprehension (generator (. x (inert value)) (= x (... dotted_path)))) "__") aliases)) (call append! term_defs new_td) (call append! rule_defs new_rd))) (for (= (tuple name _) term_defs) (block (if (call startswith name "__") (block (call throw (call GrammarError (string "Names starting with double-underscore are reserved (Error at " name ")"))))))) (= ignore_names (vect)) (for (= t ignore) (block (if (&& (call == (. t (inert data)) "expansions") (call == (call length (. t (inert children))) 1)) (block (= t2 (ref (. t (inert children)) 1)) (if (&& (call == (. t2 (inert data)) "expansion") (call == (call length (. t2 (inert children))) 1)) (block (= item (ref (. t2 (inert children)) 1)) (if (call == (. item (inert data)) "value") (block (= item (ref (. item (inert children)) 1)) (if (&& (call isa item Token) (call == (. item (inert type_)) "TERMINAL")) (block (call push! ignore_names (. item (inert value))) (continue))))))))) (= name (string "__IGNORE_" (call length ignore_names))) (call push! ignore_names name) (call push! term_defs (tuple name (tuple t 0))))) (= terminal_names (call Set)) (for (= (tuple name _) term_defs) (block (if (call in name terminal_names) (block (call throw (call GrammarError (string "Terminal '" name "' defined more than once"))))) (call push! terminal_names name))) (if (call > (call Set ignore_names) terminal_names) (block (call throw (call GrammarError (string "Terminals " (call setdiff ignore_names terminal_names) " were marked to ignore but were not defined!"))))) (call resolve_term_references term_defs) (= rules rule_defs) (= rule_names (call Dict)) (if (. gl (inert global_keep_all_tokens)) (block (= rules (comprehension (generator (tuple a b c (call RuleOptions d true)) (= (tuple a b c d) rules)))))) (for (= (tuple name params _x option) rules) (block (if (. gl (inert global_keep_all_tokens)) (block (= option (call RuleOptions option true)))) (if (call startswith name "__") (block (call throw (call GrammarError (string "Names starting with double-underscore are reserved (Error at " name ")"))))) (if (call in name (call keys rule_names)) (block (call throw (call GrammarError (string "Rule '" name "' defined more than once"))))) (= (ref rule_names name) (call length params)))) (for (= (tuple name params expansions _o) rules) (block (for (= (tuple i p) (call enumerate params)) (block (if (call in p (call keys rule_names)) (block (call throw (call GrammarError (string "Template Parameter conflicts with rule " p " (in template " name ")"))))) (if (call in p (ref params (call : 1 (call - i 1)))) (block (call throw (call GrammarError (string "Duplicate Template Parameter " p " (in template " name ")"))))))) (for (= temp (call find_data expansions "template_usage")) (block (= sym (ref (. temp (inert children)) 1)) (= args (ref (. temp (inert children)) (call : 2 end))) (if (call ! (call in sym params)) (block (if (call ! (call in sym (call keys rule_names))) (block (call throw (call GrammarError (string "Template '" sym "' used but not defined (in rule " name ")"))))) (if (call != (call length args) (ref rule_names sym)) (block (call throw (call GrammarError (string "Wrong number of template arguments used for " sym " (expected " (ref rule_names sym) ", got " (call length args) ") (in rule " name ")"))))))))) (for (= sym (call _find_used_symbols expansions)) (block (if (call == (. sym (inert type_)) "TERMINAL") (block (if (call ! (call in sym terminal_names)) (block (call throw (call GrammarError (string "Token '" sym "' used but not defined (in rule " name ")")))))) (block (if (&& (call ! (call in sym (call keys rule_names))) (call ! (call in sym params))) (block (call throw (call GrammarError (string "Rule '" sym "' used but not defined (in rule " name ")"))))))))))) (return (call Grammar rules term_defs ignore_names)))))  └─ @ /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958  Stacktrace:  [1] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4448  [2] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [3] include(mapexpr::Function, mod::Module, _path::String)  @ Base Base.jl:327  [4] top-level scope  @ ~/.julia/packages/Lerche/bn9Mc/src/Lerche.jl:39  [5] include(mod::Module, _path::String)  @ Base Base.jl:326  [6] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [7] top-level scope  @ stdin:5  [8] eval(m::Module, e::Any)  @ Core boot.jl:521  [9] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [10] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [11] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [12] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/load_grammar.jl:958 in expression starting at /home/pkgeval/.julia/packages/Lerche/bn9Mc/src/Lerche.jl:1 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ Lerche │ [Output was shown above] └ ERROR: LoadError: The following 1 package failed to precompile: Lerche Failed to precompile Lerche [d42ef402-04e6-4356-9f73-091573ea58dc] to "/home/pkgeval/.julia/compiled/v1.14/Lerche/jl_z3QLMA" (ProcessExited(1)). in expression starting at /home/pkgeval/.julia/packages/Lerche/bn9Mc/test/runtests.jl:1 Testing failed after 123.66s ERROR: LoadError: Package Lerche errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3247 [3] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [4] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [5] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [6] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [7] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 [8] include(mod::Module, _path::String) @ Base Base.jl:326 [9] exec_options(opts::Base.JLOptions) @ Base client.jl:355 [10] _start() @ Base client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 637.13s: package fails to precompile