Package evaluation to test CrystalInfoContainers on Julia 1.14.0-DEV.2309 (6e1a27e459*) started at 2026-06-06T12:38:09.539 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 17.66s ################################################################################ # Installation # Installing CrystalInfoContainers... Resolving package versions... Installed URIs ──────────────────────── v1.6.1 Installed IteratorInterfaceExtensions ─ v1.0.0 Installed OrderedCollections ────────── v1.8.2 Installed DataStructures ────────────── v0.19.5 Installed DataAPI ───────────────────── v1.16.0 Installed MacroTools ────────────────── v0.5.16 Installed InlineStrings ─────────────── v1.4.5 Installed Statistics ────────────────── v1.11.1 Installed InvertedIndices ───────────── v1.3.1 Installed Compat ────────────────────── v4.18.1 Installed DataValueInterfaces ───────── v1.0.0 Installed SentinelArrays ────────────── v1.4.10 Installed CrystalInfoContainers ─────── v0.1.1 Installed Tables ────────────────────── v1.12.1 Installed PrecompileTools ───────────── v1.3.4 Installed Reexport ──────────────────── v1.2.2 Installed Missings ──────────────────── v1.2.0 Installed PooledArrays ──────────────── v1.4.3 Installed StringManipulation ────────── v0.4.4 Installed Preferences ───────────────── v1.5.2 Installed PrettyTables ──────────────── v3.3.2 Installed LaTeXStrings ──────────────── v1.4.0 Installed TableTraits ───────────────── v1.0.1 Installed Crayons ───────────────────── v4.1.1 Installed CrystalInfoFramework ──────── v1.1.0 Installed DataFrames ────────────────── v1.8.2 Installed SortingAlgorithms ─────────── v1.2.2 Installed Lerche ────────────────────── v0.5.8 Updating `~/.julia/environments/v1.14/Project.toml` [0536147b] + CrystalInfoContainers v0.1.1 Updating `~/.julia/environments/v1.14/Manifest.toml` [34da2185] + Compat v4.18.1 [a8cc5b0e] + Crayons v4.1.1 [0536147b] + CrystalInfoContainers v0.1.1 ⌅ [6007d9b0] + CrystalInfoFramework v1.1.0 [9a962f9c] + DataAPI v1.16.0 [a93c6f00] + DataFrames v1.8.2 [864edb3b] + DataStructures v0.19.5 [e2d170a0] + DataValueInterfaces v1.0.0 [842dd82b] + InlineStrings v1.4.5 [41ab1584] + InvertedIndices v1.3.1 [82899510] + IteratorInterfaceExtensions v1.0.0 [b964fa9f] + LaTeXStrings v1.4.0 [d42ef402] + Lerche v0.5.8 [1914dd2f] + MacroTools v0.5.16 [e1d29d7a] + Missings v1.2.0 ⌅ [bac558e1] + OrderedCollections v1.8.2 [2dfb63ee] + PooledArrays v1.4.3 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [08abe8d2] + PrettyTables v3.3.2 [189a3867] + Reexport v1.2.2 [91c51154] + SentinelArrays v1.4.10 [a2af1166] + SortingAlgorithms v1.2.2 [10745b16] + Statistics v1.11.1 [892a3eda] + StringManipulation v0.4.4 [3783bdb8] + TableTraits v1.0.1 [bd369af6] + Tables v1.12.1 [5c2747f8] + URIs v1.6.1 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [7b1f6079] + FileWatching v1.11.0 [9fa8497b] + Future v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [3fa0cd96] + REPL v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [6462fe0b] + Sockets v1.11.0 [f489334b] + StyledStrings v1.13.0 [fa267f1f] + TOML v1.0.3 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.2+0 [4536629a] + OpenBLAS_jll v0.3.33+0 [8e850b90] + libblastrampoline_jll v5.15.0+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 5.58s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 6.7 s ✓ TestEnv 1 dependency successfully precompiled in 7 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... 4.9 s ✓ MacroTools 319.4 s ✓ InlineStrings 0.6 s ✓ Reexport 1.1 s ✓ Statistics 1.1 s ✓ DataAPI 0.5 s ✓ DataValueInterfaces 40.1 s ✓ URIs 152.6 s ✓ OrderedCollections 57.2 s ✓ InvertedIndices 0.5 s ✓ IteratorInterfaceExtensions 42.5 s ✓ LaTeXStrings 2.3 s ✓ Crayons 159.2 s ✓ SentinelArrays 1.6 s ✓ Compat 3.0 s ✓ Preferences 55.9 s ✓ Missings 23.3 s ✓ PooledArrays 169.8 s ✓ DataStructures 0.5 s ✓ TableTraits 0.7 s ✓ Compat → CompatLinearAlgebraExt 3.1 s ✓ PrecompileTools 38.4 s ✓ SortingAlgorithms 152.2 s ✓ Tables 78.1 s ✓ StringManipulation ┌ 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 213.0 s ✓ PrettyTables 336.4 s ✓ DataFrames ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("d42ef402-04e6-4356-9f73-091573ea58dc"), "Lerche") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) Stacktrace:  [1] error(s::String)  @ Base error.jl:56  [2] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base loading.jl:2837  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base loading.jl:2685  [4] macro expansion  @ loading.jl:2599 [inlined]  [5] macro expansion  @ lock.jl:376 [inlined]  [6] __require(into::Module, mod::Symbol)  @ Base loading.jl:2563  [7] require(into::Module, mod::Symbol)  @ Base loading.jl:2539 [inlined]  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)  @ Base module.jl:36 [inlined]  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)  @ Base module.jl:60  [10] _eval_using(to::Module, path::Expr, flags::UInt8)  @ Base module.jl:137 [inlined]  [11] eval_using(to::Module, path::Expr)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207  [12] top-level scope  @ ~/.julia/packages/CrystalInfoFramework/PJp1x/src/CrystalInfoFramework.jl:31  [13] include(mod::Module, _path::String)  @ Base Base.jl:326  [14] 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  [15] top-level scope  @ stdin:5  [16] eval(m::Module, e::Any)  @ Core boot.jl:521  [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [18] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [19] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [20] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/CrystalInfoFramework/PJp1x/src/CrystalInfoFramework.jl:21 in expression starting at stdin:5 ✗ CrystalInfoFramework ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("6007d9b0-c6b2-11e8-0510-1d10e825f3f1"), "CrystalInfoFramework") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) Stacktrace:  [1] error(s::String)  @ Base error.jl:56  [2] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base loading.jl:2837  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base loading.jl:2685  [4] macro expansion  @ loading.jl:2599 [inlined]  [5] macro expansion  @ lock.jl:376 [inlined]  [6] __require(into::Module, mod::Symbol)  @ Base loading.jl:2563  [7] require(into::Module, mod::Symbol)  @ Base loading.jl:2539 [inlined]  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)  @ Base module.jl:36 [inlined]  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)  @ Base module.jl:60  [10] _eval_using(to::Module, path::Expr, flags::UInt8)  @ Base module.jl:137 [inlined]  [11] eval_using(to::Module, path::Expr)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207  [12] top-level scope  @ ~/.julia/packages/CrystalInfoContainers/1uydM/src/CrystalInfoContainers.jl:27  [13] include(mod::Module, _path::String)  @ Base Base.jl:326  [14] 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  [15] top-level scope  @ stdin:5  [16] eval(m::Module, e::Any)  @ Core boot.jl:521  [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [18] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [19] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [20] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/CrystalInfoContainers/1uydM/src/CrystalInfoContainers.jl:21 in expression starting at stdin:5 ✗ CrystalInfoContainers 26 dependencies successfully precompiled in 2070 seconds. 15 already precompiled. Precompilation completed after 2105.58s ################################################################################ # Testing # Testing CrystalInfoContainers Status `/tmp/jl_ZTfFgy/Project.toml` [0536147b] CrystalInfoContainers v0.1.1 ⌅ [6007d9b0] CrystalInfoFramework v1.1.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_ZTfFgy/Manifest.toml` [34da2185] Compat v4.18.1 [a8cc5b0e] Crayons v4.1.1 [0536147b] CrystalInfoContainers v0.1.1 ⌅ [6007d9b0] CrystalInfoFramework v1.1.0 [9a962f9c] DataAPI v1.16.0 [a93c6f00] DataFrames v1.8.2 [864edb3b] DataStructures v0.19.5 [e2d170a0] DataValueInterfaces v1.0.0 [842dd82b] InlineStrings v1.4.5 [41ab1584] InvertedIndices v1.3.1 [82899510] IteratorInterfaceExtensions v1.0.0 [b964fa9f] LaTeXStrings v1.4.0 [d42ef402] Lerche v0.5.8 [1914dd2f] MacroTools v0.5.16 [e1d29d7a] Missings v1.2.0 ⌅ [bac558e1] OrderedCollections v1.8.2 [2dfb63ee] PooledArrays v1.4.3 [aea7be01] PrecompileTools v1.3.4 [21216c6a] Preferences v1.5.2 [08abe8d2] PrettyTables v3.3.2 [189a3867] Reexport v1.2.2 [91c51154] SentinelArrays v1.4.10 [a2af1166] SortingAlgorithms v1.2.2 [10745b16] Statistics v1.11.1 [892a3eda] StringManipulation v0.4.4 [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.1 [5c2747f8] URIs v1.6.1 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [7b1f6079] FileWatching v1.11.0 [9fa8497b] Future v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [de0858da] Printf v1.11.0 [3fa0cd96] REPL v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [6462fe0b] Sockets v1.11.0 [f489334b] StyledStrings v1.13.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.2+0 [4536629a] OpenBLAS_jll v0.3.33+0 [8e850b90] libblastrampoline_jll v5.15.0+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 ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("d42ef402-04e6-4356-9f73-091573ea58dc"), "Lerche") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) Stacktrace:  [1] error(s::String)  @ Base error.jl:56  [2] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base loading.jl:2837  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base loading.jl:2685  [4] macro expansion  @ loading.jl:2599 [inlined]  [5] macro expansion  @ lock.jl:376 [inlined]  [6] __require(into::Module, mod::Symbol)  @ Base loading.jl:2563  [7] require(into::Module, mod::Symbol)  @ Base loading.jl:2539 [inlined]  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)  @ Base module.jl:36 [inlined]  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)  @ Base module.jl:60  [10] _eval_using(to::Module, path::Expr, flags::UInt8)  @ Base module.jl:137 [inlined]  [11] eval_using(to::Module, path::Expr)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207  [12] top-level scope  @ ~/.julia/packages/CrystalInfoFramework/PJp1x/src/CrystalInfoFramework.jl:31  [13] include(mod::Module, _path::String)  @ Base Base.jl:326  [14] 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  [15] top-level scope  @ stdin:5  [16] eval(m::Module, e::Any)  @ Core boot.jl:521  [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [18] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [19] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [20] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/CrystalInfoFramework/PJp1x/src/CrystalInfoFramework.jl:21 in expression starting at stdin:5 ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("6007d9b0-c6b2-11e8-0510-1d10e825f3f1"), "CrystalInfoFramework") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) Stacktrace:  [1] error(s::String)  @ Base error.jl:56  [2] __require_prelocked(pkg::Base.PkgId, env::String)  @ Base loading.jl:2837  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)  @ Base loading.jl:2685  [4] macro expansion  @ loading.jl:2599 [inlined]  [5] macro expansion  @ lock.jl:376 [inlined]  [6] __require(into::Module, mod::Symbol)  @ Base loading.jl:2563  [7] require(into::Module, mod::Symbol)  @ Base loading.jl:2539 [inlined]  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)  @ Base module.jl:36 [inlined]  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)  @ Base module.jl:60  [10] _eval_using(to::Module, path::Expr, flags::UInt8)  @ Base module.jl:137 [inlined]  [11] eval_using(to::Module, path::Expr)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207  [12] top-level scope  @ ~/.julia/packages/CrystalInfoContainers/1uydM/src/CrystalInfoContainers.jl:27  [13] include(mod::Module, _path::String)  @ Base Base.jl:326  [14] 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  [15] top-level scope  @ stdin:5  [16] eval(m::Module, e::Any)  @ Core boot.jl:521  [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [18] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [19] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [20] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/CrystalInfoContainers/1uydM/src/CrystalInfoContainers.jl:21 in expression starting at stdin:5 3 dependencies had output during precompilation: ┌ CrystalInfoFramework │ ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("d42ef402-04e6-4356-9f73-091573ea58dc"), "Lerche") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0) │ Stacktrace: │ [1] error(s::String) │ @ Base error.jl:56 │ [2] __require_prelocked(pkg::Base.PkgId, env::String) │ @ Base loading.jl:2837 │ [3] _require_prelocked(uuidkey::Base.PkgId, env::String) │ @ Base loading.jl:2685 │ [4] macro expansion │ @ loading.jl:2599 [inlined] │ [5] macro expansion │ @ lock.jl:376 [inlined] │ [6] __require(into::Module, mod::Symbol) │ @ Base loading.jl:2563 │ [7] require(into::Module, mod::Symbol) │ @ Base loading.jl:2539 [inlined] │ [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String) │ @ Base module.jl:36 [inlined] │ [9] eval_import_path_all(at::Module, path::Expr, keyword::String) │ @ Base module.jl:60 │ [10] _eval_using(to::Module, path::Expr, flags::UInt8) │ @ Base module.jl:137 [inlined] │ [11] eval_using(to::Module, path::Expr) │ @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207 │ [12] top-level scope │ @ ~/.julia/packages/CrystalInfoFramework/PJp1x/src/CrystalInfoFramework.jl:31 │ [13] include(mod::Module, _path::String) │ @ Base Base.jl:326 │ [14] 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 │ [15] top-level scope │ @ stdin:5 │ [16] eval(m::Module, e::Any) │ @ Core boot.jl:521 │ [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String) │ @ Base loading.jl:3132 │ [18] include_string(m::Module, txt::String, fname::String) │ @ Base loading.jl:3142 [inlined] │ [19] exec_options(opts::Base.JLOptions) │ @ Base client.jl:353 │ [20] _start() │ @ Base client.jl:596 │ in expression starting at /home/pkgeval/.julia/packages/CrystalInfoFramework/PJp1x/src/CrystalInfoFramework.jl:21 │ in expression starting at stdin:5 └ ┌ Lerche │ ┌ 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 └ ┌ CrystalInfoContainers │ [Output was shown above] └ ERROR: LoadError: The following 3 packages failed to precompile: CrystalInfoFramework Failed to precompile CrystalInfoFramework [6007d9b0-c6b2-11e8-0510-1d10e825f3f1] to "/home/pkgeval/.julia/compiled/v1.14/CrystalInfoFramework/jl_oBO0F8" (ProcessExited(1)). Lerche Failed to precompile Lerche [d42ef402-04e6-4356-9f73-091573ea58dc] to "/home/pkgeval/.julia/compiled/v1.14/Lerche/jl_uEzfKh" (ProcessExited(1)). CrystalInfoContainers Failed to precompile CrystalInfoContainers [0536147b-35f3-46ba-bdca-9c2438f9daa4] to "/home/pkgeval/.julia/compiled/v1.14/CrystalInfoContainers/jl_qaGbdi" (ProcessExited(1)). in expression starting at /home/pkgeval/.julia/packages/CrystalInfoContainers/1uydM/test/runtests.jl:3 Testing failed after 230.27s ERROR: LoadError: Package CrystalInfoContainers 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 2382.55s: package fails to precompile